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

#include <stdio.h>
#include <stdarg.h>

#include <hamlib/riglist.h> /* list in another file to not mess up w/ this one */

/* __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*
#else
# define HAMLIB_PARAMS(protos) ()
# define rig_ptr_t     char*
#endif

#include <hamlib/rig_dll.h>


__BEGIN_DECLS

extern HAMLIB_EXPORT_VAR(const char) hamlib_version[];
extern HAMLIB_EXPORT_VAR(const char) hamlib_copyright[];

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 rig RIG;

#define RIGNAMSIZ 30
#define RIGVERSIZ 8
#define FILPATHLEN 100
#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_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 int vfo_t;

#define RIG_VFO_NONE    0

#define RIG_VFO_TX_FLAG    (1<<30)

#define RIG_VFO_CURR    (1<<29)

#define RIG_VFO_MEM (1<<28)

#define RIG_VFO_VFO (1<<27)

#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

#define RIG_VFO_MAIN    (1<<26)

#define RIG_VFO_SUB (1<<25)

#define RIG_VFO_N(n) (1<<(n))

#define RIG_VFO_A RIG_VFO_N(0)

#define RIG_VFO_B RIG_VFO_N(1)

#define RIG_VFO_C RIG_VFO_N(2)


/*
 * targetable bitfields, for internal use.
 * RIG_TARGETABLE_PURE means a pure targetable radio on every command
 */
#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_ALL  0x7fffffff


#define RIG_PASSBAND_NORMAL s_Hz(0)

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         
} 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     
} ptt_type_t;

typedef enum {
  RIG_POWER_OFF =   0,      
  RIG_POWER_ON =    (1<<0),     
  RIG_POWER_STANDBY =   (1<<1)      
} 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_STOP =     RIG_SCAN_NONE, 
    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)  
} 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     
};

#define RIG_COMBO_MAX   8

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 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)

/* 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
};

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 */
};

typedef union {
  signed int i;         
  float f;          
  char *s;          
  const char *cs;       
} value_t;

enum rig_level_e {
    RIG_LEVEL_NONE =    0,  
    RIG_LEVEL_PREAMP =  (1<<0), 
    RIG_LEVEL_ATT =     (1<<1), 
    RIG_LEVEL_VOX =     (1<<2), 
    RIG_LEVEL_AF =      (1<<3), 
    RIG_LEVEL_RF =      (1<<4), 
    RIG_LEVEL_SQL =     (1<<5), 
    RIG_LEVEL_IF =      (1<<6), 
    RIG_LEVEL_APF =     (1<<7), 
    RIG_LEVEL_NR =      (1<<8), 
    RIG_LEVEL_PBT_IN =  (1<<9), 
    RIG_LEVEL_PBT_OUT = (1<<10),
    RIG_LEVEL_CWPITCH = (1<<11),
    RIG_LEVEL_RFPOWER = (1<<12),
    RIG_LEVEL_MICGAIN = (1<<13),
    RIG_LEVEL_KEYSPD =  (1<<14),
    RIG_LEVEL_NOTCHF =  (1<<15),
    RIG_LEVEL_COMP =    (1<<16),
    RIG_LEVEL_AGC =     (1<<17),
    RIG_LEVEL_BKINDL =  (1<<18),
    RIG_LEVEL_BALANCE = (1<<19),
    RIG_LEVEL_METER =   (1<<20),
    RIG_LEVEL_VOXGAIN = (1<<21),
    RIG_LEVEL_VOXDELAY =  RIG_LEVEL_VOX,    
    RIG_LEVEL_ANTIVOX = (1<<22),
    RIG_LEVEL_SLOPE_LOW =   (1<<23),
    RIG_LEVEL_SLOPE_HIGH =  (1<<24),
    RIG_LEVEL_BKIN_DLYMS =  (1<<25),
    RIG_LEVEL_RAWSTR =  (1<<26),
    RIG_LEVEL_SQLSTAT = (1<<27),
    RIG_LEVEL_SWR =     (1<<28),
    RIG_LEVEL_ALC =     (1<<29),
    RIG_LEVEL_STRENGTH =    (1<<30) 
    /*RIG_LEVEL_BWC =   (1<<31)*/ 
};

#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)

#define RIG_LEVEL_READONLY_LIST (RIG_LEVEL_SQLSTAT|RIG_LEVEL_SWR|RIG_LEVEL_ALC|RIG_LEVEL_STRENGTH|RIG_LEVEL_RAWSTR)

#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)  
};

#define RIG_PARM_FLOAT_LIST (RIG_PARM_BACKLIGHT|RIG_PARM_BAT)
#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)

#define RIG_SETTING_MAX 32

typedef unsigned long setting_t;

/*
 * tranceive mode, ie. the rig notify the host of any event,
 * like freq changed, mode changed, etc.
 */
#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: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 func_str.func members.  TNX KA6MAL, AC6SL.  - N0NB
 */
#define RIG_FUNC_NONE    0         
#define RIG_FUNC_FAGC    (1UL<<0)  
#define RIG_FUNC_NB      (1UL<<1)  
#define RIG_FUNC_COMP    (1UL<<2)  
#define RIG_FUNC_VOX     (1UL<<3)  
#define RIG_FUNC_TONE    (1UL<<4)  
#define RIG_FUNC_TSQL    (1UL<<5)  
#define RIG_FUNC_SBKIN   (1UL<<6)  
#define RIG_FUNC_FBKIN   (1UL<<7)  
#define RIG_FUNC_ANF     (1UL<<8)  
#define RIG_FUNC_NR      (1UL<<9)  
#define RIG_FUNC_AIP     (1UL<<10) 
#define RIG_FUNC_APF     (1UL<<11) 
#define RIG_FUNC_MON     (1UL<<12) 
#define RIG_FUNC_MN      (1UL<<13) 
#define RIG_FUNC_RF      (1UL<<14) 
#define RIG_FUNC_ARO     (1UL<<15) 
#define RIG_FUNC_LOCK    (1UL<<16) 
#define RIG_FUNC_MUTE    (1UL<<17) 
#define RIG_FUNC_VSC     (1UL<<18) 
#define RIG_FUNC_REV     (1UL<<19) 
#define RIG_FUNC_SQL     (1UL<<20) 
#define RIG_FUNC_ABM     (1UL<<21) 
#define RIG_FUNC_BC      (1UL<<22) 
#define RIG_FUNC_MBC     (1UL<<23) 
#define RIG_FUNC_RIT     (1UL<<24) 
#define RIG_FUNC_AFC     (1UL<<25) 
#define RIG_FUNC_SATMODE (1UL<<26) 
#define RIG_FUNC_SCOPE   (1UL<<27) 
#define RIG_FUNC_RESUME  (1UL<<28) 
#define RIG_FUNC_TBURST  (1UL<<29) 
#define RIG_FUNC_TUNER   (1UL<<30) 
#define RIG_FUNC_XIT     (1UL<<31) 
/*
 * power unit macros, converts to mW
 * This is limited to 2MW on 32 bits systems.
 */
#define mW(p)    ((int)(p))
#define Watts(p) ((int)((p)*1000))
#define W(p)     Watts(p)
#define kW(p)    ((int)((p)*1000000L))

typedef enum {
    RIG_MODE_NONE =     0,  
    RIG_MODE_AM =       (1<<0), 
    RIG_MODE_CW =       (1<<1), 
    RIG_MODE_USB =      (1<<2), 
    RIG_MODE_LSB =      (1<<3), 
    RIG_MODE_RTTY =     (1<<4), 
    RIG_MODE_FM =       (1<<5), 
    RIG_MODE_WFM =      (1<<6), 
    RIG_MODE_CWR =      (1<<7), 
    RIG_MODE_RTTYR =    (1<<8), 
    RIG_MODE_AMS =      (1<<9), 
    RIG_MODE_PKTLSB =       (1<<10),
    RIG_MODE_PKTUSB =       (1<<11),
    RIG_MODE_PKTFM =        (1<<12),
    RIG_MODE_ECSSUSB =      (1<<13),
    RIG_MODE_ECSSLSB =      (1<<14),
    RIG_MODE_FAX =          (1<<15),
    RIG_MODE_SAM =          (1<<16),
    RIG_MODE_SAL =          (1<<17),
    RIG_MODE_SAH =          (1<<18),
    RIG_MODE_DSB =      (1<<19),
    RIG_MODE_FMN =      (1<<21),
    RIG_MODE_TESTS_MAX              
} rmode_t;


#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 start;     
  freq_t end;       
  rmode_t modes;    
  int low_power;    
  int high_power;   
  vfo_t vfo;        
  ant_t ant;        
} 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).start == Hz(0) && (r).end == Hz(0))

#define RIG_ITU_REGION1 1
#define RIG_ITU_REGION2 2
#define RIG_ITU_REGION3 3

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)

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;            
  int 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;       
  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 start;            
  int end;          
  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 }, } }


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);

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 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]; 
  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]; 
  struct tuning_step_list tuning_steps[TSLSTSIZ];   
  struct filter_list filters[FLTLSTSIZ];        
  cal_table_t str_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_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);
  int (*get_ant) (RIG * rig, vfo_t vfo, ant_t * ant);

  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_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 (*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, const channel_t * chan);
  int (*get_channel) (RIG * rig, channel_t * chan);

  const char *(*get_info) (RIG * rig);

  int (*set_chan_all_cb) (RIG * rig, chan_cb_t chan_cb, rig_ptr_t);
  int (*get_chan_all_cb) (RIG * rig, 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);

  const char *clone_combo_set;  
  const char *clone_combo_get;  
};

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;          
  int retry;            
  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; /*< Bit number for CM108 GPIO PTT */
    } cm108;        
    struct {
        int vid;    
        int pid;    
        int conf;   
        int iface;  
        int alt;    
        char *vendor_name; 
        char *product;     
    } usb;          
  } parm;           
} hamlib_port_t;

#if !defined(__APPLE__) || !defined(__cplusplus)
typedef hamlib_port_t port_t;
#endif


struct rig_state {
    /*
     * overridable fields
     */
  hamlib_port_t rigport;    
  hamlib_port_t pttport;    
  hamlib_port_t dcdport;    
  double vfo_comp;  
  int 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;     
  int mode_list;        
};


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 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_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) 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_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_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_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 */
extern HAMLIB_EXPORT(int) rig_get_ant HAMLIB_PARAMS((RIG *rig, vfo_t vfo, ant_t *ant));

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_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, const channel_t *chan)); /* mem */
extern HAMLIB_EXPORT(int) rig_get_channel HAMLIB_PARAMS((RIG *rig, channel_t *chan));

extern HAMLIB_EXPORT(int) rig_set_chan_all HAMLIB_PARAMS((RIG *rig, const channel_t chans[]));
extern HAMLIB_EXPORT(int) rig_get_chan_all HAMLIB_PARAMS((RIG *rig, channel_t chans[]));
extern HAMLIB_EXPORT(int) rig_set_chan_all_cb HAMLIB_PARAMS((RIG *rig, chan_cb_t chan_cb, rig_ptr_t));
extern HAMLIB_EXPORT(int) rig_get_chan_all_cb HAMLIB_PARAMS((RIG *rig, chan_cb_t chan_cb, rig_ptr_t));

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));
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));
extern HAMLIB_EXPORT(int) rig_set_mem_all HAMLIB_PARAMS((RIG *rig, const channel_t *chan, const struct confparams *, const value_t *));
extern HAMLIB_EXPORT(int) rig_get_mem_all HAMLIB_PARAMS((RIG *rig, 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(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));
#define rig_idx2setting(i) (1UL<<(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));
#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));
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_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(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);


__END_DECLS

#endif /* _RIG_H */