Logo Search packages:      
Sourcecode: hamlib version File versions  Download package

rig.h

Go to the documentation of this file.
/*
 *  Hamlib Interface - API header
 *  Copyright (c) 2000-2005 by Stephane Fillod and Frank Singleton
 *
 *    $Id: rig.h,v 1.124 2007/11/26 20:54:11 n0nb Exp $
 *
 *   This library is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU Library General Public License as
 *   published by the Free Software Foundation; either version 2 of
 *   the License, or (at your option) any later version.
 *
 *   This program 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 Library General Public License for more details.
 *
 *   You should have received a copy of the GNU Library General Public
 *   License along with this library; if not, write to the Free Software
 *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, 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 */

/**
 * \addtogroup rig
 * @{
 */

/*! \file rig.h
 *  \brief Hamlib rig data structures.
 *
 *  This file contains the data structures and definitions for the Hamlib rig API.
 *  see the rig.c file for more details on the rig API.
 */


/* __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[];

/**
 * \brief Hamlib error codes
 * Error codes that can be returned by the Hamlib functions
 */
00082 enum rig_errcode_e {
00083       RIG_OK=0,         /*!< No error, operation completed sucessfully */
00084       RIG_EINVAL,       /*!< invalid parameter */
00085       RIG_ECONF,        /*!< invalid configuration (serial,..) */
00086       RIG_ENOMEM,       /*!< memory shortage */
00087       RIG_ENIMPL,       /*!< function not implemented, but will be */
00088       RIG_ETIMEOUT,           /*!< communication timed out */
00089       RIG_EIO,          /*!< IO error, including open failed */
00090       RIG_EINTERNAL,          /*!< Internal Hamlib error, huh! */
00091       RIG_EPROTO,       /*!< Protocol error */
00092       RIG_ERJCTED,            /*!< Command rejected by the rig */
00093       RIG_ETRUNC,       /*!< Command performed, but arg truncated */
00094       RIG_ENAVAIL,            /*!< function not available */
00095       RIG_ENTARGET,           /*!< VFO not targetable */
00096       RIG_BUSERROR,           /*!< Error talking on the bus */
00097       RIG_BUSBUSY,            /*!< Collision on the bus */
00098       RIG_EARG,         /*!< NULL RIG handle or any invalid pointer parameter in get arg */
00099       RIG_EVFO,         /*!< Invalid VFO */
00100       RIG_EDOM          /*!< Argument out of domain of func */
};

/**
 *\brief Hamlib debug levels
 *
 * REM: Numeric order matters for debug level
 *
 * \sa rig_set_debug
 */
00110 enum rig_debug_level_e {
00111   RIG_DEBUG_NONE = 0,         /*!< no bug reporting */
00112   RIG_DEBUG_BUG,        /*!< serious bug */
00113   RIG_DEBUG_ERR,        /*!< error case (e.g. protocol, memory allocation) */
00114   RIG_DEBUG_WARN,       /*!< warning */
00115   RIG_DEBUG_VERBOSE,          /*!< verbose */
00116   RIG_DEBUG_TRACE       /*!< tracing */
};

/* --------------- Rig capabilities -----------------*/

/* Forward struct references */

struct rig;
struct rig_state;

/*!
 * \brief Rig structure definition (see rig for details).
 */
00129 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 42          /* 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 */


/**
 * \brief CTCSS and DCS type definition.
 *
 * Continuous Tone Controlled Squelch System (CTCSS)
 * sub-audible tone frequency are expressed in \em tenth of Hz.
 * For example, the subaudible tone of 88.5 Hz is represented within
 * Hamlib by 885.
 *
 * Digitally-Coded Squelch codes are simple direct integers.
 */
00153 typedef unsigned int tone_t;

/**
 * \brief Port type
 */
00158 typedef enum rig_port_e {
00159   RIG_PORT_NONE = 0,          /*!< No port */
00160   RIG_PORT_SERIAL,            /*!< Serial */
00161   RIG_PORT_NETWORK,           /*!< Network socket type */
00162   RIG_PORT_DEVICE,            /*!< Device driver, like the WiNRADiO */
00163   RIG_PORT_PACKET,            /*!< AX.25 network type, e.g. SV8CS protocol */
00164   RIG_PORT_DTMF,        /*!< DTMF protocol bridge via another rig, eg. Kenwood Sky Cmd System */
00165   RIG_PORT_ULTRA,       /*!< IrDA Ultra protocol! */
00166   RIG_PORT_RPC,               /*!< RPC wrapper */
00167   RIG_PORT_PARALLEL,          /*!< Parallel port */
00168   RIG_PORT_USB                /*!< USB port */
} rig_port_t;

/**
 * \brief Serial parity
 */
00174 enum serial_parity_e {
00175   RIG_PARITY_NONE = 0,        /*!< No parity */
00176   RIG_PARITY_ODD,       /*!< Odd */
00177   RIG_PARITY_EVEN       /*!< Even */
};

/**
 * \brief Serial handshake
 */
00183 enum serial_handshake_e {
00184   RIG_HANDSHAKE_NONE = 0,     /*!< No handshake */
00185   RIG_HANDSHAKE_XONXOFF,      /*!< Software XON/XOFF */
00186   RIG_HANDSHAKE_HARDWARE      /*!< Hardware CTS/RTS */
};


/**
 * \brief Serial control state
 */
00193 enum serial_control_state_e {
00194   RIG_SIGNAL_UNSET = 0, /*!< Unset or tri-state */
00195   RIG_SIGNAL_ON,  /*!< ON */
00196   RIG_SIGNAL_OFF  /*!< OFF */
};

/** \brief Rig type flags */
00200 typedef enum {
00201       RIG_FLAG_RECEIVER =     (1<<1),           /*!< Receiver */
00202       RIG_FLAG_TRANSMITTER =  (1<<2),           /*!< Transmitter */
00203       RIG_FLAG_SCANNER =      (1<<3),           /*!< Scanner */

00205       RIG_FLAG_MOBILE = (1<<4),           /*!< mobile sized */
00206       RIG_FLAG_HANDHELD =     (1<<5),           /*!< handheld sized */
00207       RIG_FLAG_COMPUTER =     (1<<6),           /*!< "Computer" rig */
00208       RIG_FLAG_TRUNKING =     (1<<7),           /*!< has trunking */
00209       RIG_FLAG_APRS =         (1<<8),           /*!< has APRS */
00210       RIG_FLAG_TNC =          (1<<9),           /*!< has TNC */
00211       RIG_FLAG_DXCLUSTER =    (1<<10),    /*!< has DXCluster */
00212       RIG_FLAG_TUNER =  (1<<11)     /*!< dumb tuner */
} 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


/**
 * \brief Development status of the backend
 */
00233 enum rig_status_e {
00234   RIG_STATUS_ALPHA = 0,       /*!< Alpha quality, i.e. development */
00235   RIG_STATUS_UNTESTED,        /*!< Written from available specs, rig unavailable for test, feedback wanted! */
00236   RIG_STATUS_BETA,            /*!< Beta quality */
00237   RIG_STATUS_STABLE,          /*!< Stable */
00238   RIG_STATUS_BUGGY,           /*!< Was stable, but something broke it! */
00239   RIG_STATUS_NEW        /*!< Initial release of code */
};

/**
 * \brief Repeater shift type
 */
00245 typedef enum {
00246   RIG_RPT_SHIFT_NONE = 0,     /*!< No repeater shift */
00247   RIG_RPT_SHIFT_MINUS,        /*!< "-" shift */
00248   RIG_RPT_SHIFT_PLUS          /*!< "+" shift */
} rptr_shift_t;

/**
 * \brief Split mode
 */
00254 typedef enum {
00255   RIG_SPLIT_OFF = 0,          /*!< Split mode disabled */
00256   RIG_SPLIT_ON                /*!< Split mode enabled */
} split_t;

/**
 * \brief Frequency type,
 * Frequency type unit in Hz, able to hold SHF frequencies.
 */
00263 typedef double freq_t;
/** \brief printf(3) format to be used for freq_t type */
00265 #define PRIfreq "f"
/** \brief scanf(3) format to be used for freq_t type */
00267 #define SCNfreq "lf"
#define FREQFMT SCNfreq

/**
 * \brief Short frequency type
 * Frequency in Hz restricted to 31bits, suitable for offsets, shifts, etc..
 */
00274 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)


/**
 * \brief VFO definition
 *
 * There are several ways of using a vfo_t. For most cases, using RIG_VFO_A,
 * RIG_VFO_B, RIG_VFO_CURR, etc., as opaque macros should suffice.
 *
 * Strictly speaking a VFO is Variable Frequency Oscillator.
 * Here, it is referred as a tunable channel, from the radio operator's
 * point of view. The channel can be designated individually by its real
 * number, or by using an alias.
 *
 * Aliases may or may not be honored by a backend and are defined using
 * high significant bits, i.e. RIG_VFO_MEM, RIG_VFO_MAIN, etc.
 *
 */
00304 typedef int vfo_t;

/** \brief '' -- used in caps */
00307 #define RIG_VFO_NONE    0

#define RIG_VFO_TX_FLAG    ((vfo_t)(1<<30))

/** \brief \c currVFO -- current "tunable channel"/VFO */
00312 #define RIG_VFO_CURR    ((vfo_t)(1<<29))

/** \brief \c MEM -- means Memory mode, to be used with set_vfo */
00315 #define RIG_VFO_MEM     ((vfo_t)(1<<28))

/** \brief \c VFO -- means (last or any)VFO mode, with set_vfo */
00318 #define RIG_VFO_VFO     ((vfo_t)(1<<27))

#define RIG_VFO_TX_VFO(v)     ((v)|RIG_VFO_TX_FLAG)

/** \brief \c TX -- alias for split tx or uplink, of VFO_CURR  */
00323 #define RIG_VFO_TX      RIG_VFO_TX_VFO(RIG_VFO_CURR)

/** \brief \c RX -- alias for split rx or downlink */
00326 #define RIG_VFO_RX      RIG_VFO_CURR

/** \brief \c Main -- alias for MAIN */
00329 #define RIG_VFO_MAIN    ((vfo_t)(1<<26))
/** \brief \c Sub -- alias for SUB */
00331 #define RIG_VFO_SUB     ((vfo_t)(1<<25))

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

/** \brief \c VFOA -- VFO A */
00336 #define RIG_VFO_A RIG_VFO_N(0)
/** \brief \c VFOB -- VFO B */
00338 #define RIG_VFO_B RIG_VFO_N(1)
/** \brief \c VFOC -- VFO C */
00340 #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_ALL  0x7fffffff


#define RIG_PASSBAND_NORMAL s_Hz(0)
/**
 * \brief Passband width, in Hz
 * \sa rig_passband_normal, rig_passband_narrow, rig_passband_wide
 */
00359 typedef shortfreq_t pbwidth_t;


/**
 * \brief DCD status
 */
00365 typedef enum dcd_e {
00366   RIG_DCD_OFF = 0,            /*!< Squelch closed */
00367   RIG_DCD_ON                  /*!< Squelch open */
} dcd_t;

/**
 * \brief DCD type
 * \sa rig_get_dcd
 */
00374 typedef enum {
00375   RIG_DCD_NONE = 0,           /*!< No DCD available */
00376   RIG_DCD_RIG,                /*!< Rig has DCD status support, i.e. rig has get_dcd cap */
00377   RIG_DCD_SERIAL_DSR,         /*!< DCD status from serial DSR signal */
00378   RIG_DCD_SERIAL_CTS,         /*!< DCD status from serial CTS signal */
00379   RIG_DCD_SERIAL_CAR,         /*!< DCD status from serial CD signal */
00380   RIG_DCD_PARALLEL            /*!< DCD status from parallel port pin */
} dcd_type_t;


/**
 * \brief PTT status
 */
00387 typedef enum {
00388   RIG_PTT_OFF = 0,            /*!< PTT activated */
00389   RIG_PTT_ON                  /*!< PTT desactivated */
} ptt_t;

/**
 * \brief PTT type
 * \sa rig_get_ptt
 */
00396 typedef enum {
00397   RIG_PTT_NONE = 0,           /*!< No PTT available */
00398   RIG_PTT_RIG,                /*!< Legacy PTT */
00399   RIG_PTT_SERIAL_DTR,         /*!< PTT control through serial DTR signal */
00400   RIG_PTT_SERIAL_RTS,         /*!< PTT control through serial RTS signal */
00401   RIG_PTT_PARALLEL            /*!< PTT control through parallel port */
} ptt_type_t;

/**
 * \brief Radio power state
 */
00407 typedef enum {
00408   RIG_POWER_OFF = 0,          /*!< Power off */
00409   RIG_POWER_ON =  (1<<0),           /*!< Power on */
00410   RIG_POWER_STANDBY =   (1<<1)            /*!< Standby */
} powerstat_t;

/**
 * \brief Reset operation
 */
00416 typedef enum {
00417   RIG_RESET_NONE =       0,         /*!< No reset */
00418   RIG_RESET_SOFT =      (1<<0),           /*!< Software reset */
00419   RIG_RESET_VFO = (1<<1),           /*!< VFO reset */
00420   RIG_RESET_MCALL =     (1<<2),           /*!< Memory clear */
00421   RIG_RESET_MASTER =    (1<<3)            /*!< Master reset */
} reset_t;


/**
 * \brief VFO operation
 *
 * A VFO operation is an action on a VFO (or tunable memory).
 * The difference with a function is that an action has no on/off
 * status, it is performed at once.
 *
 * Note: the vfo argument for some vfo operation may be irrelevant,
 * and thus will be ignored.
 *
 * The VFO/MEM "mode" is set by rig_set_vfo.\n
 * \c STRING used in rigctl
 *
 * \sa rig_parse_vfo_op() rig_strvfop()
 */
00440 typedef enum {
00441       RIG_OP_NONE =           0,  /*!< '' No VFO_OP */
00442       RIG_OP_CPY =            (1<<0),     /*!< \c CPY -- VFO A = VFO B */
00443       RIG_OP_XCHG =           (1<<1),     /*!< \c XCHG -- Exchange VFO A/B */
00444       RIG_OP_FROM_VFO = (1<<2),     /*!< \c FROM_VFO -- VFO->MEM */
00445       RIG_OP_TO_VFO =         (1<<3),     /*!< \c TO_VFO -- MEM->VFO */
00446       RIG_OP_MCL =            (1<<4),     /*!< \c MCL -- Memory clear */
00447       RIG_OP_UP =       (1<<5),     /*!< \c UP -- UP increment VFO freq by tuning step*/
00448       RIG_OP_DOWN =           (1<<6),     /*!< \c DOWN -- DOWN decrement VFO freq by tuning step*/
00449       RIG_OP_BAND_UP =  (1<<7),     /*!< \c BAND_UP -- Band UP */
00450       RIG_OP_BAND_DOWN =      (1<<8),     /*!< \c BAND_DOWN -- Band DOWN */
00451       RIG_OP_LEFT =           (1<<9),     /*!< \c LEFT -- LEFT */
00452       RIG_OP_RIGHT =          (1<<10),/*!< \c RIGHT -- RIGHT */
00453       RIG_OP_TUNE =           (1<<11),/*!< \c TUNE -- Start tune */
00454       RIG_OP_TOGGLE =         (1<<12) /*!< \c TOGGLE -- Toggle VFOA and VFOB */
} vfo_op_t;


/**
 * \brief Rig Scan operation
 *
 * Various scan operations supported by a rig.\n
 * \c STRING used in rigctl
 *
 * \sa rig_parse_scan() rig_strscan()
 */
00466 typedef enum {
00467       RIG_SCAN_NONE =         0,  /*!< '' No Scan */
00468       RIG_SCAN_STOP =         RIG_SCAN_NONE, /*!< \c STOP -- Stop scanning */
00469       RIG_SCAN_MEM =          (1<<0),     /*!< \c MEM -- Scan all memory channels */
00470       RIG_SCAN_SLCT =         (1<<1),     /*!< \c SLCT -- Scan all selected memory channels */
00471       RIG_SCAN_PRIO =         (1<<2),     /*!< \c PRIO -- Priority watch (mem or call channel) */
00472       RIG_SCAN_PROG =         (1<<3),     /*!< \c PROG -- Programmed(edge) scan */
00473       RIG_SCAN_DELTA =  (1<<4),     /*!< \c DELTA -- delta-f scan */
00474       RIG_SCAN_VFO =          (1<<5),     /*!< \c VFO -- most basic scan */
00475       RIG_SCAN_PLT =          (1<<6)  /*!< \c PLT -- Scan using pipelined tuning */
} scan_t;

/**
 * \brief configuration token
 */
00481 typedef long token_t;

#define RIG_CONF_END 0

/**
 * \brief parameter types
 *
 *   Used with configuration, parameter and extra-parm tables.
 * 
 *   Current internal implementation
 *   NUMERIC: val.f or val.i
 *   COMBO: val.i, starting from 0.  Points to a table of strings or asci stored values.
 *   STRING: val.s or val.cs
 *   CHECKBUTTON: val.i 0/1
 */

/* strongly inspired from soundmodem. Thanks Thomas! */

00499 enum rig_conf_e {
00500       RIG_CONF_STRING,  /*!<  String type */
00501       RIG_CONF_COMBO,         /*!<  Combo type */
00502       RIG_CONF_NUMERIC, /*!<  Numeric type integer or real */
00503       RIG_CONF_CHECKBUTTON    /*!<  on/off type */
};

#define RIG_COMBO_MAX   8

/**
 * \brief Configuration parameter structure.
 */
00511 struct confparams {
00512   token_t token;        /*!< Conf param token ID */
00513   const char *name;           /*!< Param name, no spaces allowed */
00514   const char *label;          /*!< Human readable label */
00515   const char *tooltip;        /*!< Hint on the parameter */
00516   const char *dflt;           /*!< Default value */
00517   enum rig_conf_e type;       /*!< Type of the parameter */
  union {               /*!< */
      struct {          /*!< */
00520             float min;  /*!< Minimum value */
00521             float max;  /*!< Maximum value */
00522             float step; /*!< Step */
      } n;              /*!< Numeric type */
      struct {          /*!< */
00525             const char *combostr[RIG_COMBO_MAX];      /*!< Combo list */
      } c;              /*!< Combo type */
  } u;                        /*!< Type union */
};

/** \brief Announce
 *
 * Designate optional speech synthesizer.
 */
00534 typedef enum {
00535       RIG_ANN_NONE =    0,          /*!< None */
00536       RIG_ANN_OFF =     RIG_ANN_NONE,     /*!< disable announces */
00537       RIG_ANN_FREQ =    (1<<0),           /*!< Announce frequency */
00538       RIG_ANN_RXMODE = (1<<1),      /*!< Announce receive mode */
00539       RIG_ANN_CW = (1<<2),          /*!< CW */
00540       RIG_ANN_ENG = (1<<3),         /*!< English */
00541       RIG_ANN_JAP = (1<<4)          /*!< Japan */
} ann_t;


/**
 * \brief Antenna number
 */
00548 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)

/**
 * \brief AGC delay settings
 */
/* TODO: kill me, and replace by real AGC delay */
00561 enum agc_level_e {
      RIG_AGC_OFF = 0,
      RIG_AGC_SUPERFAST,
      RIG_AGC_FAST,
      RIG_AGC_SLOW,
00566       RIG_AGC_USER,           /*!< user selectable */
      RIG_AGC_MEDIUM
};

/**
 * \brief Level display meters
 */
00573 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 */
};

/**
 * \brief Universal approach for passing values
 * \sa rig_set_level, rig_get_level, rig_set_parm, rig_get_parm
 */
00586 typedef union {
00587   signed int i;               /*!< Signed integer */
00588   float f;              /*!< Single precision float */
00589   char *s;              /*!< Pointer to char string */
00590   const char *cs;       /*!< Pointer to constant char string */
} value_t;

/** \brief Rig Level Settings
 *
 * Various operating levels supported by a rig.\n
 * \c STRING used in rigctl
 *
 * \sa rig_parse_level() rig_strlevel()
 */

00601 enum rig_level_e {
00602       RIG_LEVEL_NONE =  0,    /*!< '' -- No Level */
00603       RIG_LEVEL_PREAMP =      (1<<0),     /*!< \c PREAMP -- Preamp, arg int (dB) */
00604       RIG_LEVEL_ATT =         (1<<1),     /*!< \c ATT -- Attenuator, arg int (dB) */
00605       RIG_LEVEL_VOX =         (1<<2),     /*!< \c VOX -- VOX delay, arg int (tenth of seconds) */
00606       RIG_LEVEL_AF =          (1<<3),     /*!< \c AF -- Volume, arg float [0.0 ... 1.0] */
00607       RIG_LEVEL_RF =          (1<<4),     /*!< \c RF -- RF gain (not TX power), arg float [0.0 ... 1.0] */
00608       RIG_LEVEL_SQL =         (1<<5),     /*!< \c SQL -- Squelch, arg float [0.0 ... 1.0] */
00609       RIG_LEVEL_IF =          (1<<6),     /*!< \c IF -- IF, arg int (Hz) */
00610       RIG_LEVEL_APF =         (1<<7),     /*!< \c APF -- APF, arg float [0.0 ... 1.0] */
00611       RIG_LEVEL_NR =          (1<<8),     /*!< \c NR -- Noise Reduction, arg float [0.0 ... 1.0] */
00612       RIG_LEVEL_PBT_IN =      (1<<9),     /*!< \c PBT_IN -- Twin PBT (inside), arg float [0.0 ... 1.0] */
00613       RIG_LEVEL_PBT_OUT =     (1<<10),/*!< \c PBT_OUT -- Twin PBT (outside), arg float [0.0 ... 1.0] */
00614       RIG_LEVEL_CWPITCH =     (1<<11),/*!< \c CWPITCH -- CW pitch, arg int (Hz) */
00615       RIG_LEVEL_RFPOWER =     (1<<12),/*!< \c RFPOWER -- RF Power, arg float [0.0 ... 1.0] */
00616       RIG_LEVEL_MICGAIN =     (1<<13),/*!< \c MICGAIN -- MIC Gain, arg float [0.0 ... 1.0] */
00617       RIG_LEVEL_KEYSPD =      (1<<14),/*!< \c KEYSPD -- Key Speed, arg int (WPM) */
00618       RIG_LEVEL_NOTCHF =      (1<<15),/*!< \c NOTCHF -- Notch Freq., arg int (Hz) */
00619       RIG_LEVEL_COMP =  (1<<16),/*!< \c COMP -- Compressor, arg float [0.0 ... 1.0] */
00620       RIG_LEVEL_AGC =         (1<<17),/*!< \c AGC -- AGC, arg int (see enum agc_level_e) */
00621       RIG_LEVEL_BKINDL =      (1<<18),/*!< \c BKINDL -- BKin Delay, arg int (tenth of dots) */
00622       RIG_LEVEL_BALANCE =     (1<<19),/*!< \c BAL -- Balance (Dual Watch), arg float [0.0 ... 1.0] */
00623       RIG_LEVEL_METER = (1<<20),/*!< \c METER -- Display meter, arg int (see enum meter_level_e) */

00625       RIG_LEVEL_VOXGAIN =     (1<<21),/*!< \c VOXGAIN -- VOX gain level, arg float [0.0 ... 1.0] */
00626       RIG_LEVEL_VOXDELAY =  RIG_LEVEL_VOX,      /*!< Synonym of RIG_LEVEL_VOX */
00627       RIG_LEVEL_ANTIVOX =     (1<<22),/*!< \c ANTIVOX -- anti-VOX level, arg float [0.0 ... 1.0] */
00628       RIG_LEVEL_SLOPE_LOW = (1<<23),/*!< \c SLOPE_LOW -- Slope tune, low frequency cut, */
00629       RIG_LEVEL_SLOPE_HIGH = (1<<24),/*!< \c SLOPE_HIGH -- Slope tune, high frequency cut, */
      //RIG_LEVEL_LINEOUT =   (1<<23),/*!< Lineout Volume, arg float [0.0 ... 1.0] */

            /*!< These ones are not settable */
00633       RIG_LEVEL_RAWSTR =      (1<<26),/*!< \c RAWSTR -- Raw (A/D) value for signal strength, specific to each rig, arg int */
00634       RIG_LEVEL_SQLSTAT =     (1<<27),/*!< \c SQLSTAT -- SQL status, arg int (open=1/closed=0). Deprecated, use get_dcd instead */
00635       RIG_LEVEL_SWR =         (1<<28),/*!< \c SWR -- SWR, arg float [0.0 ... infinite] */
00636       RIG_LEVEL_ALC =         (1<<29),/*!< \c ALC -- ALC, arg float */
00637       RIG_LEVEL_STRENGTH =(1<<30) /*!< \c STRENGTH -- Effective (calibrated) signal strength relative to S9, arg int (dB) */
      /*RIG_LEVEL_BWC =       (1<<31)*/ /*!< Bandwidth Control, arg int (Hz) */
};

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


/**
 * \brief Rig Parameters
 *
 * Parameters are settings that are not VFO specific.\n
 * \c STRING used in rigctl
 *
 * \sa rig_parse_parm() rig_strparm()
 */
00657 enum rig_parm_e {
00658       RIG_PARM_NONE =         0,    /*!< '' -- No Parm */
00659       RIG_PARM_ANN =          (1<<0),     /*!< \c ANN -- "Announce" level, see ann_t */
00660       RIG_PARM_APO =          (1<<1),     /*!< \c APO -- Auto power off, int in minute */
00661       RIG_PARM_BACKLIGHT =    (1<<2),     /*!< \c BACKLIGHT -- LCD light, float [0.0 ... 1.0] */
00662       RIG_PARM_BEEP =         (1<<4),     /*!< \c BEEP -- Beep on keypressed, int (0,1) */
00663       RIG_PARM_TIME =         (1<<5),     /*!< \c TIME -- hh:mm:ss, int in seconds from 00:00:00 */
00664       RIG_PARM_BAT =          (1<<6),     /*!< \c BAT -- battery level, float [0.0 ... 1.0] */
00665       RIG_PARM_KEYLIGHT =     (1<<7)  /*!< \c KEYLIGHT -- Button backlight, on/off */
};

#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
/**
 * \brief Setting
 *
 * This can be a func, a level or a parm.
 * Each bit designates one of them.
 */
00681 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


/**
 * \brief Rig Function Settings
 *
 * Various operating functions supported by a rig.\n
 * \c STRING used in rigctl
 *
 * \sa rig_parse_func() rig_strfunc()
 */
00700 enum rig_func_e {
00701       RIG_FUNC_NONE =         0,    /*!< '' -- No Function */
00702     RIG_FUNC_FAGC =     (1<<0),     /*!< \c FAGC -- Fast AGC */
00703     RIG_FUNC_NB =       (1<<1),     /*!< \c NB -- Boise Blanker */
00704       RIG_FUNC_COMP =         (1<<2),     /*!< \c COMP -- Speech Compression */
00705       RIG_FUNC_VOX =          (1<<3),     /*!< \c VOX -- Voice Operated Relay */
00706       RIG_FUNC_TONE =         (1<<4),     /*!< \c TONE -- CTCSS Tone */
00707       RIG_FUNC_TSQL =         (1<<5),     /*!< \c TSQL -- CTCSS Activate/De-activate */
00708       RIG_FUNC_SBKIN =        (1<<6),     /*!< \c SBKIN -- Semi Break-in (CW mode) */
00709       RIG_FUNC_FBKIN =        (1<<7),     /*!< \c FBKIN -- Full Break-in (CW mode) */
00710       RIG_FUNC_ANF =          (1<<8),     /*!< \c ANF -- Automatic Notch Filter (DSP) */
00711       RIG_FUNC_NR =           (1<<9),     /*!< \c NR -- Noise Reduction (DSP) */
00712       RIG_FUNC_AIP =          (1<<10),/*!< \c AIP -- RF pre-amp (AIP on Kenwood, IPO on Yaesu, etc.) */
00713       RIG_FUNC_APF =          (1<<11),/*!< \c APF -- Auto Passband Filter */
00714       RIG_FUNC_MON =          (1<<12),/*!< \c MON -- Monitor transmitted signal */
00715       RIG_FUNC_MN =           (1<<13),/*!< \c MN -- Manual Notch */
00716       RIG_FUNC_RF =           (1<<14),/*!< \c RF -- RTTY Filter */
00717       RIG_FUNC_ARO =          (1<<15),/*!< \c ARO -- Auto Repeater Offset */
00718       RIG_FUNC_LOCK =         (1<<16),/*!< \c LOCK -- Lock */
00719       RIG_FUNC_MUTE =         (1<<17),/*!< \c MUTE -- Mute */
00720       RIG_FUNC_VSC =          (1<<18),/*!< \c VSC -- Voice Scan Control */
00721       RIG_FUNC_REV =          (1<<19),/*!< \c REV -- Reverse transmit and receive frequencies */
00722       RIG_FUNC_SQL =          (1<<20),/*!< \c SQL -- Turn Squelch Monitor on/off */
00723       RIG_FUNC_ABM =          (1<<21),/*!< \c ABM -- Auto Band Mode */
00724       RIG_FUNC_BC =           (1<<22),/*!< \c BC -- Beat Canceller */
00725       RIG_FUNC_MBC =          (1<<23),/*!< \c MBC -- Manual Beat Canceller */
      /*                (1<<24), used to be RIG_FUNC_LMP, see RIG_PARM_BACKLIGHT instead) */
00727       RIG_FUNC_AFC =          (1<<25),/*!< \c AFC -- Auto Frequency Control ON/OFF */
00728       RIG_FUNC_SATMODE =      (1<<26),/*!< \c SATMODE -- Satellite mode ON/OFF */
00729       RIG_FUNC_SCOPE =        (1<<27),/*!< \c SCOPE -- Simple bandscope ON/OFF */
00730       RIG_FUNC_RESUME = (1<<28),/*!< \c RESUME -- Scan auto-resume */
00731       RIG_FUNC_TBURST = (1<<29),/*!< \c TBURST -- 1750 Hz tone burst */
00732       RIG_FUNC_TUNER =  (1<<30) /*!< \c TUNER -- Enable automatic tuner */
};

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

/**
 * \brief Radio mode
 *
 * Various modes supported by a rig.\n
 * \c STRING used in rigctl
 *
 * \sa rig_parse_mode() rig_strrmode()
 */
00752 typedef enum {
00753       RIG_MODE_NONE =   0,    /*!< '' -- None */
00754       RIG_MODE_AM =     (1<<0),     /*!< \c AM -- Amplitude Modulation */
00755       RIG_MODE_CW =     (1<<1),     /*!< \c CW -- CW "normal" sideband */
00756       RIG_MODE_USB =          (1<<2),     /*!< \c USB -- Upper Side Band */
00757       RIG_MODE_LSB =          (1<<3),     /*!< \c LSB -- Lower Side Band */
00758       RIG_MODE_RTTY =         (1<<4),     /*!< \c RTTY -- Radio Teletype */
00759       RIG_MODE_FM =     (1<<5),     /*!< \c FM -- "narrow" band FM */
00760       RIG_MODE_WFM =    (1<<6),     /*!< \c WFM -- broadcast wide FM */
00761       RIG_MODE_CWR =    (1<<7),     /*!< \c CWR -- CW "reverse" sideband */
00762       RIG_MODE_RTTYR =  (1<<8),     /*!< \c RTTYR -- RTTY "reverse" sideband */
00763       RIG_MODE_AMS =          (1<<9),     /*!< \c AMS -- Amplitude Modulation Synchronous */
00764       RIG_MODE_PKTLSB =       (1<<10),/*!< \c PKTLSB -- Packet/Digital LSB mode (dedicated port) */
00765       RIG_MODE_PKTUSB =       (1<<11),/*!< \c PKTUSB -- Packet/Digital USB mode (dedicated port) */
00766       RIG_MODE_PKTFM =        (1<<12),/*!< \c PKTFM -- Packet/Digital FM mode (dedicated port) */
00767       RIG_MODE_ECSSUSB =      (1<<13),/*!< \c ECSSUSB -- Exalted Carrier Single Sideband USB */
00768       RIG_MODE_ECSSLSB =      (1<<14),/*!< \c ECSSLSB -- Exalted Carrier Single Sideband LSB */
00769       RIG_MODE_FAX =          (1<<15),/*!< \c FAX -- Facsimile Mode */
00770       RIG_MODE_SAM =          (1<<16),/*!< \c SAM -- Synchronous AM double sideband */
00771       RIG_MODE_SAL =          (1<<17),/*!< \c SAL -- Synchronous AM lower sideband */
00772       RIG_MODE_SAH =          (1<<18),/*!< \c SAH -- Synchronous AM upper (higher) sideband */
00773       RIG_MODE_DSB =                (1<<19) /*!< \c DSB -- Double sideband suppressed carrier */
} rmode_t;

/** \brief macro for backends, not to be used by rig_set_mode et al. */
00777 #define RIG_MODE_SSB    (RIG_MODE_USB|RIG_MODE_LSB)

/** \brief macro for backends, not to be used by rig_set_mode et al. */
00780 #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)

/**
 * \brief Frequency range
 *
 * Put together a group of this struct in an array to define
 * what frequencies your rig has access to.
 */
00792 typedef struct freq_range_list {
00793   freq_t start;         /*!< Start frequency */
00794   freq_t end;           /*!< End frequency */
00795   rmode_t modes;  /*!< Bit field of RIG_MODE's */
00796   int low_power;  /*!< Lower RF power in mW, -1 for no power (ie. rx list) */
00797   int high_power; /*!< Higher RF power in mW, -1 for no power (ie. rx list) */
00798   vfo_t vfo;            /*!< VFO list equipped with this range */
00799   ant_t ant;            /*!< Antenna list equipped with this range, 0 means all */
} 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

/**
 * \brief Tuning step definition
 *
 * Lists the tuning steps available for each mode.
 *
 * If a ts field in the list has RIG_TS_ANY value,
 * this means the rig allows its tuning step to be
 * set to any value ranging from the lowest to the
 * highest (if any) value in the list for that mode.
 * The tuning step must be sorted in the ascending
 * order, and the RIG_TS_ANY value, if present, must
 * be the last one in the list.
 *
 * Note also that the minimum frequency resolution
 * of the rig is determined by the lowest value
 * in the Tuning step list.
 *
 * \sa rig_set_ts, rig_get_resolution
 */
00828 struct tuning_step_list {
00829   rmode_t modes;  /*!< Bit field of RIG_MODE's */
00830   shortfreq_t ts; /*!< Tuning step in Hz */
};

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

/**
 * \brief Filter definition
 *
 * Lists the filters available for each mode.
 *
 * If more than one filter is available for a given mode,
 * the first entry in the array will be the default
 * filter to use for the normal passband of this mode.
 * The first entry in the array below the default normal passband
 * is the default narrow passband and the first entry in the array 
 * above the default normal passband is the default wide passband.
 * Note: if there's no lower width or upper width, then narrow or
 * respectively wide passband is equal to the default normal passband.
 *
 * If a width field in the list has RIG_FLT_ANY value,
 * this means the rig allows its passband width to be
 * set to any value ranging from the lowest to the
 * highest value (if any) in the list for that mode.
 * The RIG_TS_ANY value, if present, must
 * be the last one in the list.
 *
 * The width field is the narrowest passband in a transmit/receive chain
 * with regard to different IF.
 * 
 * \sa rig_set_mode, rig_passband_normal, rig_passband_narrow, rig_passband_wide
 */
00863 struct filter_list {
00864   rmode_t modes;  /*!< Bit field of RIG_MODE's */
00865   pbwidth_t width;      /*!< Passband width in Hz */
};

#define RIG_FLT_ANY     0
#define RIG_FLT_END     {RIG_MODE_NONE,0}
#define RIG_IS_FLT_END(f)     ((f).modes == RIG_MODE_NONE)


/*
 * Used in the channel.flags field
 */
#define RIG_CHFLAG_NONE 0
#define RIG_CHFLAG_SKIP (1<<0)
/* DATA port mode flag */
#define RIG_CHFLAG_DATA (1<<1)

/**
 * \brief Extension attribute definition
 *
 */
00885 struct ext_list {
00886   token_t token;  /*!< Token ID */
00887   value_t val;          /*!< Value */
};

#define RIG_EXT_END     {0, {.i=0}}
#define RIG_IS_EXT_END(x)     ((x).token == 0)

/**
 * \brief Channel structure
 *
 * The channel struct stores all the attributes peculiar to a VFO.
 *
 * \sa rig_set_channel, rig_get_channel
 */
00900 struct channel {
00901   int channel_num;            /*!< Channel number */
00902   int bank_num;               /*!< Bank number */
00903   vfo_t vfo;                  /*!< VFO */
00904   int ant;              /*!< Selected antenna */
00905   freq_t freq;                /*!< Receive frequency */
00906   rmode_t mode;               /*!< Receive mode */
00907   pbwidth_t width;            /*!< Receive passband width associated with mode */

00909   freq_t tx_freq;       /*!< Transmit frequency */
00910   rmode_t tx_mode;            /*!< Transmit mode */
00911   pbwidth_t tx_width;         /*!< Transmit passband width associated with mode */

00913   split_t split;        /*!< Split mode */
00914   vfo_t tx_vfo;               /*!< Split transmit VFO */

00916   rptr_shift_t rptr_shift;    /*!< Repeater shift */
00917   shortfreq_t rptr_offs;      /*!< Repeater offset */
00918   shortfreq_t tuning_step;    /*!< Tuning step */
00919   shortfreq_t rit;            /*!< RIT */
00920   shortfreq_t xit;            /*!< XIT */
00921   setting_t funcs;            /*!< Function status */
00922   value_t levels[RIG_SETTING_MAX];  /*!< Level values */
00923   tone_t ctcss_tone;          /*!< CTCSS tone */
00924   tone_t ctcss_sql;           /*!< CTCSS squelch tone */
00925   tone_t dcs_code;            /*!< DCS code */
00926   tone_t dcs_sql;       /*!< DCS squelch code */
00927   int scan_group;       /*!< Scan group */
00928   int flags;                  /*!< Channel flags, see RIG_CHFLAG's */
00929   char channel_desc[MAXCHANDESC];   /*!< Name */
00930   struct ext_list *ext_levels;      /*!< Extension level value list, NULL ended. ext_levels can be NULL */
};
/** \brief Channel structure typedef */
00933 typedef struct channel channel_t;

/**
 * \brief Channel capability definition
 *
 * Definition of the attributes that can be stored/retrieved in/from memory
 */
00940 struct channel_cap {
00941   unsigned bank_num:1;        /*!< Bank number */
00942   unsigned vfo:1;       /*!< VFO */
00943   unsigned ant:1;       /*!< Selected antenna */
00944   unsigned freq:1;            /*!< Receive frequency */
00945   unsigned mode:1;            /*!< Receive mode */
00946   unsigned width:1;           /*!< Receive passband width associated with mode */

00948   unsigned tx_freq:1;         /*!< Transmit frequency */
00949   unsigned tx_mode:1;         /*!< Transmit mode */
00950   unsigned tx_width:1;        /*!< Transmit passband width associated with mode */

00952   unsigned split:1;           /*!< Split mode */
00953   unsigned tx_vfo:1;          /*!< Split transmit VFO */
00954   unsigned rptr_shift:1;      /*!< Repeater shift */
00955   unsigned rptr_offs:1;       /*!< Repeater offset */
00956   unsigned tuning_step:1;     /*!< Tuning step */
00957   unsigned rit:1;       /*!< RIT */
00958   unsigned xit:1;       /*!< XIT */
00959   setting_t funcs;            /*!< Function status */
00960   setting_t levels;           /*!< Level values */
00961   unsigned ctcss_tone:1;      /*!< CTCSS tone */
00962   unsigned ctcss_sql:1;       /*!< CTCSS squelch tone */
00963   unsigned dcs_code:1;        /*!< DCS code */
00964   unsigned dcs_sql:1;         /*!< DCS squelch code */
00965   unsigned scan_group:1;      /*!< Scan group */
00966   unsigned flags:1;           /*!< Channel flags */
00967   unsigned channel_desc:1;    /*!< Name */
00968   unsigned ext_levels:1;      /*!< Extension level value list */
};

/** \brief Channel cap */
00972 typedef struct channel_cap channel_cap_t;


/**
 * \brief Memory channel type definition
 *
 * Definition of memory types. Depending on the type, the content
 * of the memory channel has to be interpreted accordingly.
 * For instance, a RIG_MTYPE_EDGE channel_t will hold only a start 
 * or stop frequency.
 *
 * \sa chan_list
 */
00985 typedef enum {
00986   RIG_MTYPE_NONE=0,           /*!< None */
00987   RIG_MTYPE_MEM,        /*!< Regular */
00988   RIG_MTYPE_EDGE,       /*!< Scan edge */
00989   RIG_MTYPE_CALL,       /*!< Call channel */
00990   RIG_MTYPE_MEMOPAD,          /*!< Memory pad */
00991   RIG_MTYPE_SAT               /*!< Satellite */
} chan_type_t;

/**
 * \brief Memory channel list definition
 *
 * Example for the Ic706MkIIG (99 memory channels, 2 scan edges, 2 call chans):
\code
      chan_t chan_list[] = {
            { 1, 99, RIG_MTYPE_MEM  },
            { 100, 103, RIG_MTYPE_EDGE },
            { 104, 105, RIG_MTYPE_CALL },
            RIG_CHAN_END
      }
\endcode
 */
01007 struct chan_list {
01008   int start;                  /*!< Starting memory channel \b number */
01009   int end;              /*!< Ending memory channel \b number */
01010   chan_type_t type;           /*!< Memory type. see chan_type_t */
01011   channel_cap_t mem_caps;     /*!< Definition of attributes that can be stored/retrieved */
};

#define RIG_CHAN_END     {0,0,RIG_MTYPE_NONE}
#define RIG_IS_CHAN_END(c)    ((c).type == RIG_MTYPE_NONE)

/** \brief chan_t type */
01018 typedef struct chan_list chan_t;

/**
 * \brief level/parm granularity definition
 *
 * The granularity is undefined if min=0, max=0, and step=0.
 *
 * For float settings, if min.f=0 and max.f=0 (and step.f!=0),
 * max.f is assumed to be actually equal to 1.0.
 *
 * If step=0 (and min and/or max are not null), then this means step
 * can have maximum resolution, depending on type (int or float).
 */
01031 struct gran {
01032       value_t min;            /*!< Minimum value */
01033       value_t max;            /*!< Maximum value */
01034       value_t step;           /*!< Step */
};

/** \brief gran_t type */
01038 typedef     struct gran gran_t;


/** \brief Calibration table struct */
01042 struct cal_table {
01043       int size;         /*!< number of plots in the table */
      struct {
01045             int raw;    /*!< raw (A/D) value, as returned by \a RIG_LEVEL_RAWSTR */
01046             int val;    /*!< associated value, basically the measured dB value */
      } table[MAX_CAL_LENGTH];      /*!< table of plots */
};

/**
 * \brief calibration table type
 *
 * cal_table_t is a data type suited to hold linear calibration.
 * cal_table_t.size tells the number of plots cal_table_t.table contains.
 *
 * If a value is below or equal to cal_table_t.table[0].raw, 
 * rig_raw2val() will return cal_table_t.table[0].val.
 *
 * If a value is greater or equal to cal_table_t.table[cal_table_t.size-1].raw, 
 * rig_raw2val() will return cal_table_t.table[cal_table_t.size-1].val.
 */
01062 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);

/**
 * \brief Rig data structure.
 *
 * Basic rig type, can store some useful info about different radios.
 * Each lib must be able to populate this structure, so we can make
 * useful inquiries about capabilities.
 *
 * The main idea of this struct is that it will be defined by the backend
 * rig driver, and will remain readonly for the application.
 * Fields that need to be modifiable by the application are
 * copied into the struct rig_state, which is a kind of private
 * of the RIG instance.
 * This way, you can have several rigs running within the same application,
 * sharing the struct rig_caps of the backend, while keeping their own
 * customized data.
 * NB: don't move fields around, as backend depends on it when initializing
 *     their caps.
 */
01088 struct rig_caps {
01089   rig_model_t rig_model;      /*!< Rig model. */
01090   const char *model_name;     /*!< Model name. */
01091   const char *mfg_name;       /*!< Manufacturer. */
01092   const char *version;        /*!< Driver version. */
01093   const char *copyright;      /*!< Copyright info. */
01094   enum rig_status_e status;   /*!< Driver status. */

01096   int rig_type;               /*!< Rig type. */
01097   ptt_type_t ptt_type;        /*!< Type of the PTT port. */
01098   dcd_type_t dcd_type;        /*!< Type of the DCD port. */
01099   rig_port_t port_type;       /*!< Type of communication port. */

01101   int serial_rate_min;        /*!< Minimum serial speed. */
01102   int serial_rate_max;        /*!< Maximum serial speed. */
01103   int serial_data_bits;       /*!< Number of data bits. */
01104   int serial_stop_bits;       /*!< Number of stop bits. */
01105   enum serial_parity_e serial_parity;           /*!< Parity. */
01106   enum serial_handshake_e serial_handshake;     /*!< Handshake. */

01108   int write_delay;            /*!< Delay between each byte sent out, in mS */
01109   int post_write_delay;       /*!< Delay between each commands send out, in mS */
01110   int timeout;                /*!< Timeout, in mS */
01111   int retry;                  /*!< Maximum number of retries if command fails, 0 to disable */

01113   setting_t has_get_func;     /*!< List of get functions */
01114   setting_t has_set_func;     /*!< List of set functions */
01115   setting_t has_get_level;    /*!< List of get level */
01116   setting_t has_set_level;    /*!< List of set level */
01117   setting_t has_get_parm;     /*!< List of get parm */
01118   setting_t has_set_parm;     /*!< List of set parm */

01120   gran_t level_gran[RIG_SETTING_MAX];     /*!< level granularity (i.e. steps) */
01121   gran_t parm_gran[RIG_SETTING_MAX];      /*!< parm granularity (i.e. steps) */

01123   const struct confparams *extparms;      /*!< Extension parm list, \sa ext.c */
01124   const struct confparams *extlevels;     /*!< Extension level list, \sa ext.c */

01126   const tone_t *ctcss_list;   /*!< CTCSS tones list, zero ended */
01127   const tone_t *dcs_list;     /*!< DCS code list, zero ended */

01129   int preamp[MAXDBLSTSIZ];    /*!< Preamp list in dB, 0 terminated */
01130   int attenuator[MAXDBLSTSIZ];      /*!< Preamp list in dB, 0 terminated */
01131   shortfreq_t max_rit;        /*!< max absolute RIT */
01132   shortfreq_t max_xit;        /*!< max absolute XIT */
01133   shortfreq_t max_ifshift;    /*!< max absolute IF-SHIFT */

01135   ann_t announces;      /*!< Announces bit field list */

01137   vfo_op_t vfo_ops;     /*!< VFO op bit field list */
01138   scan_t scan_ops;      /*!< Scan bit field list */
01139   int targetable_vfo;   /*!< Bit field list of direct VFO access commands */
01140   int transceive; /*!< Supported transceive mode */

01142   int bank_qty;         /*!< Number of banks */
01143   int chan_desc_sz;     /*!< Max length of memory channel name */

01145   chan_t chan_list[CHANLSTSIZ];     /*!< Channel list, zero ended */

01147   freq_range_t rx_range_list1[FRQRANGESIZ];     /*!< Receive frequency range list for ITU region 1 */
01148   freq_range_t tx_range_list1[FRQRANGESIZ];     /*!< Transmit frequency range list for ITU region 1 */
01149   freq_range_t rx_range_list2[FRQRANGESIZ];     /*!< Receive frequency range list for ITU region 2 */
01150   freq_range_t tx_range_list2[FRQRANGESIZ];     /*!< Transmit frequency range list for ITU region 2 */

01152   struct tuning_step_list tuning_steps[TSLSTSIZ];     /*!< Tuning step list */
01153   struct filter_list filters[FLTLSTSIZ];        /*!< mode/filter table, at -6dB */

01155   cal_table_t str_cal;                    /*!< S-meter calibration table */

01157   const struct confparams *cfgparams;            /*!< Configuration parametres. */
01158   const rig_ptr_t priv;                          /*!< Private data. */

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

01289   const char *clone_combo_set;      /*!< String describing key combination to enter load cloning mode */
01290   const char *clone_combo_get;      /*!< String describing key combination to enter save cloning mode */
};

/**
 * \brief Port definition
 *
 * Of course, looks like OO painstakingly programmed in C, sigh.
 */
01298 typedef struct {
  union {
01300       rig_port_t rig;         /*!< Communication port type */
01301       ptt_type_t ptt;         /*!< PTT port type */
01302       dcd_type_t dcd;         /*!< DCD port type */
  } type;
01304   int fd;               /*!< File descriptor */
01305   void* handle;               /*!< handle for USB */

01307   int write_delay;            /*!< Delay between each byte sent out, in mS */
01308   int post_write_delay;       /*!< Delay between each commands send out, in mS */
  struct { int tv_sec,tv_usec; } post_write_date;     /*!< hamlib internal use */
01310   int timeout;                /*!< Timeout, in mS */
01311   int retry;                  /*!< Maximum number of retries, 0 to disable */

01313   char pathname[FILPATHLEN];  /*!< Port pathname */
  union {
      struct {
01316             int rate;   /*!< Serial baud rate */
01317             int data_bits;    /*!< Number of data bits */
01318             int stop_bits;    /*!< Number of stop bits */
01319             enum serial_parity_e parity;        /*!< Serial parity */
01320             enum serial_handshake_e handshake;  /*!< Serial handshake */
01321             enum serial_control_state_e rts_state;    /*!< RTS set state */
01322             enum serial_control_state_e dtr_state;    /*!< DTR set state */
      } serial;         /*!< serial attributes */
      struct {
01325             int pin;    /*!< Parallel port pin number */
      } parallel;       /*!< parallel attributes */
      struct {
01328             int vid;    /*!< Vendor ID */
01329             int pid;    /*!< Product ID */
01330             int conf;   /*!< Configuration */
01331             int iface;  /*!< interface */
01332             int alt;    /*!< alternate */
      } usb;                  /*!< USB attributes */
  } parm;               /*!< Port parameter union */
} hamlib_port_t;

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


/** 
 * \brief Rig state containing live data and customized fields.
 *
 * This struct contains live data, as well as a copy of capability fields
 * that may be updated (ie. customized)
 *
 * It is fine to move fields around, as this kind of struct should
 * not be initialized like caps are.
 */
01351 struct rig_state {
      /*
       * overridable fields
       */
01355   hamlib_port_t rigport;      /*!< Rig port (internal use). */
01356   hamlib_port_t pttport;      /*!< PTT port (internal use). */
01357   hamlib_port_t dcdport;      /*!< DCD port (internal use). */

01359   double vfo_comp;      /*!< VFO compensation in PPM, 0.0 to disable */

01361   int itu_region; /*!< ITU region to select among freq_range_t */
01362   freq_range_t rx_range_list[FRQRANGESIZ];      /*!< Receive frequency range list */
01363   freq_range_t tx_range_list[FRQRANGESIZ];      /*!< Transmit frequency range list */

01365   struct tuning_step_list tuning_steps[TSLSTSIZ];     /*!< Tuning step list */

01367   struct filter_list filters[FLTLSTSIZ];  /*!< Mode/filter table, at -6dB */

01369   cal_table_t str_cal;                    /*!< S-meter calibration table */

01371   chan_t chan_list[CHANLSTSIZ];     /*!< Channel list, zero ended */

01373   shortfreq_t max_rit;        /*!< max absolute RIT */
01374   shortfreq_t max_xit;        /*!< max absolute XIT */
01375   shortfreq_t max_ifshift;    /*!< max absolute IF-SHIFT */

01377   ann_t announces;            /*!< Announces bit field list */

01379   int preamp[MAXDBLSTSIZ];    /*!< Preamp list in dB, 0 terminated */
01380   int attenuator[MAXDBLSTSIZ];      /*!< Preamp list in dB, 0 terminated */

01382   setting_t has_get_func;     /*!< List of get functions */
01383   setting_t has_set_func;     /*!< List of set functions */
01384   setting_t has_get_level;    /*!< List of get level */
01385   setting_t has_set_level;    /*!< List of set level */
01386   setting_t has_get_parm;     /*!< List of get parm */
01387   setting_t has_set_parm;     /*!< List of set parm */

01389   gran_t level_gran[RIG_SETTING_MAX];     /*!< level granularity */
01390   gran_t parm_gran[RIG_SETTING_MAX];      /*!< parm granularity */


      /* 
       * non overridable fields, internal use
       */

01397   int hold_decode;      /*!< set to 1 to hold the event decoder (async) otherwise 0 */
01398   vfo_t current_vfo;    /*!< VFO currently set */
01399   int vfo_list;         /*!< Complete list of VFO for this rig */
01400   int comm_state; /*!< Comm port state, opened/closed. */
01401   rig_ptr_t priv; /*!< Pointer to private rig state data. */
01402   rig_ptr_t obj;  /*!< Internal use by hamlib++ for event handling. */

01404   int transceive; /*!< Whether the transceive mode is on */
01405   int poll_interval;    /*!< Event notification polling period in milliseconds */
01406   freq_t current_freq;  /*!< Frequency currently set */
01407   rmode_t current_mode; /*!< Mode currently set */
01408   pbwidth_t current_width;    /*!< Passband width currently set */

};


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

/**
 * \brief Callback functions and args for rig event.
 *
 * Some rigs are able to notify the host computer the operator changed 
 * the freq/mode from the front panel, depressed a button, etc.
 *
 * Events from the rig are received through async io,
 * so callback functions will be called from the SIGIO sighandler context.
 *
 * Don't set these fields directly, use rig_set_freq_callback et. al. instead.
 *
 * Callbacks suit event based programming very well, 
 * really appropriate in a GUI.
 *
 * \sa rig_set_freq_callback, rig_set_mode_callback, rig_set_vfo_callback,
 *     rig_set_ptt_callback, rig_set_dcd_callback
 */
01439 struct rig_callbacks {
01440   freq_cb_t freq_event; /*!< Frequency change event */
01441   rig_ptr_t freq_arg;   /*!< Frequency change argument */
01442   mode_cb_t mode_event; /*!< Mode change event */
01443   rig_ptr_t mode_arg;   /*!< Mode change argument */
01444   vfo_cb_t vfo_event;   /*!< VFO change event */
01445   rig_ptr_t vfo_arg;    /*!< VFO change argument */
01446   ptt_cb_t ptt_event;   /*!< PTT change event */
01447   rig_ptr_t ptt_arg;    /*!< PTT change argument */
01448   dcd_cb_t dcd_event;   /*!< DCD change event */
01449   rig_ptr_t dcd_arg;    /*!< DCD change argument */
01450   pltune_cb_t pltune;   /*!< Pipeline tuning module freq/mode/width callback */
01451   rig_ptr_t pltune_arg; /*!< Pipeline tuning argument */
  /* etc.. */
};

/**
 * \brief The Rig structure
 *
 * This is the master data structure, acting as a handle for the controlled
 * rig. A pointer to this structure is returned by the rig_init() API
 * function and is passed as a parameter to every rig specific API call.
 *
 * \sa rig_init(), rig_caps, rig_state
 */
01464 struct rig {
01465   struct rig_caps *caps;            /*!< Pointer to rig capabilities (read only) */
01466   struct rig_state state;           /*!< Rig state */
01467   struct rig_callbacks callbacks;   /*!< registered event 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(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(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);


__END_DECLS

#endif /* _RIG_H */

/*! @} */

Generated by  Doxygen 1.6.0   Back to index