rig.h

Go to the documentation of this file.

/*
 *  Hamlib Interface - API header
 *  Copyright (c) 2000-2003 by Frank Singleton
 *  Copyright (c) 2000-2012 by Stephane Fillod
 *
 *
 *   This library is free software; you can redistribute it and/or
 *   modify it under the terms of the GNU Lesser General Public
 *   License as published by the Free Software Foundation; either
 *   version 2.1 of the License, or (at your option) any later version.
 *
 *   This library is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *   Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public
 *   License along with this library; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */
 
 
#ifndef _RIG_H
#define _RIG_H 1
 
#define __FILENAME__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
 
#include <stdio.h>
#include <stdarg.h>
#include <inttypes.h>
#include <time.h>
 
/* Rig list is in a separate file so as not to mess up w/ this one */
#include <hamlib/riglist.h>
 
/* __BEGIN_DECLS should be used at the beginning of your declarations,
 * so that C++ compilers don't mangle their names.  Use __END_DECLS at
 * the end of C declarations. */
#undef __BEGIN_DECLS
#undef __END_DECLS
#ifdef __cplusplus
#  define __BEGIN_DECLS extern "C" {
#  define __END_DECLS }
#else
#  define __BEGIN_DECLS      /* empty */
#  define __END_DECLS        /* empty */
#endif
 
/* HAMLIB_PARAMS is a macro used to wrap function prototypes, so that compilers
 * that don't understand ANSI C prototypes still work, and ANSI C
 * compilers can issue warnings about type mismatches. */
#undef HAMLIB_PARAMS
#if defined (__STDC__)                                                  \
    || defined (_AIX)                                                   \
    || (defined (__mips) && defined (_SYSTYPE_SVR4))                    \
    || defined(__CYGWIN__)                                              \
    || defined(_WIN32)                                                  \
    || defined(__cplusplus)
#  define HAMLIB_PARAMS(protos) protos
#  define rig_ptr_t     void *
#  define amp_ptr_t     void *
#else
#  define HAMLIB_PARAMS(protos) ()
#  define rig_ptr_t     char *
#  define amp_ptr_t     char *
#endif
 
#include <hamlib/rig_dll.h>
 
#ifndef SWIGLUA
#define CONSTANT_64BIT_FLAG(BIT) (1ull << (BIT))
#else
/* SWIG's older Lua generator doesn't grok ull due to Lua using a
   double-precision floating point type internally for number
   representations (max 53 bits of precision) so makes a string
   constant from a constant number literal using ull */
// #define CONSTANT_64BIT_FLAG(BIT) (1 << (BIT))
// #define SWIGLUAHIDE
/* But this appears to have been fixed so we'll use the correct one now 
   If you have the older version of SWIG comment out this line and use
   the two above */
// This 1ul definition works on swig 4.0.1 and lua 5.3.5
#define CONSTANT_64BIT_FLAG(BIT) (1ul << (BIT))
#endif
 
__BEGIN_DECLS
 
extern HAMLIB_EXPORT_VAR(const char) hamlib_version[];
extern HAMLIB_EXPORT_VAR(const char) hamlib_copyright[];
extern HAMLIB_EXPORT_VAR(const char *) hamlib_version2;
extern HAMLIB_EXPORT_VAR(const char *) hamlib_copyright2;
 
enum rig_errcode_e {
    RIG_OK = 0,     
    RIG_EINVAL,     
    RIG_ECONF,      
    RIG_ENOMEM,     
    RIG_ENIMPL,     
    RIG_ETIMEOUT,   
    RIG_EIO,        
    RIG_EINTERNAL,  
    RIG_EPROTO,     
    RIG_ERJCTED,    
    RIG_ETRUNC,     
    RIG_ENAVAIL,    
    RIG_ENTARGET,   
    RIG_BUSERROR,   
    RIG_BUSBUSY,    
    RIG_EARG,       
    RIG_EVFO,       
    RIG_EDOM        
};
 
#define NETRIGCTL_RET "RPRT "
 
 
enum rig_debug_level_e {
    RIG_DEBUG_NONE = 0, 
    RIG_DEBUG_BUG,      
    RIG_DEBUG_ERR,      
    RIG_DEBUG_WARN,     
    RIG_DEBUG_VERBOSE,  
    RIG_DEBUG_TRACE     
};
 
 
/* --------------- Rig capabilities -----------------*/
 
/* Forward struct references */
 
struct rig;
struct rig_state;
 
typedef struct s_rig RIG;
 
#define RIGNAMSIZ 30
#define RIGVERSIZ 8
#define FILPATHLEN 512
#define FRQRANGESIZ 30
#define MAXCHANDESC 30      /* describe channel eg: "WWV 5Mhz" */
#define TSLSTSIZ 20         /* max tuning step list size, zero ended */
#define FLTLSTSIZ 60        /* max mode/filter list size, zero ended */
#define MAXDBLSTSIZ 8       /* max preamp/att levels supported, zero ended */
#define CHANLSTSIZ 16       /* max mem_list size, zero ended */
#define MAX_CAL_LENGTH 32   /* max calibration plots in cal_table_t */
 
 
typedef unsigned int tone_t;
 
 
typedef enum rig_port_e {
    RIG_PORT_NONE = 0,      
    RIG_PORT_SERIAL,        
    RIG_PORT_NETWORK,       
    RIG_PORT_DEVICE,        
    RIG_PORT_PACKET,        
    RIG_PORT_DTMF,          
    RIG_PORT_ULTRA,         
    RIG_PORT_RPC,           
    RIG_PORT_PARALLEL,      
    RIG_PORT_USB,           
    RIG_PORT_UDP_NETWORK,   
    RIG_PORT_CM108,         
    RIG_PORT_GPIO,          
    RIG_PORT_GPION,         
} rig_port_t;
 
 
enum serial_parity_e {
    RIG_PARITY_NONE = 0,    
    RIG_PARITY_ODD,         
    RIG_PARITY_EVEN,        
    RIG_PARITY_MARK,        
    RIG_PARITY_SPACE        
};
 
 
enum serial_handshake_e {
    RIG_HANDSHAKE_NONE = 0, 
    RIG_HANDSHAKE_XONXOFF,  
    RIG_HANDSHAKE_HARDWARE  
};
 
 
enum serial_control_state_e {
    RIG_SIGNAL_UNSET = 0,   
    RIG_SIGNAL_ON,          
    RIG_SIGNAL_OFF          
};
 
 
typedef enum {
    RIG_FLAG_RECEIVER = (1 << 1),       
    RIG_FLAG_TRANSMITTER = (1 << 2),    
    RIG_FLAG_SCANNER = (1 << 3),        
    RIG_FLAG_MOBILE = (1 << 4),         
    RIG_FLAG_HANDHELD = (1 << 5),       
    RIG_FLAG_COMPUTER = (1 << 6),       
    RIG_FLAG_TRUNKING = (1 << 7),       
    RIG_FLAG_APRS = (1 << 8),           
    RIG_FLAG_TNC = (1 << 9),            
    RIG_FLAG_DXCLUSTER = (1 << 10),     
    RIG_FLAG_TUNER = (1 << 11)          
} rig_type_t;
 
#define RIG_FLAG_TRANSCEIVER (RIG_FLAG_RECEIVER|RIG_FLAG_TRANSMITTER)
#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)
 
#define RIG_TYPE_OTHER      0
#define RIG_TYPE_TRANSCEIVER    RIG_FLAG_TRANSCEIVER
#define RIG_TYPE_HANDHELD       (RIG_FLAG_TRANSCEIVER|RIG_FLAG_HANDHELD)
#define RIG_TYPE_MOBILE         (RIG_FLAG_TRANSCEIVER|RIG_FLAG_MOBILE)
#define RIG_TYPE_RECEIVER       RIG_FLAG_RECEIVER
#define RIG_TYPE_PCRECEIVER     (RIG_FLAG_COMPUTER|RIG_FLAG_RECEIVER)
#define RIG_TYPE_SCANNER        (RIG_FLAG_SCANNER|RIG_FLAG_RECEIVER)
#define RIG_TYPE_TRUNKSCANNER   (RIG_TYPE_SCANNER|RIG_FLAG_TRUNKING)
#define RIG_TYPE_COMPUTER       (RIG_FLAG_TRANSCEIVER|RIG_FLAG_COMPUTER)
#define RIG_TYPE_TUNER          RIG_FLAG_TUNER
 
 
enum rig_status_e {
    RIG_STATUS_ALPHA = 0,   
    RIG_STATUS_UNTESTED,    
    RIG_STATUS_BETA,        
    RIG_STATUS_STABLE,      
    RIG_STATUS_BUGGY        
    /* RIG_STATUS_NEW  *     *!< Initial release of code
     * !! Use of RIG_STATUS_NEW is deprecated. Do not use it anymore */
};
 
#define RIG_STATUS_NEW  RIG_STATUS_UNTESTED
 
 
typedef enum {
    RIG_RPT_SHIFT_NONE = 0, 
    RIG_RPT_SHIFT_MINUS,    
    RIG_RPT_SHIFT_PLUS      
} rptr_shift_t;
 
 
typedef enum {
    RIG_SPLIT_OFF = 0,  
    RIG_SPLIT_ON        
} split_t;
 
 
typedef double freq_t;
 
#define PRIfreq "f"
 
#define SCNfreq "lf"
#define FREQFMT SCNfreq
 
 
typedef signed long shortfreq_t;
 
#define Hz(f)   ((freq_t)(f))
#define kHz(f)  ((freq_t)((f)*(freq_t)1000))
#define MHz(f)  ((freq_t)((f)*(freq_t)1000000))
#define GHz(f)  ((freq_t)((f)*(freq_t)1000000000))
 
#define s_Hz(f)     ((shortfreq_t)(f))
#define s_kHz(f)    ((shortfreq_t)((f)*(shortfreq_t)1000))
#define s_MHz(f)    ((shortfreq_t)((f)*(shortfreq_t)1000000))
#define s_GHz(f)    ((shortfreq_t)((f)*(shortfreq_t)1000000000))
 
#define RIG_FREQ_NONE Hz(0)
 
 
typedef unsigned int vfo_t;
 
#define RIG_VFO_N(n)        (1u<<(n))
 
#define RIG_VFO_NONE        0
 
#define RIG_VFO_A           RIG_VFO_N(0)
 
#define RIG_VFO_B           RIG_VFO_N(1)
 
#define RIG_VFO_C           RIG_VFO_N(2)
 
// Any addition VFOS need to go from 3-20
// To maintain backward compatibility these values cannot change
 
#define RIG_VFO_SUB_A       RIG_VFO_N(21)
 
#define RIG_VFO_SUB_B       RIG_VFO_N(22)
 
#define RIG_VFO_MAIN_A      RIG_VFO_N(23)
 
#define RIG_VFO_MAIN_B      RIG_VFO_N(24)
 
#define RIG_VFO_SUB         RIG_VFO_N(25)
 
#define RIG_VFO_MAIN        RIG_VFO_N(26)
 
#define RIG_VFO_VFO         RIG_VFO_N(27)
 
#define RIG_VFO_MEM         RIG_VFO_N(28)
 
#define RIG_VFO_CURR        RIG_VFO_N(29)
 
#define RIG_VFO_TX_FLAG     RIG_VFO_N(30)
// we and also use RIG_VFO_N(31) if needed
 
// Misc VFO Macros
 
#define RIG_VFO_TX_VFO(v)   ((v)|RIG_VFO_TX_FLAG)
 
#define RIG_VFO_TX          RIG_VFO_TX_VFO(RIG_VFO_CURR)
 
#define RIG_VFO_RX          RIG_VFO_CURR
 
 
/*
 * targetable bitfields, for internal use.
 * RIG_TARGETABLE_PURE means a pure targetable radio on every command
 * In rig.c lack of a flag will case a VFO change if needed
 * So setting this flag will mean the backend handles any VFO needs
 * For many rigs RITXIT, PTT, MEM, and BANK are non-VFO commands so need these flags to avoid unnecessary VFO swapping
 */
#define RIG_TARGETABLE_NONE 0
#define RIG_TARGETABLE_FREQ (1<<0)
#define RIG_TARGETABLE_MODE (1<<1)
#define RIG_TARGETABLE_PURE (1<<2)
#define RIG_TARGETABLE_TONE (1<<3)
#define RIG_TARGETABLE_FUNC (1<<4)
#define RIG_TARGETABLE_LEVEL (1<<5)
#define RIG_TARGETABLE_RITXIT (1<<6)
#define RIG_TARGETABLE_PTT (1<<7)
#define RIG_TARGETABLE_MEM (1<<8)
#define RIG_TARGETABLE_BANK (1<<9)
#define RIG_TARGETABLE_ANT (1<<10)
#define RIG_TARGETABLE_COMMON (RIG_TARGETABLE_RITXIT | RIG_TARGETABLE_PTT | RIG_TARGETABLE_MEM | RIG_TARGETABLE_BANK)
#define RIG_TARGETABLE_ALL  0x7fffffff
//
//
// Newer Icoms like the 9700 and 910 have VFOA/B on both Main & Sub
// Compared to older rigs which have one or the other
// So we need to distinguish between them
#define VFO_HAS_A_B ((rig->state.vfo_list & (RIG_VFO_A|RIG_VFO_B)) == (RIG_VFO_A|RIG_VFO_B))
#define VFO_HAS_MAIN_SUB ((rig->state.vfo_list & (RIG_VFO_MAIN|RIG_VFO_SUB)) == (RIG_VFO_MAIN|RIG_VFO_SUB))
#define VFO_HAS_MAIN_SUB_ONLY ((!VFO_HAS_A_B) & VFO_HAS_MAIN_SUB)
#define VFO_HAS_MAIN_SUB_A_B_ONLY (VFO_HAS_A_B & VFO_HAS_MAIN_SUB)
#define VFO_HAS_A_B_ONLY (VFO_HAS_A_B & (!VFO_HAS_MAIN_SUB))
#define VFO_DUAL (RIG_VFO_MAIN_A|RIG_VFO_MAIN_B|RIG_VFO_SUB_A|RIG_VFO_SUB_B)
#define VFO_HAS_DUAL ((rig->state.vfo_list & VFO_DUAL == VFO_DUAL)
 
#define RIG_PASSBAND_NORMAL     s_Hz(0)
 
#define RIG_PASSBAND_NOCHANGE   s_Hz(-1)
 
typedef shortfreq_t pbwidth_t;
 
 
typedef enum dcd_e {
    RIG_DCD_OFF = 0,    
    RIG_DCD_ON          
} dcd_t;
 
 
typedef enum {
    RIG_DCD_NONE = 0,   
    RIG_DCD_RIG,        
    RIG_DCD_SERIAL_DSR, 
    RIG_DCD_SERIAL_CTS, 
    RIG_DCD_SERIAL_CAR, 
    RIG_DCD_PARALLEL,   
    RIG_DCD_CM108,      
    RIG_DCD_GPIO,       
    RIG_DCD_GPION,      
} dcd_type_t;
 
 
typedef enum {
    RIG_PTT_OFF = 0,    
    RIG_PTT_ON,         
    RIG_PTT_ON_MIC,     
    RIG_PTT_ON_DATA     
} ptt_t;
 
 
typedef enum {
    RIG_PTT_NONE = 0,       
    RIG_PTT_RIG,            
    RIG_PTT_SERIAL_DTR,     
    RIG_PTT_SERIAL_RTS,     
    RIG_PTT_PARALLEL,       
    RIG_PTT_RIG_MICDATA,    
    RIG_PTT_CM108,          
    RIG_PTT_GPIO,           
    RIG_PTT_GPION,          
} ptt_type_t;
 
 
typedef enum {
    RIG_POWER_OFF =     0,          
    RIG_POWER_ON =      (1 << 0),   
    RIG_POWER_STANDBY = (1 << 1),   
    RIG_POWER_OPERATE = (1 << 2),   
    RIG_POWER_UNKNOWN = (1 << 3)    
} powerstat_t;
 
 
typedef enum {
    RIG_RESET_NONE =    0,          
    RIG_RESET_SOFT =    (1 << 0),   
    RIG_RESET_VFO =     (1 << 1),   
    RIG_RESET_MCALL =   (1 << 2),   
    RIG_RESET_MASTER =  (1 << 3)    
} reset_t;
 
 
typedef enum {
    RIG_OP_NONE =       0,          
    RIG_OP_CPY =        (1 << 0),   
    RIG_OP_XCHG =       (1 << 1),   
    RIG_OP_FROM_VFO =   (1 << 2),   
    RIG_OP_TO_VFO =     (1 << 3),   
    RIG_OP_MCL =        (1 << 4),   
    RIG_OP_UP =         (1 << 5),   
    RIG_OP_DOWN =       (1 << 6),   
    RIG_OP_BAND_UP =    (1 << 7),   
    RIG_OP_BAND_DOWN =  (1 << 8),   
    RIG_OP_LEFT =       (1 << 9),   
    RIG_OP_RIGHT =      (1 << 10),  
    RIG_OP_TUNE =       (1 << 11),  
    RIG_OP_TOGGLE =     (1 << 12)   
} vfo_op_t;
 
 
typedef enum {
    RIG_SCAN_NONE =     0,          
    RIG_SCAN_MEM =      (1 << 0),   
    RIG_SCAN_SLCT =     (1 << 1),   
    RIG_SCAN_PRIO =     (1 << 2),   
    RIG_SCAN_PROG =     (1 << 3),   
    RIG_SCAN_DELTA =    (1 << 4),   
    RIG_SCAN_VFO =      (1 << 5),   
    RIG_SCAN_PLT =      (1 << 6),   
    RIG_SCAN_STOP =     (1 << 7)    
} scan_t;
 
 
typedef long token_t;
 
 
#define RIG_CONF_END 0
 
 
/* strongly inspired from soundmodem. Thanks Thomas! */
enum rig_conf_e {
    RIG_CONF_STRING,        
    RIG_CONF_COMBO,         
    RIG_CONF_NUMERIC,       
    RIG_CONF_CHECKBUTTON,   
    RIG_CONF_BUTTON,        
    RIG_CONF_BINARY         
};
 
#define RIG_COMBO_MAX   16
#define RIG_BIN_MAX  80
 
struct confparams {
    token_t token;          
    const char *name;       
    const char *label;      
    const char *tooltip;    
    const char *dflt;       
    enum rig_conf_e type;   
    union {                 
        struct {            
            float min;      
            float max;      
            float step;     
        } n;                
        struct {            
            const char *combostr[RIG_COMBO_MAX];    
        } c;                
    } u;                    
};
 
 
typedef enum {
    RIG_ANN_NONE =      0,              
    RIG_ANN_OFF =       RIG_ANN_NONE,   
    RIG_ANN_FREQ =      (1 << 0),       
    RIG_ANN_RXMODE =    (1 << 1),       
    RIG_ANN_CW =        (1 << 2),       
    RIG_ANN_ENG =       (1 << 3),       
    RIG_ANN_JAP =       (1 << 4)        
} ann_t;
 
 
typedef unsigned int ant_t;
 
#define RIG_ANT_NONE    0
#define RIG_ANT_N(n)    ((ant_t)1<<(n))
#define RIG_ANT_1       RIG_ANT_N(0)
#define RIG_ANT_2       RIG_ANT_N(1)
#define RIG_ANT_3       RIG_ANT_N(2)
#define RIG_ANT_4       RIG_ANT_N(3)
#define RIG_ANT_5       RIG_ANT_N(4)
 
#define RIG_ANT_UNKNOWN RIG_ANT_N(30)
#define RIG_ANT_CURR    RIG_ANT_N(31)
 
#define RIG_ANT_MAX 32
 
 
/* TODO: kill me, and replace by real AGC delay */
enum agc_level_e {
    RIG_AGC_OFF =       0,
    RIG_AGC_SUPERFAST,
    RIG_AGC_FAST,
    RIG_AGC_SLOW,
    RIG_AGC_USER,           
    RIG_AGC_MEDIUM,
    RIG_AGC_AUTO
};
 
#define RIG_AGC_LAST RIG_AGC_AUTO
 
enum meter_level_e {
    RIG_METER_NONE =    0,          /*< No display meter */
    RIG_METER_SWR =     (1 << 0),   /*< Stationary Wave Ratio */
    RIG_METER_COMP =    (1 << 1),   /*< Compression level */
    RIG_METER_ALC =     (1 << 2),   /*< ALC */
    RIG_METER_IC =      (1 << 3),   /*< IC */
    RIG_METER_DB =      (1 << 4),   /*< DB */
    RIG_METER_PO =      (1 << 5),   /*< Power Out */
    RIG_METER_VDD =     (1 << 6),   /*< Final Amp Voltage */
    RIG_METER_TEMP =    (1 << 7)    /*< Final Amp Voltage */
};
 
 
typedef union {
    signed int i;       
    float f;            
    char *s;            
    const char *cs;     
    struct {
        int l;          
        unsigned char *d; /* Pointer to data buffer */
    } b;
} value_t;
 
 
typedef uint64_t rig_level_e;
#define RIG_LEVEL_NONE       0              
#define RIG_LEVEL_PREAMP     CONSTANT_64BIT_FLAG(0)       
#define RIG_LEVEL_ATT        CONSTANT_64BIT_FLAG(1)       
#define RIG_LEVEL_VOXDELAY   CONSTANT_64BIT_FLAG(2)       
#define RIG_LEVEL_AF         CONSTANT_64BIT_FLAG(3)       
#define RIG_LEVEL_RF         CONSTANT_64BIT_FLAG(4)       
#define RIG_LEVEL_SQL        CONSTANT_64BIT_FLAG(5)       
#define RIG_LEVEL_IF         CONSTANT_64BIT_FLAG(6)       
#define RIG_LEVEL_APF        CONSTANT_64BIT_FLAG(7)       
#define RIG_LEVEL_NR         CONSTANT_64BIT_FLAG(8)       
#define RIG_LEVEL_PBT_IN     CONSTANT_64BIT_FLAG(9)       
#define RIG_LEVEL_PBT_OUT    CONSTANT_64BIT_FLAG(10)      
#define RIG_LEVEL_CWPITCH    CONSTANT_64BIT_FLAG(11)      
#define RIG_LEVEL_RFPOWER    CONSTANT_64BIT_FLAG(12)      
#define RIG_LEVEL_MICGAIN    CONSTANT_64BIT_FLAG(13)      
#define RIG_LEVEL_KEYSPD     CONSTANT_64BIT_FLAG(14)      
#define RIG_LEVEL_NOTCHF     CONSTANT_64BIT_FLAG(15)      
#define RIG_LEVEL_COMP       CONSTANT_64BIT_FLAG(16)      
#define RIG_LEVEL_AGC        CONSTANT_64BIT_FLAG(17)      
#define RIG_LEVEL_BKINDL     CONSTANT_64BIT_FLAG(18)      
#define RIG_LEVEL_BALANCE    CONSTANT_64BIT_FLAG(19)      
#define RIG_LEVEL_METER      CONSTANT_64BIT_FLAG(20)      
#define RIG_LEVEL_VOXGAIN    CONSTANT_64BIT_FLAG(21)      
#define RIG_LEVEL_ANTIVOX    CONSTANT_64BIT_FLAG(22)      
#define RIG_LEVEL_SLOPE_LOW  CONSTANT_64BIT_FLAG(23)      
#define RIG_LEVEL_SLOPE_HIGH CONSTANT_64BIT_FLAG(24)      
#define RIG_LEVEL_BKIN_DLYMS CONSTANT_64BIT_FLAG(25)      
#define RIG_LEVEL_RAWSTR     CONSTANT_64BIT_FLAG(26)      
#define RIG_LEVEL_SQLSTAT    CONSTANT_64BIT_FLAG(27)      
#define RIG_LEVEL_SWR        CONSTANT_64BIT_FLAG(28)      
#define RIG_LEVEL_ALC        CONSTANT_64BIT_FLAG(29)      
#define RIG_LEVEL_STRENGTH   CONSTANT_64BIT_FLAG(30)      
    /* RIG_LEVEL_BWC        (1<<31) */        
#define RIG_LEVEL_RFPOWER_METER  CONSTANT_64BIT_FLAG(32)      
#define RIG_LEVEL_COMP_METER   CONSTANT_64BIT_FLAG(33)      
#define RIG_LEVEL_VD_METER     CONSTANT_64BIT_FLAG(34)      
#define RIG_LEVEL_ID_METER     CONSTANT_64BIT_FLAG(35)      
#define RIG_LEVEL_NOTCHF_RAW   CONSTANT_64BIT_FLAG(36)      
#define RIG_LEVEL_MONITOR_GAIN CONSTANT_64BIT_FLAG(37)      
#define RIG_LEVEL_NB           CONSTANT_64BIT_FLAG(38)      
#define RIG_LEVEL_RFPOWER_METER_WATTS  CONSTANT_64BIT_FLAG(39)      
#define RIG_LEVEL_40           CONSTANT_64BIT_FLAG(40)      
#define RIG_LEVEL_41           CONSTANT_64BIT_FLAG(41)      
#define RIG_LEVEL_42           CONSTANT_64BIT_FLAG(42)      
#define RIG_LEVEL_43           CONSTANT_64BIT_FLAG(43)      
#define RIG_LEVEL_44           CONSTANT_64BIT_FLAG(44)      
#define RIG_LEVEL_45           CONSTANT_64BIT_FLAG(45)      
#define RIG_LEVEL_46           CONSTANT_64BIT_FLAG(46)      
#define RIG_LEVEL_47           CONSTANT_64BIT_FLAG(47)      
#define RIG_LEVEL_48           CONSTANT_64BIT_FLAG(48)      
#define RIG_LEVEL_49           CONSTANT_64BIT_FLAG(49)      
#define RIG_LEVEL_50           CONSTANT_64BIT_FLAG(50)      
#define RIG_LEVEL_51           CONSTANT_64BIT_FLAG(51)      
#define RIG_LEVEL_52           CONSTANT_64BIT_FLAG(52)      
#define RIG_LEVEL_53           CONSTANT_64BIT_FLAG(53)      
#define RIG_LEVEL_54           CONSTANT_64BIT_FLAG(54)      
#define RIG_LEVEL_55           CONSTANT_64BIT_FLAG(55)      
#define RIG_LEVEL_56           CONSTANT_64BIT_FLAG(56)      
#define RIG_LEVEL_57           CONSTANT_64BIT_FLAG(57)      
#define RIG_LEVEL_58           CONSTANT_64BIT_FLAG(58)      
#define RIG_LEVEL_59           CONSTANT_64BIT_FLAG(59)      
#define RIG_LEVEL_60           CONSTANT_64BIT_FLAG(60)      
#define RIG_LEVEL_61           CONSTANT_64BIT_FLAG(61)      
#define RIG_LEVEL_62           CONSTANT_64BIT_FLAG(62)      
#define RIG_LEVEL_63           CONSTANT_64BIT_FLAG(63)      
#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|RIG_LEVEL_RFPOWER_METER|RIG_LEVEL_RFPOWER_METER_WATTS|RIG_LEVEL_COMP_METER|RIG_LEVEL_VD_METER|RIG_LEVEL_ID_METER|RIG_LEVEL_NOTCHF_RAW|RIG_LEVEL_MONITOR_GAIN|RIG_LEVEL_NB)
 
#define RIG_LEVEL_READONLY_LIST (RIG_LEVEL_SQLSTAT|RIG_LEVEL_SWR|RIG_LEVEL_ALC|RIG_LEVEL_STRENGTH|RIG_LEVEL_RAWSTR|RIG_LEVEL_RFPOWER_METER|RIG_LEVEL_COMP_METER|RIG_LEVEL_VD_METER|RIG_LEVEL_ID_METER)
 
#define RIG_LEVEL_IS_FLOAT(l) ((l)&RIG_LEVEL_FLOAT_LIST)
#define RIG_LEVEL_SET(l) ((l)&~RIG_LEVEL_READONLY_LIST)
 
 
enum rig_parm_e {
    RIG_PARM_NONE =         0,          
    RIG_PARM_ANN =          (1 << 0),   
    RIG_PARM_APO =          (1 << 1),   
    RIG_PARM_BACKLIGHT =    (1 << 2),   
    RIG_PARM_BEEP =         (1 << 4),   
    RIG_PARM_TIME =         (1 << 5),   
    RIG_PARM_BAT =          (1 << 6),   
    RIG_PARM_KEYLIGHT =     (1 << 7),   
    RIG_PARM_SCREENSAVER =  (1 << 8)    
};
 
#define RIG_PARM_FLOAT_LIST (RIG_PARM_BACKLIGHT|RIG_PARM_BAT|RIG_PARM_KEYLIGHT)
#define RIG_PARM_READONLY_LIST (RIG_PARM_BAT)
 
#define RIG_PARM_IS_FLOAT(l) ((l)&RIG_PARM_FLOAT_LIST)
#define RIG_PARM_SET(l) ((l)&~RIG_PARM_READONLY_LIST)
 
typedef uint64_t setting_t;
 
#define RIG_SETTING_MAX 64
 
#define RIG_TRN_OFF 0
#define RIG_TRN_RIG 1
#define RIG_TRN_POLL 2
 
 
/*
 * The C standard dictates that an enum constant is a 32 bit signed integer.
 * Setting a constant's bit 31 created a negative value that on amd64 had the
 * upper 32 bits set as well when assigned to the misc.c:rig_func_str structure.
 * This caused misc.c:rig_strfunc() to fail its comparison for RIG_FUNC_XIT
 * on amd64 (x86_64).  To use bit 31 as an unsigned long, preprocessor macros
 * have been used instead as a 'const unsigned long' which cannot be used to
 * initialize the rig_func_str.func members.  TNX KA6MAL, AC6SL.  - N0NB
 */
#define RIG_FUNC_NONE       0                          
#define RIG_FUNC_FAGC       CONSTANT_64BIT_FLAG (0)    
#define RIG_FUNC_NB         CONSTANT_64BIT_FLAG (1)    
#define RIG_FUNC_COMP       CONSTANT_64BIT_FLAG (2)    
#define RIG_FUNC_VOX        CONSTANT_64BIT_FLAG (3)    
#define RIG_FUNC_TONE       CONSTANT_64BIT_FLAG (4)    
#define RIG_FUNC_TSQL       CONSTANT_64BIT_FLAG (5)    
#define RIG_FUNC_SBKIN      CONSTANT_64BIT_FLAG (6)    
#define RIG_FUNC_FBKIN      CONSTANT_64BIT_FLAG (7)    
#define RIG_FUNC_ANF        CONSTANT_64BIT_FLAG (8)    
#define RIG_FUNC_NR         CONSTANT_64BIT_FLAG (9)    
#define RIG_FUNC_AIP        CONSTANT_64BIT_FLAG (10)   
#define RIG_FUNC_APF        CONSTANT_64BIT_FLAG (11)   
#define RIG_FUNC_MON        CONSTANT_64BIT_FLAG (12)   
#define RIG_FUNC_MN         CONSTANT_64BIT_FLAG (13)   
#define RIG_FUNC_RF         CONSTANT_64BIT_FLAG (14)   
#define RIG_FUNC_ARO        CONSTANT_64BIT_FLAG (15)   
#define RIG_FUNC_LOCK       CONSTANT_64BIT_FLAG (16)   
#define RIG_FUNC_MUTE       CONSTANT_64BIT_FLAG (17)   
#define RIG_FUNC_VSC        CONSTANT_64BIT_FLAG (18)   
#define RIG_FUNC_REV        CONSTANT_64BIT_FLAG (19)   
#define RIG_FUNC_SQL        CONSTANT_64BIT_FLAG (20)   
#define RIG_FUNC_ABM        CONSTANT_64BIT_FLAG (21)   
#define RIG_FUNC_BC         CONSTANT_64BIT_FLAG (22)   
#define RIG_FUNC_MBC        CONSTANT_64BIT_FLAG (23)   
#define RIG_FUNC_RIT        CONSTANT_64BIT_FLAG (24)   
#define RIG_FUNC_AFC        CONSTANT_64BIT_FLAG (25)   
#define RIG_FUNC_SATMODE    CONSTANT_64BIT_FLAG (26)   
#define RIG_FUNC_SCOPE      CONSTANT_64BIT_FLAG (27)   
#define RIG_FUNC_RESUME     CONSTANT_64BIT_FLAG (28)   
#define RIG_FUNC_TBURST     CONSTANT_64BIT_FLAG (29)   
#define RIG_FUNC_TUNER      CONSTANT_64BIT_FLAG (30)   
#define RIG_FUNC_XIT        CONSTANT_64BIT_FLAG (31)   
#ifndef SWIGLUAHIDE
/* Hide the top 32 bits from the old Lua binding as they can't be represented */
#define RIG_FUNC_NB2        CONSTANT_64BIT_FLAG (32)   
#define RIG_FUNC_CSQL       CONSTANT_64BIT_FLAG (33)   
#define RIG_FUNC_AFLT       CONSTANT_64BIT_FLAG (34)   
#define RIG_FUNC_ANL        CONSTANT_64BIT_FLAG (35)   
#define RIG_FUNC_BC2        CONSTANT_64BIT_FLAG (36)   
#define RIG_FUNC_DUAL_WATCH CONSTANT_64BIT_FLAG (37)   
#define RIG_FUNC_DIVERSITY  CONSTANT_64BIT_FLAG (38)   
#define RIG_FUNC_DSQL       CONSTANT_64BIT_FLAG (39)   
#define RIG_FUNC_SCEN       CONSTANT_64BIT_FLAG (40)   
#define RIG_FUNC_BIT41      CONSTANT_64BIT_FLAG (41)   
#define RIG_FUNC_BIT42      CONSTANT_64BIT_FLAG (42)   
#define RIG_FUNC_BIT43      CONSTANT_64BIT_FLAG (43)   
#define RIG_FUNC_BIT44      CONSTANT_64BIT_FLAG (44)   
#define RIG_FUNC_BIT45      CONSTANT_64BIT_FLAG (45)   
#define RIG_FUNC_BIT46      CONSTANT_64BIT_FLAG (46)   
#define RIG_FUNC_BIT47      CONSTANT_64BIT_FLAG (47)   
#define RIG_FUNC_BIT48      CONSTANT_64BIT_FLAG (48)   
#define RIG_FUNC_BIT49      CONSTANT_64BIT_FLAG (49)   
#define RIG_FUNC_BIT50      CONSTANT_64BIT_FLAG (50)   
#define RIG_FUNC_BIT51      CONSTANT_64BIT_FLAG (51)   
#define RIG_FUNC_BIT52      CONSTANT_64BIT_FLAG (52)   
#define RIG_FUNC_BIT53      CONSTANT_64BIT_FLAG (53)   
#define RIG_FUNC_BIT54      CONSTANT_64BIT_FLAG (54)   
#define RIG_FUNC_BIT55      CONSTANT_64BIT_FLAG (55)   
#define RIG_FUNC_BIT56      CONSTANT_64BIT_FLAG (56)   
#define RIG_FUNC_BIT57      CONSTANT_64BIT_FLAG (57)   
#define RIG_FUNC_BIT58      CONSTANT_64BIT_FLAG (58)   
#define RIG_FUNC_BIT59      CONSTANT_64BIT_FLAG (59)   
#define RIG_FUNC_BIT60      CONSTANT_64BIT_FLAG (60)   
#define RIG_FUNC_BIT61      CONSTANT_64BIT_FLAG (61)   
#define RIG_FUNC_BIT62      CONSTANT_64BIT_FLAG (62)   
#define RIG_FUNC_BIT63      CONSTANT_64BIT_FLAG (63)   
/* 63 is this highest bit number that can be used */
#endif
 
#define mW(p)       ((int)(p))
#define Watts(p)    ((int)((p)*1000))
#define W(p)        Watts(p)
#if 0 // deprecating kW macro as this doesn't make sense
#define kW(p)       ((int)((p)*1000000L))
#endif
 
 
typedef uint64_t rmode_t;
 
#define    RIG_MODE_NONE      0                         
#define    RIG_MODE_AM        CONSTANT_64BIT_FLAG (0)   
#define    RIG_MODE_CW        CONSTANT_64BIT_FLAG (1)   
#define    RIG_MODE_USB       CONSTANT_64BIT_FLAG (2)   
#define    RIG_MODE_LSB       CONSTANT_64BIT_FLAG (3)   
#define    RIG_MODE_RTTY      CONSTANT_64BIT_FLAG (4)   
#define    RIG_MODE_FM        CONSTANT_64BIT_FLAG (5)   
#define    RIG_MODE_WFM       CONSTANT_64BIT_FLAG (6)   
#define    RIG_MODE_CWR       CONSTANT_64BIT_FLAG (7)   
#define    RIG_MODE_RTTYR     CONSTANT_64BIT_FLAG (8)   
#define    RIG_MODE_AMS       CONSTANT_64BIT_FLAG (9)   
#define    RIG_MODE_PKTLSB    CONSTANT_64BIT_FLAG (10)  
#define    RIG_MODE_PKTUSB    CONSTANT_64BIT_FLAG (11)  
#define    RIG_MODE_PKTFM     CONSTANT_64BIT_FLAG (12)  
#define    RIG_MODE_ECSSUSB   CONSTANT_64BIT_FLAG (13)  
#define    RIG_MODE_ECSSLSB   CONSTANT_64BIT_FLAG (14)  
#define    RIG_MODE_FAX       CONSTANT_64BIT_FLAG (15)  
#define    RIG_MODE_SAM       CONSTANT_64BIT_FLAG (16)  
#define    RIG_MODE_SAL       CONSTANT_64BIT_FLAG (17)  
#define    RIG_MODE_SAH       CONSTANT_64BIT_FLAG (18)  
#define    RIG_MODE_DSB       CONSTANT_64BIT_FLAG (19)  
#define    RIG_MODE_FMN       CONSTANT_64BIT_FLAG (21)  
#define    RIG_MODE_PKTAM     CONSTANT_64BIT_FLAG (22)  
#define    RIG_MODE_P25       CONSTANT_64BIT_FLAG (23)  
#define    RIG_MODE_DSTAR     CONSTANT_64BIT_FLAG (24)  
#define    RIG_MODE_DPMR      CONSTANT_64BIT_FLAG (25)  
#define    RIG_MODE_NXDNVN    CONSTANT_64BIT_FLAG (26)  
#define    RIG_MODE_NXDN_N    CONSTANT_64BIT_FLAG (27)  
#define    RIG_MODE_DCR       CONSTANT_64BIT_FLAG (28)  
#define    RIG_MODE_AMN       CONSTANT_64BIT_FLAG (29)  
#define    RIG_MODE_PSK       CONSTANT_64BIT_FLAG (30)  
#define    RIG_MODE_PSKR      CONSTANT_64BIT_FLAG (31)  
#ifndef SWIGLUAHIDE
/* hide the top 32 bits from the Lua binding as they will not work */
#define    RIG_MODE_DD        CONSTANT_64BIT_FLAG (32)  
#define    RIG_MODE_C4FM      CONSTANT_64BIT_FLAG (33)  
#define    RIG_MODE_PKTFMN    CONSTANT_64BIT_FLAG (34)  
#define    RIG_MODE_SPEC      CONSTANT_64BIT_FLAG (35)  
#define    RIG_MODE_BIT36     CONSTANT_64BIT_FLAG (36)  
#define    RIG_MODE_BIT37     CONSTANT_64BIT_FLAG (37)  
#define    RIG_MODE_BIT38     CONSTANT_64BIT_FLAG (38)  
#define    RIG_MODE_BIT39     CONSTANT_64BIT_FLAG (39)  
#define    RIG_MODE_BIT40     CONSTANT_64BIT_FLAG (40)  
#define    RIG_MODE_BIT41     CONSTANT_64BIT_FLAG (41)  
#define    RIG_MODE_BIT42     CONSTANT_64BIT_FLAG (42)  
#define    RIG_MODE_BIT43     CONSTANT_64BIT_FLAG (43)  
#define    RIG_MODE_BIT44     CONSTANT_64BIT_FLAG (44)  
#define    RIG_MODE_BIT45     CONSTANT_64BIT_FLAG (45)  
#define    RIG_MODE_BIT46     CONSTANT_64BIT_FLAG (46)  
#define    RIG_MODE_BIT47     CONSTANT_64BIT_FLAG (47)  
#define    RIG_MODE_BIT48     CONSTANT_64BIT_FLAG (48)  
#define    RIG_MODE_BIT49     CONSTANT_64BIT_FLAG (49)  
#define    RIG_MODE_BIT50     CONSTANT_64BIT_FLAG (50)  
#define    RIG_MODE_BIT51     CONSTANT_64BIT_FLAG (51)  
#define    RIG_MODE_BIT52     CONSTANT_64BIT_FLAG (52)  
#define    RIG_MODE_BIT53     CONSTANT_64BIT_FLAG (53)  
#define    RIG_MODE_BIT54     CONSTANT_64BIT_FLAG (54)  
#define    RIG_MODE_BIT55     CONSTANT_64BIT_FLAG (55)  
#define    RIG_MODE_BIT56     CONSTANT_64BIT_FLAG (56)  
#define    RIG_MODE_BIT57     CONSTANT_64BIT_FLAG (57)  
#define    RIG_MODE_BIT58     CONSTANT_64BIT_FLAG (58)  
#define    RIG_MODE_BIT59     CONSTANT_64BIT_FLAG (59)  
#define    RIG_MODE_BIT60     CONSTANT_64BIT_FLAG (60)  
#define    RIG_MODE_BIT61     CONSTANT_64BIT_FLAG (61)  
#define    RIG_MODE_BIT62     CONSTANT_64BIT_FLAG (62)  
#define    RIG_MODE_TESTS_MAX CONSTANT_64BIT_FLAG (63)  
#endif
 
#define RIG_MODE_SSB    (RIG_MODE_USB|RIG_MODE_LSB)
 
#define RIG_MODE_ECSS   (RIG_MODE_ECSSUSB|RIG_MODE_ECSSLSB)
 
#define RIG_DBLST_END 0     /* end marker in a preamp/att level list */
#define RIG_IS_DBLST_END(d) ((d)==0)
 
 
typedef struct freq_range_list {
    freq_t startf;      
    freq_t endf;        
    rmode_t modes;      
    int low_power;      
    int high_power;     
    vfo_t vfo;          
    ant_t ant;          
    char *label;        
} freq_range_t;
 
#define RIG_FRNG_END        {Hz(0),Hz(0),RIG_MODE_NONE,0,0,RIG_VFO_NONE}
#define RIG_IS_FRNG_END(r)  ((r).startf == Hz(0) && (r).endf == Hz(0))
 
struct tuning_step_list {
    rmode_t modes;      
    shortfreq_t ts;     
};
 
#define RIG_TS_ANY          0
#define RIG_TS_END          {RIG_MODE_NONE, 0}
#define RIG_IS_TS_END(t)    ((t).modes == RIG_MODE_NONE && (t).ts == 0)
 
 
struct filter_list {
    rmode_t modes;      
    pbwidth_t width;    
};
#define RIG_FLT_ANY         0
#define RIG_FLT_END         {RIG_MODE_NONE, 0}
#define RIG_IS_FLT_END(f)   ((f).modes == RIG_MODE_NONE)
 
 
#define RIG_CHFLAG_NONE     0
#define RIG_CHFLAG_SKIP     (1<<0)
#define RIG_CHFLAG_DATA     (1<<1)
#define RIG_CHFLAG_PSKIP    (1<<2)
 
struct ext_list {
    token_t token;      
    value_t val;        
};
 
#define RIG_EXT_END     {0, {.i=0}}
#define RIG_IS_EXT_END(x)   ((x).token == 0)
 
struct channel {
    int channel_num;                    
    int bank_num;                       
    vfo_t vfo;                          
    ant_t ant;                            
    freq_t freq;                        
    rmode_t mode;                       
    pbwidth_t width;                    
    freq_t tx_freq;                     
    rmode_t tx_mode;                    
    pbwidth_t tx_width;                 
    split_t split;                      
    vfo_t tx_vfo;                       
    rptr_shift_t rptr_shift;            
    shortfreq_t rptr_offs;              
    shortfreq_t tuning_step;            
    shortfreq_t rit;                    
    shortfreq_t xit;                    
    setting_t funcs;                    
    value_t levels[RIG_SETTING_MAX];    
    tone_t ctcss_tone;                  
    tone_t ctcss_sql;                   
    tone_t dcs_code;                    
    tone_t dcs_sql;                     
    int scan_group;                     
    unsigned int flags;                 
    char channel_desc[MAXCHANDESC];     
    struct ext_list
            *ext_levels;                
};
 
typedef struct channel channel_t;
 
struct channel_cap {
    unsigned bank_num:      1;  
    unsigned vfo:           1;  
    unsigned ant:           1;  
    unsigned freq:          1;  
    unsigned mode:          1;  
    unsigned width:         1;  
    unsigned tx_freq:       1;  
    unsigned tx_mode:       1;  
    unsigned tx_width:      1;  
    unsigned split:         1;  
    unsigned tx_vfo:        1;  
    unsigned rptr_shift:    1;  
    unsigned rptr_offs:     1;  
    unsigned tuning_step:   1;  
    unsigned rit:           1;  
    unsigned xit:           1;  
    setting_t funcs;            
    setting_t levels;           
    unsigned ctcss_tone:    1;  
    unsigned ctcss_sql:     1;  
    unsigned dcs_code:      1;  
    unsigned dcs_sql:       1;  
    unsigned scan_group:    1;  
    unsigned flags:         1;  
    unsigned channel_desc:  1;  
    unsigned ext_levels:    1;  
};
 
typedef struct channel_cap channel_cap_t;
 
 
typedef enum {
    RIG_MTYPE_NONE =    0,  
    RIG_MTYPE_MEM,          
    RIG_MTYPE_EDGE,         
    RIG_MTYPE_CALL,         
    RIG_MTYPE_MEMOPAD,      
    RIG_MTYPE_SAT,          
    RIG_MTYPE_BAND,         
    RIG_MTYPE_PRIO          
} chan_type_t;
 
 
struct chan_list {
    int startc;          
    int endc;            
    chan_type_t type;   
    channel_cap_t
    mem_caps;           
};
 
#define RIG_CHAN_END        {0,0,RIG_MTYPE_NONE}
#define RIG_IS_CHAN_END(c)  ((c).type == RIG_MTYPE_NONE)
 
#define RIG_MEM_CAPS_ALL    -1
 
typedef struct chan_list chan_t;
 
 
struct gran {
    value_t min;        
    value_t max;        
    value_t step;       
};
 
typedef struct gran gran_t;
 
 
struct cal_table {
    int size;                   
    struct {
        int raw;                
        int val;                
    } table[MAX_CAL_LENGTH];    
};
 
typedef struct cal_table cal_table_t;
 
#define EMPTY_STR_CAL { 0, { { 0, 0 }, } }
 
 
struct cal_table_float {
  int size;                   
  struct {
    int raw;                  
    float val;                
  } table[MAX_CAL_LENGTH];    
};
 
typedef struct cal_table_float cal_table_float_t;
 
#define EMPTY_FLOAT_CAL { 0, { { 0, 0f }, } }
 
typedef int (* chan_cb_t)(RIG *, channel_t **, int, const chan_t *, rig_ptr_t);
typedef int (* confval_cb_t)(RIG *,
                             const struct confparams *,
                             value_t *,
                             rig_ptr_t);
 
 
#define RIG_MODEL(arg) .rig_model=arg,.macro_name=#arg
struct rig_caps {
    rig_model_t rig_model;      
    const char *model_name;     
    const char *mfg_name;       
    const char *version;        
    const char *copyright;      
    enum rig_status_e status;   
    int rig_type;               
    ptt_type_t ptt_type;        
    dcd_type_t dcd_type;        
    rig_port_t port_type;       
    int serial_rate_min;        
    int serial_rate_max;        
    int serial_data_bits;       
    int serial_stop_bits;       
    enum serial_parity_e serial_parity;         
    enum serial_handshake_e serial_handshake;   
    int write_delay;            
    int post_write_delay;       
    int timeout;                
    int retry;                  
    setting_t has_get_func;     
    setting_t has_set_func;     
    setting_t has_get_level;    
    setting_t has_set_level;    
    setting_t has_get_parm;     
    setting_t has_set_parm;     
    gran_t level_gran[RIG_SETTING_MAX]; 
    gran_t parm_gran[RIG_SETTING_MAX];  
    const struct confparams *extparms;  
    const struct confparams *extlevels; 
    const struct confparams *extfuncs; 
    int *ext_tokens;                    
    const tone_t *ctcss_list;   
    const tone_t *dcs_list;     
    int preamp[MAXDBLSTSIZ];    
    int attenuator[MAXDBLSTSIZ];    
    shortfreq_t max_rit;        
    shortfreq_t max_xit;        
    shortfreq_t max_ifshift;    
    ann_t announces;            
    vfo_op_t vfo_ops;           
    scan_t scan_ops;            
    int targetable_vfo;         
    int transceive;             
    int bank_qty;               
    int chan_desc_sz;           
    chan_t chan_list[CHANLSTSIZ];   
    // As of 2020-02-12 we know of 5 models from Icom USA, EUR, ITR, TPE, KOR for the IC-9700
    // So we currently have 5 ranges we need to deal with
    // The backend for the model should fill in the label field to explain what model it is
    // The the IC-9700 in ic7300.c for an example 
    freq_range_t rx_range_list1[FRQRANGESIZ];   
    freq_range_t tx_range_list1[FRQRANGESIZ];   
    freq_range_t rx_range_list2[FRQRANGESIZ];   
    freq_range_t tx_range_list2[FRQRANGESIZ];   
    freq_range_t rx_range_list3[FRQRANGESIZ];   
    freq_range_t tx_range_list3[FRQRANGESIZ];   
    freq_range_t rx_range_list4[FRQRANGESIZ];   
    freq_range_t tx_range_list4[FRQRANGESIZ];   
    freq_range_t rx_range_list5[FRQRANGESIZ];   
    freq_range_t tx_range_list5[FRQRANGESIZ];   
    struct tuning_step_list tuning_steps[TSLSTSIZ];     
    struct filter_list filters[FLTLSTSIZ];              
    cal_table_t str_cal;                    
    cal_table_float_t swr_cal;              
    cal_table_float_t alc_cal;              
    cal_table_float_t rfpower_meter_cal;    
    cal_table_float_t comp_meter_cal;       
    cal_table_float_t vd_meter_cal;         
    cal_table_float_t id_meter_cal;         
    const struct confparams *cfgparams; 
    const rig_ptr_t priv;               
    /*
     * Rig API
     *
     */
 
    int (*rig_init)(RIG *rig);
    int (*rig_cleanup)(RIG *rig);
    int (*rig_open)(RIG *rig);
    int (*rig_close)(RIG *rig);
 
    /*
     *  General API commands, from most primitive to least.. :()
     *  List Set/Get functions pairs
     */
 
    int (*set_freq)(RIG *rig, vfo_t vfo, freq_t freq);
    int (*get_freq)(RIG *rig, vfo_t vfo, freq_t *freq);
 
    int (*set_mode)(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width);
    int (*get_mode)(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width);
 
    int (*set_vfo)(RIG *rig, vfo_t vfo);
    int (*get_vfo)(RIG *rig, vfo_t *vfo);
 
    int (*set_ptt)(RIG *rig, vfo_t vfo, ptt_t ptt);
    int (*get_ptt)(RIG *rig, vfo_t vfo, ptt_t *ptt);
 
    int (*get_dcd)(RIG *rig, vfo_t vfo, dcd_t *dcd);
 
    int (*set_rptr_shift)(RIG *rig, vfo_t vfo, rptr_shift_t rptr_shift);
    int (*get_rptr_shift)(RIG *rig, vfo_t vfo, rptr_shift_t *rptr_shift);
 
    int (*set_rptr_offs)(RIG *rig, vfo_t vfo, shortfreq_t offs);
    int (*get_rptr_offs)(RIG *rig, vfo_t vfo, shortfreq_t *offs);
 
    int (*set_split_freq)(RIG *rig, vfo_t vfo, freq_t tx_freq);
    int (*get_split_freq)(RIG *rig, vfo_t vfo, freq_t *tx_freq);
 
    int (*set_split_mode)(RIG *rig,
                          vfo_t vfo,
                          rmode_t tx_mode,
                          pbwidth_t tx_width);
    int (*get_split_mode)(RIG *rig,
                          vfo_t vfo,
                          rmode_t *tx_mode,
                          pbwidth_t *tx_width);
 
    int (*set_split_freq_mode)(RIG *rig,
                               vfo_t vfo,
                               freq_t tx_freq,
                               rmode_t tx_mode,
                               pbwidth_t tx_width);
    int (*get_split_freq_mode)(RIG *rig,
                               vfo_t vfo,
                               freq_t *tx_freq,
                               rmode_t *tx_mode,
                               pbwidth_t *tx_width);
 
    int (*set_split_vfo)(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo);
    int (*get_split_vfo)(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vfo);
 
    int (*set_rit)(RIG *rig, vfo_t vfo, shortfreq_t rit);
    int (*get_rit)(RIG *rig, vfo_t vfo, shortfreq_t *rit);
 
    int (*set_xit)(RIG *rig, vfo_t vfo, shortfreq_t xit);
    int (*get_xit)(RIG *rig, vfo_t vfo, shortfreq_t *xit);
 
    int (*set_ts)(RIG *rig, vfo_t vfo, shortfreq_t ts);
    int (*get_ts)(RIG *rig, vfo_t vfo, shortfreq_t *ts);
 
    int (*set_dcs_code)(RIG *rig, vfo_t vfo, tone_t code);
    int (*get_dcs_code)(RIG *rig, vfo_t vfo, tone_t *code);
 
    int (*set_tone)(RIG *rig, vfo_t vfo, tone_t tone);
    int (*get_tone)(RIG *rig, vfo_t vfo, tone_t *tone);
 
    int (*set_ctcss_tone)(RIG *rig, vfo_t vfo, tone_t tone);
    int (*get_ctcss_tone)(RIG *rig, vfo_t vfo, tone_t *tone);
 
    int (*set_dcs_sql)(RIG *rig, vfo_t vfo, tone_t code);
    int (*get_dcs_sql)(RIG *rig, vfo_t vfo, tone_t *code);
 
    int (*set_tone_sql)(RIG *rig, vfo_t vfo, tone_t tone);
    int (*get_tone_sql)(RIG *rig, vfo_t vfo, tone_t *tone);
 
    int (*set_ctcss_sql)(RIG *rig, vfo_t vfo, tone_t tone);
    int (*get_ctcss_sql)(RIG *rig, vfo_t vfo, tone_t *tone);
 
    int (*power2mW)(RIG *rig,
                    unsigned int *mwpower,
                    float power,
                    freq_t freq,
                    rmode_t mode);
    int (*mW2power)(RIG *rig,
                    float *power,
                    unsigned int mwpower,
                    freq_t freq,
                    rmode_t mode);
 
    int (*set_powerstat)(RIG *rig, powerstat_t status);
    int (*get_powerstat)(RIG *rig, powerstat_t *status);
 
    int (*reset)(RIG *rig, reset_t reset);
 
    int (*set_ant)(RIG *rig, vfo_t vfo, ant_t ant, value_t option);
    int (*get_ant)(RIG *rig, vfo_t vfo, ant_t ant, value_t *option, ant_t *ant_curr, ant_t *ant_tx, ant_t *ant_rx);
 
    int (*set_level)(RIG *rig, vfo_t vfo, setting_t level, value_t val);
    int (*get_level)(RIG *rig, vfo_t vfo, setting_t level, value_t *val);
 
    int (*set_func)(RIG *rig, vfo_t vfo, setting_t func, int status);
    int (*get_func)(RIG *rig, vfo_t vfo, setting_t func, int *status);
 
    int (*set_parm)(RIG *rig, setting_t parm, value_t val);
    int (*get_parm)(RIG *rig, setting_t parm, value_t *val);
 
    int (*set_ext_level)(RIG *rig, vfo_t vfo, token_t token, value_t val);
    int (*get_ext_level)(RIG *rig, vfo_t vfo, token_t token, value_t *val);
 
    int (*set_ext_func)(RIG *rig, vfo_t vfo, token_t token, int status);
    int (*get_ext_func)(RIG *rig, vfo_t vfo, token_t token, int *status);
 
    int (*set_ext_parm)(RIG *rig, token_t token, value_t val);
    int (*get_ext_parm)(RIG *rig, token_t token, value_t *val);
 
    int (*set_conf)(RIG *rig, token_t token, const char *val);
    int (*get_conf)(RIG *rig, token_t token, char *val);
 
    int (*send_dtmf)(RIG *rig, vfo_t vfo, const char *digits);
    int (*recv_dtmf)(RIG *rig, vfo_t vfo, char *digits, int *length);
 
    int (*send_morse)(RIG *rig, vfo_t vfo, const char *msg);
    int (*stop_morse)(RIG *rig, vfo_t vfo);
    int (*wait_morse)(RIG *rig, vfo_t vfo);
 
    int (*send_voice_mem)(RIG *rig, vfo_t vfo, int ch);
 
    int (*set_bank)(RIG *rig, vfo_t vfo, int bank);
 
    int (*set_mem)(RIG *rig, vfo_t vfo, int ch);
    int (*get_mem)(RIG *rig, vfo_t vfo, int *ch);
 
    int (*vfo_op)(RIG *rig, vfo_t vfo, vfo_op_t op);
 
    int (*scan)(RIG *rig, vfo_t vfo, scan_t scan, int ch);
 
    int (*set_trn)(RIG *rig, int trn);
    int (*get_trn)(RIG *rig, int *trn);
 
    int (*decode_event)(RIG *rig);
 
    int (*set_channel)(RIG *rig, vfo_t vfo, const channel_t *chan);
    int (*get_channel)(RIG *rig, vfo_t vfo, channel_t *chan, int read_only);
 
    const char * (*get_info)(RIG *rig);
 
    int (*set_chan_all_cb)(RIG *rig, vfo_t vfo, chan_cb_t chan_cb, rig_ptr_t);
    int (*get_chan_all_cb)(RIG *rig, vfo_t vfo, chan_cb_t chan_cb, rig_ptr_t);
 
    int (*set_mem_all_cb)(RIG *rig,
                          chan_cb_t chan_cb,
                          confval_cb_t parm_cb,
                          rig_ptr_t);
    int (*get_mem_all_cb)(RIG *rig,
                          chan_cb_t chan_cb,
                          confval_cb_t parm_cb,
                          rig_ptr_t);
 
    int (*set_vfo_opt)(RIG *rig, int status); // only for Net Rigctl device
 
    const char *clone_combo_set;    
    const char *clone_combo_get;    
    const char *macro_name;     
};
 
// all functions enumerated for rig_get_function_ptr
enum rig_function_e {
    RIG_FUNCTION_INIT,
    RIG_FUNCTION_CLEANUP,
    RIG_FUNCTION_OPEN,
    RIG_FUNCTION_CLOSE,
    RIG_FUNCTION_SET_FREQ,
    RIG_FUNCTION_GET_FREQ,
    RIG_FUNCTION_SET_MODE,
    RIG_FUNCTION_GET_MODE,
    RIG_FUNCTION_SET_VFO,
    RIG_FUNCTION_GET_VFO,
    RIG_FUNCTION_SET_PTT,
    RIG_FUNCTION_GET_PTT,
    RIG_FUNCTION_GET_DCD,
    RIG_FUNCTION_SET_RPTR_SHIFT,
    RIG_FUNCTION_GET_RPTR_SHIFT,
    RIG_FUNCTION_SET_RPTR_OFFS,
    RIG_FUNCTION_GET_RPTR_OFFS,
    RIG_FUNCTION_SET_SPLIT_FREQ,
    RIG_FUNCTION_GET_SPLIT_FREQ,
    RIG_FUNCTION_SET_SPLIT_MODE,
    RIG_FUNCTION_SET_SPLIT_FREQ_MODE,
    RIG_FUNCTION_GET_SPLIT_FREQ_MODE,
    RIG_FUNCTION_SET_SPLIT_VFO,
    RIG_FUNCTION_GET_SPLIT_VFO,
    RIG_FUNCTION_SET_RIT,
    RIG_FUNCTION_GET_RIT,
    RIG_FUNCTION_SET_XIT,
    RIG_FUNCTION_GET_XIT,
    RIG_FUNCTION_SET_TS,
    RIG_FUNCTION_GET_TS,
    RIG_FUNCTION_SET_DCS_CODE,
    RIG_FUNCTION_GET_DCS_CODE,
    RIG_FUNCTION_SET_TONE,
    RIG_FUNCTION_GET_TONE,
    RIG_FUNCTION_SET_CTCSS_TONE,
    RIG_FUNCTION_GET_CTCSS_TONE,
    RIG_FUNCTION_SET_DCS_SQL,
    RIG_FUNCTION_GET_DCS_SQL,
    RIG_FUNCTION_SET_TONE_SQL,
    RIG_FUNCTION_GET_TONE_SQL,
    RIG_FUNCTION_SET_CTCSS_SQL,
    RIG_FUNCTION_GET_CTCSS_SQL,
    RIG_FUNCTION_POWER2MW,
    RIG_FUNCTION_MW2POWER,
    RIG_FUNCTION_SET_POWERSTAT,
    RIG_FUNCTION_GET_POWERSTAT,
    RIG_FUNCTION_RESET,
    RIG_FUNCTION_SET_ANT,
    RIG_FUNCTION_GET_ANT,
    RIG_FUNCTION_SET_LEVEL,
    RIG_FUNCTION_GET_LEVEL,
    RIG_FUNCTION_SET_FUNC,
    RIG_FUNCTION_GET_FUNC,
    RIG_FUNCTION_SET_PARM,
    RIG_FUNCTION_GET_PARM,
    RIG_FUNCTION_SET_EXT_LEVEL,
    RIG_FUNCTION_GET_EXT_LEVEL,
    RIG_FUNCTION_SET_EXT_FUNC,
    RIG_FUNCTION_GET_EXT_FUNC,
    RIG_FUNCTION_SET_EXT_PARM,
    RIG_FUNCTION_GET_EXT_PARM,
    RIG_FUNCTION_SET_CONF,
    RIG_FUNCTION_GET_CONF,
    RIG_FUNCTION_SEND_DTMF,
    RIG_FUNCTION_SEND_MORSE,
    RIG_FUNCTION_STOP_MORSE,
    RIG_FUNCTION_WAIT_MORSE,
    RIG_FUNCTION_SEND_VOICE_MEM,
    RIG_FUNCTION_SET_BANK,
    RIG_FUNCTION_SET_MEM,
    RIG_FUNCTION_GET_MEM,
    RIG_FUNCTION_VFO_OP,
    RIG_FUNCTION_SCAN,
    RIG_FUNCTION_SET_TRN,
    RIG_FUNCTION_GET_TRN,
    RIG_FUNCTION_DECODE_EVENT,
    RIG_FUNCTION_SET_CHANNEL,
    RIG_FUNCTION_GET_CHANNEL,
    RIG_FUNCTION_GET_INFO,
    RIG_FUNCTION_SET_CHAN_ALL_CB,
    RIG_FUNCTION_GET_CHAN_ALL_CB,
    RIG_FUNCTION_SET_MEM_ALL_CB,
    RIG_FUNCTION_GET_MEM_ALL_CB,
    RIG_FUNCTION_SET_VFO_OPT
};
 
extern void *rig_get_function_ptr(rig_model_t rig_model, enum rig_function_e rig_function);
 
// values enumerated for rig->caps values
enum rig_caps_int_e {
    RIG_CAPS_TARGETABLE_VFO,
    RIG_CAPS_RIG_MODEL,
    RIG_CAPS_PORT_TYPE,
    RIG_CAPS_PTT_TYPE
};
 
enum rig_caps_cptr_e {
    RIG_CAPS_VERSION_CPTR,
    RIG_CAPS_MFG_NAME_CPTR,
    RIG_CAPS_MODEL_NAME_CPTR,
    RIG_CAPS_STATUS_CPTR
};
 
extern int rig_get_caps_int(rig_model_t rig_model, enum rig_caps_int_e rig_caps);
 
extern const char* rig_get_caps_cptr(rig_model_t rig_model, enum rig_caps_cptr_e rig_caps);
 
typedef struct hamlib_port {
    union {
        rig_port_t rig;     
        ptt_type_t ptt;     
        dcd_type_t dcd;     
    } type;
 
    int fd;                 
    void *handle;           
    int write_delay;        
    int post_write_delay;   
    struct {
        int tv_sec, tv_usec;
    } post_write_date;      
    int timeout;            
    short retry;            
    short flushx;           
    char pathname[FILPATHLEN];      
    union {
        struct {
            int rate;       
            int data_bits;  
            int stop_bits;  
            enum serial_parity_e parity;        
            enum serial_handshake_e handshake;  
            enum serial_control_state_e rts_state;    
            enum serial_control_state_e dtr_state;    
        } serial;           
        struct {
            int pin;        
        } parallel;         
        struct {
            int ptt_bitnum; 
        } cm108;            
        struct {
            int vid;        
            int pid;        
            int conf;       
            int iface;      
            int alt;        
            char *vendor_name;  
            char *product;      
        } usb;              
        struct {
            int on_value;   
            int value;      
        } gpio;             
    } parm;                 
} hamlib_port_t;
 
#if !defined(__APPLE__) || !defined(__cplusplus)
typedef hamlib_port_t port_t;
#endif
 
#define HAMLIB_ELAPSED_GET 0
#define HAMLIB_ELAPSED_SET 1
#define HAMLIB_ELAPSED_INVALIDATE 2
 
typedef enum {
    HAMLIB_CACHE_ALL, // to set all cache timeouts at once
    HAMLIB_CACHE_VFO,
    HAMLIB_CACHE_FREQ,
    HAMLIB_CACHE_MODE,
    HAMLIB_CACHE_PTT,
    HAMLIB_CACHE_SPLIT
} hamlib_cache_t;
 
struct rig_cache {
    int timeout_ms;  // the cache timeout for invalidating itself
    vfo_t vfo;
    freq_t freq; // to be deprecated in 4.1 when full Main/Sub/A/B caching is implemented in 4.1
    // other abstraction here is based on dual vfo rigs and mapped to all others
    // So we have four possible states of rig
    // MainA, MainB, SubA, SubB
    // Main is the Main VFO and Sub is for the 2nd VFO
    // Most rigs have MainA and MainB
    // Dual VFO rigs can have SubA and SubB too
    // For dual VFO rigs simplex operations are all done on MainA/MainB -- ergo this abstraction
    freq_t freqCurr;  // VFO_CURR
    freq_t freqMainA; // VFO_A, VFO_MAIN, and VFO_MAINA
    freq_t freqMainB; // VFO_B, VFO_SUB, and VFO_MAINB
    freq_t freqMainC; // VFO_C, VFO_MAINC
    freq_t freqSubA;  // VFO_SUBA -- only for rigs with dual Sub VFOs
    freq_t freqSubB;  // VFO_SUBB -- only for rigs with dual Sub VFOs
#if 0 // future
    freq_t freqSubC;  // VFO_SUBC -- only for rigs with 3 Sub VFOs
#endif
    rmode_t mode;
    pbwidth_t width;
    ptt_t ptt;
    split_t split;
    vfo_t split_vfo;  // split caches two values
    struct timespec time_freq;
    struct timespec time_freqCurr;
    struct timespec time_freqMainA;
    struct timespec time_freqMainB;
    struct timespec time_freqMainC;
    struct timespec time_freqSubA;
    struct timespec time_freqSubB;
    struct timespec time_vfo;
    struct timespec time_mode;
    struct timespec time_ptt;
    struct timespec time_split;
    vfo_t vfo_freq; // last vfo cached
    vfo_t vfo_mode; // last vfo cached
    int satmode; // if rig is in satellite mode
};
 
 
struct rig_state {
    /*
     * overridable fields
     */
    hamlib_port_t rigport;  
    hamlib_port_t pttport;  
    hamlib_port_t dcdport;  
    double vfo_comp;        
    int deprecated_itu_region;         
    freq_range_t rx_range_list[FRQRANGESIZ];    
    freq_range_t tx_range_list[FRQRANGESIZ];    
    struct tuning_step_list tuning_steps[TSLSTSIZ]; 
    struct filter_list filters[FLTLSTSIZ];      
    cal_table_t str_cal;            
    chan_t chan_list[CHANLSTSIZ];   
    shortfreq_t max_rit;        
    shortfreq_t max_xit;        
    shortfreq_t max_ifshift;    
    ann_t announces;            
    int preamp[MAXDBLSTSIZ];    
    int attenuator[MAXDBLSTSIZ];    
    setting_t has_get_func;     
    setting_t has_set_func;     
    setting_t has_get_level;    
    setting_t has_set_level;    
    setting_t has_get_parm;     
    setting_t has_set_parm;     
    gran_t level_gran[RIG_SETTING_MAX]; 
    gran_t parm_gran[RIG_SETTING_MAX];  
    /*
     * non overridable fields, internal use
     */
 
    int hold_decode;    
    vfo_t current_vfo;  
    int vfo_list;       
    int comm_state;     
    rig_ptr_t priv;     
    rig_ptr_t obj;      
    int transceive;             
    int poll_interval;          
    freq_t current_freq;        
    rmode_t current_mode;       
    pbwidth_t current_width;    
    vfo_t tx_vfo;               
    rmode_t mode_list;              
    int transmit;               
    freq_t lo_freq;             
    time_t twiddle_time;        
    int twiddle_timeout;        
    // uplink allows gpredict to behave better by no reading the uplink VFO
    int uplink;                 
    struct rig_cache cache;
    int vfo_opt;                
    int auto_power_on;          
    int auto_disable_screensaver; 
    int ptt_share;              
    int power_now;              
    int power_min;              
    int power_max;              
    unsigned char disable_yaesu_bandselect; 
};
 
typedef int (*vprintf_cb_t)(enum rig_debug_level_e,
                            rig_ptr_t,
                            const char *,
                            va_list);
 
typedef int (*freq_cb_t)(RIG *, vfo_t, freq_t, rig_ptr_t);
typedef int (*mode_cb_t)(RIG *, vfo_t, rmode_t, pbwidth_t, rig_ptr_t);
typedef int (*vfo_cb_t)(RIG *, vfo_t, rig_ptr_t);
typedef int (*ptt_cb_t)(RIG *, vfo_t, ptt_t, rig_ptr_t);
typedef int (*dcd_cb_t)(RIG *, vfo_t, dcd_t, rig_ptr_t);
typedef int (*pltune_cb_t)(RIG *,
                           vfo_t, freq_t *,
                           rmode_t *,
                           pbwidth_t *,
                           rig_ptr_t);
 
 
struct rig_callbacks {
    freq_cb_t freq_event;   
    rig_ptr_t freq_arg;     
    mode_cb_t mode_event;   
    rig_ptr_t mode_arg;     
    vfo_cb_t vfo_event;     
    rig_ptr_t vfo_arg;      
    ptt_cb_t ptt_event;     
    rig_ptr_t ptt_arg;      
    dcd_cb_t dcd_event;     
    rig_ptr_t dcd_arg;      
    pltune_cb_t pltune;     
    rig_ptr_t pltune_arg;   
    /* etc.. */
};
 
 
struct s_rig {
    struct rig_caps *caps;          
    struct rig_state state;         
    struct rig_callbacks callbacks; 
};
 
 
 
/* --------------- API function prototypes -----------------*/
 
 
extern HAMLIB_EXPORT(RIG *) rig_init HAMLIB_PARAMS((rig_model_t rig_model));
extern HAMLIB_EXPORT(int) rig_open HAMLIB_PARAMS((RIG *rig));
 
/*
 *  General API commands, from most primitive to least.. :()
 *  List Set/Get functions pairs
 */
 
extern HAMLIB_EXPORT(int)
rig_flush(hamlib_port_t *port);
 
extern HAMLIB_EXPORT(int)
rig_set_freq HAMLIB_PARAMS((RIG *rig,
                            vfo_t vfo,
                            freq_t freq));
extern HAMLIB_EXPORT(int)
rig_get_freq HAMLIB_PARAMS((RIG *rig,
                            vfo_t vfo,
                            freq_t *freq));
 
extern HAMLIB_EXPORT(int)
rig_set_mode HAMLIB_PARAMS((RIG *rig,
                            vfo_t vfo,
                            rmode_t mode,
                            pbwidth_t width));
extern HAMLIB_EXPORT(int)
rig_get_mode HAMLIB_PARAMS((RIG *rig,
                            vfo_t vfo,
                            rmode_t *mode,
                            pbwidth_t *width));
 
extern HAMLIB_EXPORT(int)
rig_set_vfo HAMLIB_PARAMS((RIG *rig,
                           vfo_t vfo));
extern HAMLIB_EXPORT(int)
rig_get_vfo HAMLIB_PARAMS((RIG *rig,
                           vfo_t *vfo));
 
extern HAMLIB_EXPORT(int)
netrigctl_get_vfo_mode HAMLIB_PARAMS((RIG *rig));
 
extern HAMLIB_EXPORT(int)
rig_set_ptt HAMLIB_PARAMS((RIG *rig,
                           vfo_t vfo,
                           ptt_t ptt));
extern HAMLIB_EXPORT(int)
rig_get_ptt HAMLIB_PARAMS((RIG *rig,
                           vfo_t vfo,
                           ptt_t *ptt));
 
extern HAMLIB_EXPORT(int)
rig_get_dcd HAMLIB_PARAMS((RIG *rig,
                           vfo_t vfo,
                           dcd_t *dcd));
 
extern HAMLIB_EXPORT(int)
rig_set_rptr_shift HAMLIB_PARAMS((RIG *rig,
                                  vfo_t vfo,
                                  rptr_shift_t rptr_shift));
extern HAMLIB_EXPORT(int)
rig_get_rptr_shift HAMLIB_PARAMS((RIG *rig,
                                  vfo_t vfo,
                                  rptr_shift_t *rptr_shift));
 
extern HAMLIB_EXPORT(int)
rig_set_rptr_offs HAMLIB_PARAMS((RIG *rig,
                                 vfo_t vfo,
                                 shortfreq_t rptr_offs));
extern HAMLIB_EXPORT(int)
rig_get_rptr_offs HAMLIB_PARAMS((RIG *rig,
                                 vfo_t vfo,
                                 shortfreq_t *rptr_offs));
 
extern HAMLIB_EXPORT(int)
rig_set_ctcss_tone HAMLIB_PARAMS((RIG *rig,
                                  vfo_t vfo,
                                  tone_t tone));
extern HAMLIB_EXPORT(int)
rig_get_ctcss_tone HAMLIB_PARAMS((RIG *rig,
                                  vfo_t vfo,
                                  tone_t *tone));
 
extern HAMLIB_EXPORT(int)
rig_set_dcs_code HAMLIB_PARAMS((RIG *rig,
                                vfo_t vfo,
                                tone_t code));
extern HAMLIB_EXPORT(int)
rig_get_dcs_code HAMLIB_PARAMS((RIG *rig,
                                vfo_t vfo,
                                tone_t *code));
 
extern HAMLIB_EXPORT(int)
rig_set_ctcss_sql HAMLIB_PARAMS((RIG *rig,
                                 vfo_t vfo,
                                 tone_t tone));
extern HAMLIB_EXPORT(int)
rig_get_ctcss_sql HAMLIB_PARAMS((RIG *rig,
                                 vfo_t vfo,
                                 tone_t *tone));
 
extern HAMLIB_EXPORT(int)
rig_set_dcs_sql HAMLIB_PARAMS((RIG *rig,
                               vfo_t vfo,
                               tone_t code));
extern HAMLIB_EXPORT(int)
rig_get_dcs_sql HAMLIB_PARAMS((RIG *rig,
                               vfo_t vfo,
                               tone_t *code));
 
extern HAMLIB_EXPORT(int)
rig_set_split_freq HAMLIB_PARAMS((RIG *rig,
                                  vfo_t vfo,
                                  freq_t tx_freq));
extern HAMLIB_EXPORT(int)
rig_get_split_freq HAMLIB_PARAMS((RIG *rig,
                                  vfo_t vfo,
                                  freq_t *tx_freq));
 
extern HAMLIB_EXPORT(int)
rig_set_split_mode HAMLIB_PARAMS((RIG *rig,
                                  vfo_t vfo,
                                  rmode_t tx_mode,
                                  pbwidth_t tx_width));
extern HAMLIB_EXPORT(int)
rig_get_split_mode HAMLIB_PARAMS((RIG *rig,
                                  vfo_t vfo,
                                  rmode_t *tx_mode,
                                  pbwidth_t *tx_width));
 
extern HAMLIB_EXPORT(int)
rig_set_split_freq_mode HAMLIB_PARAMS((RIG *rig,
                                       vfo_t vfo,
                                       freq_t tx_freq,
                                       rmode_t tx_mode,
                                       pbwidth_t tx_width));
extern HAMLIB_EXPORT(int)
rig_get_split_freq_mode HAMLIB_PARAMS((RIG *rig,
                                       vfo_t vfo,
                                       freq_t *tx_freq,
                                       rmode_t *tx_mode,
                                       pbwidth_t *tx_width));
 
extern HAMLIB_EXPORT(int)
rig_set_split_vfo HAMLIB_PARAMS((RIG *,
                                 vfo_t rx_vfo,
                                 split_t split,
                                 vfo_t tx_vfo));
extern HAMLIB_EXPORT(int)
rig_get_split_vfo HAMLIB_PARAMS((RIG *,
                                 vfo_t rx_vfo,
                                 split_t *split,
                                 vfo_t *tx_vfo));
 
#define rig_set_split(r,v,s) rig_set_split_vfo((r),(v),(s),RIG_VFO_CURR)
#define rig_get_split(r,v,s) ({ vfo_t _tx_vfo; rig_get_split_vfo((r),(v),(s),&_tx_vfo); })
 
extern HAMLIB_EXPORT(int)
rig_set_rit HAMLIB_PARAMS((RIG *rig,
                           vfo_t vfo,
                           shortfreq_t rit));
extern HAMLIB_EXPORT(int)
rig_get_rit HAMLIB_PARAMS((RIG *rig,
                           vfo_t vfo,
                           shortfreq_t *rit));
 
extern HAMLIB_EXPORT(int)
rig_set_xit HAMLIB_PARAMS((RIG *rig,
                           vfo_t vfo,
                           shortfreq_t xit));
extern HAMLIB_EXPORT(int)
rig_get_xit HAMLIB_PARAMS((RIG *rig,
                           vfo_t vfo,
                           shortfreq_t *xit));
 
extern HAMLIB_EXPORT(int)
rig_set_ts HAMLIB_PARAMS((RIG *rig,
                          vfo_t vfo,
                          shortfreq_t ts));
extern HAMLIB_EXPORT(int)
rig_get_ts HAMLIB_PARAMS((RIG *rig,
                          vfo_t vfo,
                          shortfreq_t *ts));
 
extern HAMLIB_EXPORT(int)
rig_power2mW HAMLIB_PARAMS((RIG *rig,
                            unsigned int *mwpower,
                            float power,
                            freq_t freq,
                            rmode_t mode));
extern HAMLIB_EXPORT(int)
rig_mW2power HAMLIB_PARAMS((RIG *rig,
                            float *power,
                            unsigned int mwpower,
                            freq_t freq,
                            rmode_t mode));
 
extern HAMLIB_EXPORT(shortfreq_t)
rig_get_resolution HAMLIB_PARAMS((RIG *rig,
                                  rmode_t mode));
 
extern HAMLIB_EXPORT(int)
rig_set_level HAMLIB_PARAMS((RIG *rig,
                             vfo_t vfo,
                             setting_t level,
                             value_t val));
extern HAMLIB_EXPORT(int)
rig_get_level HAMLIB_PARAMS((RIG *rig,
                             vfo_t vfo,
                             setting_t level,
                             value_t *val));
 
#define rig_get_strength(r,v,s) rig_get_level((r),(v),RIG_LEVEL_STRENGTH, (value_t*)(s))
 
extern HAMLIB_EXPORT(int)
rig_set_parm HAMLIB_PARAMS((RIG *rig,
                            setting_t parm,
                            value_t val));
extern HAMLIB_EXPORT(int)
rig_get_parm HAMLIB_PARAMS((RIG *rig,
                            setting_t parm,
                            value_t *val));
 
extern HAMLIB_EXPORT(int)
rig_set_conf HAMLIB_PARAMS((RIG *rig,
                            token_t token,
                            const char *val));
extern HAMLIB_EXPORT(int)
rig_get_conf HAMLIB_PARAMS((RIG *rig,
                            token_t token,
                            char *val));
 
extern HAMLIB_EXPORT(int)
rig_set_powerstat HAMLIB_PARAMS((RIG *rig,
                                 powerstat_t status));
extern HAMLIB_EXPORT(int)
rig_get_powerstat HAMLIB_PARAMS((RIG *rig,
                                 powerstat_t *status));
 
extern HAMLIB_EXPORT(int)
rig_reset HAMLIB_PARAMS((RIG *rig,
                         reset_t reset));   /* dangerous! */
 
extern HAMLIB_EXPORT(int)
rig_set_ext_level HAMLIB_PARAMS((RIG *rig,
                                 vfo_t vfo,
                                 token_t token,
                                 value_t val));
extern HAMLIB_EXPORT(int)
rig_get_ext_level HAMLIB_PARAMS((RIG *rig,
                                 vfo_t vfo,
                                 token_t token,
                                 value_t *val));
 
extern HAMLIB_EXPORT(int)
rig_set_ext_func HAMLIB_PARAMS((RIG *rig,
                                 vfo_t vfo,
                                 token_t token,
                                 int status));
extern HAMLIB_EXPORT(int)
rig_get_ext_func HAMLIB_PARAMS((RIG *rig,
                                 vfo_t vfo,
                                 token_t token,
                                 int *status));
 
extern HAMLIB_EXPORT(int)
rig_set_ext_parm HAMLIB_PARAMS((RIG *rig,
                                token_t token,
                                value_t val));
extern HAMLIB_EXPORT(int)
rig_get_ext_parm HAMLIB_PARAMS((RIG *rig,
                                token_t token,
                                value_t *val));
 
extern HAMLIB_EXPORT(int)
rig_ext_func_foreach HAMLIB_PARAMS((RIG *rig,
                                     int (*cfunc)(RIG *,
                                                  const struct confparams *,
                                                  rig_ptr_t),
                                     rig_ptr_t data));
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));
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));
 
extern HAMLIB_EXPORT(const struct confparams *)
rig_ext_lookup HAMLIB_PARAMS((RIG *rig,
                              const char *name));
 
extern HAMLIB_EXPORT(const struct confparams *)
rig_ext_lookup_tok HAMLIB_PARAMS((RIG *rig,
                                  token_t token));
extern HAMLIB_EXPORT(token_t)
rig_ext_token_lookup HAMLIB_PARAMS((RIG *rig,
                                    const char *name));
 
 
extern HAMLIB_EXPORT(int)
rig_token_foreach HAMLIB_PARAMS((RIG *rig,
                                 int (*cfunc)(const struct confparams *,
                                              rig_ptr_t),
                                 rig_ptr_t data));
 
extern HAMLIB_EXPORT(const struct confparams *)
rig_confparam_lookup HAMLIB_PARAMS((RIG *rig,
                                    const char *name));
extern HAMLIB_EXPORT(token_t)
rig_token_lookup HAMLIB_PARAMS((RIG *rig,
                                const char *name));
 
extern HAMLIB_EXPORT(int)
rig_close HAMLIB_PARAMS((RIG *rig));
 
extern HAMLIB_EXPORT(int)
rig_cleanup HAMLIB_PARAMS((RIG *rig));
 
extern HAMLIB_EXPORT(int)
rig_set_ant HAMLIB_PARAMS((RIG *rig,
                           vfo_t vfo,
                           ant_t ant,  /* antenna */
                           value_t option));  /* optional ant info */
extern HAMLIB_EXPORT(int)
rig_get_ant HAMLIB_PARAMS((RIG *rig,
                           vfo_t vfo,
                           ant_t ant,
                           value_t *option,
                           ant_t *ant_curr,
                           ant_t *ant_tx,
                           ant_t *ant_rx));
 
extern HAMLIB_EXPORT(setting_t)
rig_has_get_level HAMLIB_PARAMS((RIG *rig,
                                 setting_t level));
extern HAMLIB_EXPORT(setting_t)
rig_has_set_level HAMLIB_PARAMS((RIG *rig,
                                 setting_t level));
 
extern HAMLIB_EXPORT(setting_t)
rig_has_get_parm HAMLIB_PARAMS((RIG *rig,
                                setting_t parm));
extern HAMLIB_EXPORT(setting_t)
rig_has_set_parm HAMLIB_PARAMS((RIG *rig,
                                setting_t parm));
 
extern HAMLIB_EXPORT(setting_t)
rig_has_get_func HAMLIB_PARAMS((RIG *rig,
                                setting_t func));
extern HAMLIB_EXPORT(setting_t)
rig_has_set_func HAMLIB_PARAMS((RIG *rig,
                                setting_t func));
 
extern HAMLIB_EXPORT(int)
rig_set_func HAMLIB_PARAMS((RIG *rig,
                            vfo_t vfo,
                            setting_t func,
                            int status));
extern HAMLIB_EXPORT(int)
rig_get_func HAMLIB_PARAMS((RIG *rig,
                            vfo_t vfo,
                            setting_t func,
                            int *status));
 
extern HAMLIB_EXPORT(int)
rig_send_dtmf HAMLIB_PARAMS((RIG *rig,
                             vfo_t vfo,
                             const char *digits));
extern HAMLIB_EXPORT(int)
rig_recv_dtmf HAMLIB_PARAMS((RIG *rig,
                             vfo_t vfo,
                             char *digits,
                             int *length));
 
extern HAMLIB_EXPORT(int)
rig_send_morse HAMLIB_PARAMS((RIG *rig,
                              vfo_t vfo,
                              const char *msg));
 
extern HAMLIB_EXPORT(int)
rig_stop_morse HAMLIB_PARAMS((RIG *rig,
                              vfo_t vfo));
 
extern HAMLIB_EXPORT(int)
rig_wait_morse HAMLIB_PARAMS((RIG *rig,
                              vfo_t vfo));
 
extern HAMLIB_EXPORT(int)
rig_send_voice_mem HAMLIB_PARAMS((RIG *rig,
                              vfo_t vfo,
                              int ch));
 
extern HAMLIB_EXPORT(int)
rig_set_bank HAMLIB_PARAMS((RIG *rig,
                            vfo_t vfo,
                            int bank));
 
extern HAMLIB_EXPORT(int)
rig_set_mem HAMLIB_PARAMS((RIG *rig,
                           vfo_t vfo,
                           int ch));
extern HAMLIB_EXPORT(int)
rig_get_mem HAMLIB_PARAMS((RIG *rig,
                           vfo_t vfo,
                           int *ch));
 
extern HAMLIB_EXPORT(int)
rig_vfo_op HAMLIB_PARAMS((RIG *rig,
                          vfo_t vfo,
                          vfo_op_t op));
 
extern HAMLIB_EXPORT(vfo_op_t)
rig_has_vfo_op HAMLIB_PARAMS((RIG *rig,
                              vfo_op_t op));
 
extern HAMLIB_EXPORT(int)
rig_scan HAMLIB_PARAMS((RIG *rig,
                        vfo_t vfo,
                        scan_t scan,
                        int ch));
 
extern HAMLIB_EXPORT(scan_t)
rig_has_scan HAMLIB_PARAMS((RIG *rig,
                            scan_t scan));
 
extern HAMLIB_EXPORT(int)
rig_set_channel HAMLIB_PARAMS((RIG *rig, 
                               vfo_t vfo,
                               const channel_t *chan)); /* mem */
extern HAMLIB_EXPORT(int)
rig_get_channel HAMLIB_PARAMS((RIG *rig, 
                               vfo_t vfo,
                               channel_t *chan, int read_only));
 
extern HAMLIB_EXPORT(int)
rig_set_chan_all HAMLIB_PARAMS((RIG *rig, 
                                vfo_t vfo,
                                const channel_t chans[]));
extern HAMLIB_EXPORT(int)
rig_get_chan_all HAMLIB_PARAMS((RIG *rig, 
                                vfo_t vfo,
                                channel_t chans[]));
 
extern HAMLIB_EXPORT(int)
rig_set_chan_all_cb HAMLIB_PARAMS((RIG *rig, 
                                   vfo_t vfo,
                                   chan_cb_t chan_cb,
                                   rig_ptr_t));
extern HAMLIB_EXPORT(int)
rig_get_chan_all_cb HAMLIB_PARAMS((RIG *rig, 
                                   vfo_t vfo,
                                   chan_cb_t chan_cb,
                                   rig_ptr_t));
 
extern HAMLIB_EXPORT(int)
rig_set_mem_all_cb HAMLIB_PARAMS((RIG *rig,
                                  vfo_t vfo,
                                  chan_cb_t chan_cb,
                                  confval_cb_t parm_cb,
                                  rig_ptr_t));
extern HAMLIB_EXPORT(int)
rig_get_mem_all_cb HAMLIB_PARAMS((RIG *rig, 
                                  vfo_t vfo,
                                  chan_cb_t chan_cb,
                                  confval_cb_t parm_cb,
                                  rig_ptr_t));
 
extern HAMLIB_EXPORT(int)
rig_set_mem_all HAMLIB_PARAMS((RIG *rig,
                               vfo_t vfo,
                               const channel_t *chan,
                               const struct confparams *,
                               const value_t *));
extern HAMLIB_EXPORT(int)
rig_get_mem_all HAMLIB_PARAMS((RIG *rig,
                               vfo_t vfo,
                               channel_t *chan,
                               const struct confparams *,
                               value_t *));
 
extern HAMLIB_EXPORT(const chan_t *)
rig_lookup_mem_caps HAMLIB_PARAMS((RIG *rig,
                                   int ch));
 
extern HAMLIB_EXPORT(int)
rig_mem_count HAMLIB_PARAMS((RIG *rig));
 
extern HAMLIB_EXPORT(int)
rig_set_trn HAMLIB_PARAMS((RIG *rig,
                           int trn));
extern HAMLIB_EXPORT(int)
rig_get_trn HAMLIB_PARAMS((RIG *rig,
                           int *trn));
 
extern HAMLIB_EXPORT(int)
rig_set_freq_callback HAMLIB_PARAMS((RIG *,
                                     freq_cb_t,
                                     rig_ptr_t));
 
extern HAMLIB_EXPORT(int)
rig_set_mode_callback HAMLIB_PARAMS((RIG *,
                                     mode_cb_t,
                                     rig_ptr_t));
extern HAMLIB_EXPORT(int)
rig_set_vfo_callback HAMLIB_PARAMS((RIG *,
                                    vfo_cb_t,
                                    rig_ptr_t));
 
extern HAMLIB_EXPORT(int)
rig_set_ptt_callback HAMLIB_PARAMS((RIG *,
                                    ptt_cb_t,
                                    rig_ptr_t));
 
extern HAMLIB_EXPORT(int)
rig_set_dcd_callback HAMLIB_PARAMS((RIG *,
                                    dcd_cb_t,
                                    rig_ptr_t));
 
extern HAMLIB_EXPORT(int)
rig_set_pltune_callback HAMLIB_PARAMS((RIG *,
                                       pltune_cb_t,
                                       rig_ptr_t));
 
extern HAMLIB_EXPORT(int)
rig_set_twiddle HAMLIB_PARAMS((RIG *rig,
                                 int seconds));
 
extern HAMLIB_EXPORT(int)
rig_get_twiddle HAMLIB_PARAMS((RIG *rig,
                                 int *seconds));
 
extern HAMLIB_EXPORT(int)
rig_set_uplink HAMLIB_PARAMS((RIG *rig,
                                 int val));
 
 
extern HAMLIB_EXPORT(const char *)
rig_get_info HAMLIB_PARAMS((RIG *rig));
 
extern HAMLIB_EXPORT(const struct rig_caps *)
rig_get_caps HAMLIB_PARAMS((rig_model_t rig_model));
 
extern HAMLIB_EXPORT(const freq_range_t *)
rig_get_range HAMLIB_PARAMS((const freq_range_t *range_list,
                             freq_t freq,
                             rmode_t mode));
 
extern HAMLIB_EXPORT(pbwidth_t)
rig_passband_normal HAMLIB_PARAMS((RIG *rig,
                                   rmode_t mode));
extern HAMLIB_EXPORT(pbwidth_t)
rig_passband_narrow HAMLIB_PARAMS((RIG *rig,
                                   rmode_t mode));
extern HAMLIB_EXPORT(pbwidth_t)
rig_passband_wide HAMLIB_PARAMS((RIG *rig,
                                 rmode_t mode));
 
extern HAMLIB_EXPORT(const char *)
rigerror HAMLIB_PARAMS((int errnum));
 
extern HAMLIB_EXPORT(int)
rig_setting2idx HAMLIB_PARAMS((setting_t s));
 
extern HAMLIB_EXPORT(setting_t)
rig_idx2setting(int i);
/*
 * Even if these functions are prefixed with "rig_", they are not rig specific
 * Maybe "hamlib_" would have been better. Let me know. --SF
 */
extern HAMLIB_EXPORT(void)
rig_set_debug HAMLIB_PARAMS((enum rig_debug_level_e debug_level));
 
extern HAMLIB_EXPORT(void)
rig_set_debug_time_stamp HAMLIB_PARAMS((int flag));
 
#define rig_set_debug_level(level) rig_set_debug(level)
 
extern HAMLIB_EXPORT(int)
rig_need_debug HAMLIB_PARAMS((enum rig_debug_level_e debug_level));
 
 
// this need to be fairly big to avoid compiler warnings
#define DEBUGMSGSAVE_SIZE 24000
extern HAMLIB_EXPORT_VAR(char) debugmsgsave[DEBUGMSGSAVE_SIZE];  // last debug msg
#ifndef __cplusplus
#ifdef __GNUC__
// doing the debug macro with a dummy sprintf allows gcc to check the format string
//#define rig_debug(debug_level,fmt,...) { char xxxbuf[16384]="";snprintf(xxxbuf,sizeof(xxxbuf),fmt,__VA_ARGS__);rig_debug(debug_level,fmt,##__VA_ARGS__); }
#define rig_debug(debug_level,fmt,...) { snprintf(debugmsgsave,sizeof(debugmsgsave),fmt,__VA_ARGS__);rig_debug(debug_level,fmt,##__VA_ARGS__); }
#endif
#endif
extern HAMLIB_EXPORT(void)
rig_debug HAMLIB_PARAMS((enum rig_debug_level_e debug_level,
                         const char *fmt, ...));
 
extern HAMLIB_EXPORT(vprintf_cb_t)
rig_set_debug_callback HAMLIB_PARAMS((vprintf_cb_t cb,
                                      rig_ptr_t arg));
 
extern HAMLIB_EXPORT(FILE *)
rig_set_debug_file HAMLIB_PARAMS((FILE *stream));
 
extern HAMLIB_EXPORT(int)
rig_register HAMLIB_PARAMS((const struct rig_caps *caps));
 
extern HAMLIB_EXPORT(int)
rig_unregister HAMLIB_PARAMS((rig_model_t rig_model));
 
extern HAMLIB_EXPORT(int)
rig_list_foreach HAMLIB_PARAMS((int (*cfunc)(const struct rig_caps *, rig_ptr_t),
                                rig_ptr_t data));
 
extern HAMLIB_EXPORT(int)
rig_list_foreach_model HAMLIB_PARAMS((int (*cfunc)(const rig_model_t rig_model, rig_ptr_t),
                                rig_ptr_t data));
 
extern HAMLIB_EXPORT(int)
rig_load_backend HAMLIB_PARAMS((const char *be_name));
 
extern HAMLIB_EXPORT(int)
rig_check_backend HAMLIB_PARAMS((rig_model_t rig_model));
 
extern HAMLIB_EXPORT(int)
rig_load_all_backends HAMLIB_PARAMS((void));
 
typedef int (*rig_probe_func_t)(const hamlib_port_t *, rig_model_t, rig_ptr_t);
 
extern HAMLIB_EXPORT(int)
rig_probe_all HAMLIB_PARAMS((hamlib_port_t *p,
                             rig_probe_func_t,
                             rig_ptr_t));
 
extern HAMLIB_EXPORT(rig_model_t)
rig_probe HAMLIB_PARAMS((hamlib_port_t *p));
 
 
/* Misc calls */
extern HAMLIB_EXPORT(const char *) rig_strrmode(rmode_t mode);
extern HAMLIB_EXPORT(int)          rig_strrmodes(rmode_t modes, char *buf, int buflen);
extern HAMLIB_EXPORT(const char *) rig_strvfo(vfo_t vfo);
extern HAMLIB_EXPORT(const char *) rig_strfunc(setting_t);
extern HAMLIB_EXPORT(const char *) rig_strlevel(setting_t);
extern HAMLIB_EXPORT(const char *) rig_strparm(setting_t);
extern HAMLIB_EXPORT(const char *) rig_strptrshift(rptr_shift_t);
extern HAMLIB_EXPORT(const char *) rig_strvfop(vfo_op_t op);
extern HAMLIB_EXPORT(const char *) rig_strscan(scan_t scan);
extern HAMLIB_EXPORT(const char *) rig_strstatus(enum rig_status_e status);
extern HAMLIB_EXPORT(const char *) rig_strmtype(chan_type_t mtype);
 
extern HAMLIB_EXPORT(rmode_t) rig_parse_mode(const char *s);
extern HAMLIB_EXPORT(vfo_t) rig_parse_vfo(const char *s);
extern HAMLIB_EXPORT(setting_t) rig_parse_func(const char *s);
extern HAMLIB_EXPORT(setting_t) rig_parse_level(const char *s);
extern HAMLIB_EXPORT(setting_t) rig_parse_parm(const char *s);
extern HAMLIB_EXPORT(vfo_op_t) rig_parse_vfo_op(const char *s);
extern HAMLIB_EXPORT(scan_t) rig_parse_scan(const char *s);
extern HAMLIB_EXPORT(rptr_shift_t) rig_parse_rptr_shift(const char *s);
extern HAMLIB_EXPORT(chan_type_t) rig_parse_mtype(const char *s);
 
extern HAMLIB_EXPORT(const char *) rig_license HAMLIB_PARAMS(());
extern HAMLIB_EXPORT(const char *) rig_version HAMLIB_PARAMS(());
extern HAMLIB_EXPORT(const char *) rig_copyright HAMLIB_PARAMS(());
 
extern HAMLIB_EXPORT(void) rig_no_restore_ai();
 
extern HAMLIB_EXPORT(int) rig_get_cache_timeout_ms(RIG *rig, hamlib_cache_t selection);
extern HAMLIB_EXPORT(int) rig_set_cache_timeout_ms(RIG *rig, hamlib_cache_t selection, int ms);
 
extern HAMLIB_EXPORT(int) rig_set_vfo_opt(RIG *rig, int status);
 
 
typedef unsigned long rig_useconds_t;
extern HAMLIB_EXPORT(int) hl_usleep(rig_useconds_t msec);
 
 
__END_DECLS
 
#endif /* _RIG_H */