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

Classes | Files | Defines | Typedefs | Enumerations | Functions | Variables

Rig

Classes

struct  cal_table
 Calibration table struct. More...
struct  chan_list
 Memory channel list definition. More...
struct  channel
 Channel structure. More...
struct  channel_cap
 Channel capability definition. More...
struct  confparams
 Configuration parameter structure. More...
struct  ext_list
 Extension attribute definition. More...
struct  filter_list
 Filter definition. More...
struct  freq_range_list
 Frequency range. More...
struct  gran
 level/parm granularity definition More...
struct  hamlib_port_t
 Port definition. More...
struct  map_all_s
struct  opened_rig_l
struct  rig
 The Rig structure. More...
struct  rig_callbacks
 Callback functions and args for rig event. More...
struct  rig_caps
 Rig data structure. More...
struct  rig_state
 Rig state containing live data and customized fields. More...
struct  tuning_step_list
 Tuning step definition. More...
union  value_t
 Universal approach for passing values. More...

Files

file  conf.c
 

Rig configuration interface.


file  event.c
 

Event handling.


file  ext.c
 

Extension request parameter interface.


file  mem.c
 

Memory and channel interface.


file  rig.c
 

Ham Radio Control Libraries interface.


file  rig.h
 

Hamlib rig data structures.


file  settings.c
 

func/level/parm interface


file  tones.c
 

CTCSS and DCS interface and tables.


Defines

#define __BEGIN_DECLS
#define __END_DECLS
#define CHANLSTSIZ   16
#define CHECK_RIG_ARG(r)   (!(r) || !(r)->caps || !(r)->state.comm_state)
#define CHECK_RIG_ARG(r)   (!(r) || !(r)->caps || !(r)->state.comm_state)
#define CHECK_RIG_ARG(r)   (!(r) || !(r)->caps || !(r)->state.comm_state)
#define CHECK_RIG_ARG(r)   (!(r) || !(r)->caps || !(r)->state.comm_state)
#define CHECK_RIG_ARG(r)   (!(r) || !(r)->caps || !(r)->state.comm_state)
#define DEFAULT_PARALLEL_PORT   "/dev/parport0"
#define DEFAULT_SERIAL_PORT   "/dev/ttyS0"
#define EMPTY_STR_CAL   { 0, { { 0, 0 }, } }
#define ERROR_TBL_SZ   (sizeof(rigerror_table)/sizeof(char *))
#define FILPATHLEN   100
#define FLTLSTSIZ   42
#define FREQFMT   SCNfreq
#define FRQRANGESIZ   30
#define GHz(f)   ((freq_t)((f)*(freq_t)1000000000))
#define HAMLIB_PARAMS(protos)   ()
#define Hz(f)   ((freq_t)(f))
#define kHz(f)   ((freq_t)((f)*(freq_t)1000))
#define kW(p)   ((int)((p)*1000000L))
#define MAX_CAL_LENGTH   32
#define MAXCHANDESC   30
#define MAXDBLSTSIZ   8
#define MHz(f)   ((freq_t)((f)*(freq_t)1000000))
#define mW(p)   ((int)(p))
#define NETRIGCTL_RET   "RPRT "
 Token in the netrigctl protocol for returning error code.
#define PRIfreq   "f"
 printf(3) format to be used for freq_t type
#define RIG_ANT_1   RIG_ANT_N(0)
#define RIG_ANT_2   RIG_ANT_N(1)
#define RIG_ANT_3   RIG_ANT_N(2)
#define RIG_ANT_4   RIG_ANT_N(3)
#define RIG_ANT_5   RIG_ANT_N(4)
#define RIG_ANT_N(n)   ((ant_t)1<<(n))
#define RIG_ANT_NONE   0
#define RIG_CHAN_END   {0,0,RIG_MTYPE_NONE}
#define RIG_CHFLAG_DATA   (1<<1)
 DATA port mode flag.
#define RIG_CHFLAG_NONE   0
 Empty channel_t.flags field.
#define RIG_CHFLAG_SKIP   (1<<0)
 skip memory channel during scan (lock out), channel_t.flags
#define RIG_COMBO_MAX   8
#define RIG_CONF_END   0
#define RIG_DBLST_END   0
#define RIG_EXT_END   {0, {.i=0}}
#define RIG_FLAG_TRANSCEIVER   (RIG_FLAG_RECEIVER|RIG_FLAG_TRANSMITTER)
#define RIG_FLT_ANY   0
#define RIG_FLT_END   {RIG_MODE_NONE,0}
#define RIG_FREQ_NONE   Hz(0)
#define RIG_FRNG_END   {Hz(0),Hz(0),RIG_MODE_NONE,0,0,RIG_VFO_NONE}
#define rig_get_split(r, v, s)   ({ vfo_t _tx_vfo; rig_get_split_vfo((r),(v),(s),&_tx_vfo); })
#define rig_get_strength(r, v, s)   rig_get_level((r),(v),RIG_LEVEL_STRENGTH, (value_t*)(s))
#define rig_idx2setting(i)   (1UL<<(i))
#define RIG_IS_CHAN_END(c)   ((c).type == RIG_MTYPE_NONE)
#define RIG_IS_DBLST_END(d)   ((d)==0)
#define RIG_IS_EXT_END(x)   ((x).token == 0)
#define RIG_IS_FLT_END(f)   ((f).modes == RIG_MODE_NONE)
#define RIG_IS_FRNG_END(r)   ((r).start == Hz(0) && (r).end == Hz(0))
#define RIG_IS_TS_END(t)   ((t).modes == RIG_MODE_NONE && (t).ts == 0)
#define RIG_ITU_REGION1   1
#define RIG_ITU_REGION2   2
#define RIG_ITU_REGION3   3
#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_IS_FLOAT(l)   ((l)&RIG_LEVEL_FLOAT_LIST)
#define RIG_LEVEL_READONLY_LIST   (RIG_LEVEL_SQLSTAT|RIG_LEVEL_SWR|RIG_LEVEL_ALC|RIG_LEVEL_STRENGTH|RIG_LEVEL_RAWSTR)
#define RIG_LEVEL_SET(l)   ((l)&~RIG_LEVEL_READONLY_LIST)
#define RIG_MEM_CAPS_ALL   -1
 Special memory channel value to tell rig_lookup_mem_caps() to retrieve all the ranges.
#define RIG_MODE_ECSS   (RIG_MODE_ECSSUSB|RIG_MODE_ECSSLSB)
 macro for backends, not to be used by rig_set_mode et al.
#define RIG_MODE_SSB   (RIG_MODE_USB|RIG_MODE_LSB)
 macro for backends, not to be used by rig_set_mode et al.
#define RIG_PARM_FLOAT_LIST   (RIG_PARM_BACKLIGHT|RIG_PARM_BAT)
#define RIG_PARM_IS_FLOAT(l)   ((l)&RIG_PARM_FLOAT_LIST)
#define RIG_PARM_READONLY_LIST   (RIG_PARM_BAT)
#define RIG_PARM_SET(l)   ((l)&~RIG_PARM_READONLY_LIST)
#define RIG_PASSBAND_NORMAL   s_Hz(0)
#define rig_ptr_t   char*
#define rig_set_debug_level(level)   rig_set_debug(level)
#define rig_set_split(r, v, s)   rig_set_split_vfo((r),(v),(s),RIG_VFO_CURR)
#define RIG_SETTING_MAX   32
#define RIG_STATUS_NEW   RIG_STATUS_UNTESTED
 Map all deprecated RIG_STATUS_NEW references to RIG_STATUS_UNTESTED for backward compatibility.
#define RIG_TARGETABLE_ALL   0x7fffffff
#define RIG_TARGETABLE_FREQ   (1<<0)
#define RIG_TARGETABLE_FUNC   (1<<4)
#define RIG_TARGETABLE_MODE   (1<<1)
#define RIG_TARGETABLE_NONE   0
#define RIG_TARGETABLE_PURE   (1<<2)
#define RIG_TARGETABLE_TONE   (1<<3)
#define RIG_TRN_OFF   0
#define RIG_TRN_POLL   2
#define RIG_TRN_RIG   1
#define RIG_TS_ANY   0
#define RIG_TS_END   {RIG_MODE_NONE,0}
#define RIG_TYPE_COMPUTER   (RIG_FLAG_TRANSCEIVER|RIG_FLAG_COMPUTER)
#define RIG_TYPE_HANDHELD   (RIG_FLAG_TRANSCEIVER|RIG_FLAG_HANDHELD)
#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_MOBILE   (RIG_FLAG_TRANSCEIVER|RIG_FLAG_MOBILE)
#define RIG_TYPE_OTHER   0
#define RIG_TYPE_PCRECEIVER   (RIG_FLAG_COMPUTER|RIG_FLAG_RECEIVER)
#define RIG_TYPE_RECEIVER   RIG_FLAG_RECEIVER
#define RIG_TYPE_SCANNER   (RIG_FLAG_SCANNER|RIG_FLAG_RECEIVER)
#define RIG_TYPE_TRANSCEIVER   RIG_FLAG_TRANSCEIVER
#define RIG_TYPE_TRUNKSCANNER   (RIG_TYPE_SCANNER|RIG_FLAG_TRUNKING)
#define RIG_TYPE_TUNER   RIG_FLAG_TUNER
#define RIG_VFO_A   RIG_VFO_N(0)
 VFOA -- VFO A
#define RIG_VFO_B   RIG_VFO_N(1)
 VFOB -- VFO B
#define RIG_VFO_C   RIG_VFO_N(2)
 VFOC -- VFO C
#define RIG_VFO_CURR   (1<<29)
 currVFO -- current "tunable channel"/VFO
#define RIG_VFO_MAIN   (1<<26)
 Main -- alias for MAIN
#define RIG_VFO_MEM   (1<<28)
 MEM -- means Memory mode, to be used with set_vfo
#define RIG_VFO_N(n)   (1<<(n))
#define RIG_VFO_NONE   0
 '' -- used in caps
#define RIG_VFO_RX   RIG_VFO_CURR
 RX -- alias for split rx or downlink
#define RIG_VFO_SUB   (1<<25)
 Sub -- alias for SUB
#define RIG_VFO_TX   RIG_VFO_TX_VFO(RIG_VFO_CURR)
 TX -- alias for split tx or uplink, of VFO_CURR
#define RIG_VFO_TX_FLAG   (1<<30)
#define RIG_VFO_TX_VFO(v)   ((v)|RIG_VFO_TX_FLAG)
#define RIG_VFO_VFO   (1<<27)
 VFO -- means (last or any)VFO mode, with set_vfo
#define RIGNAMSIZ   30
#define RIGVERSIZ   8
#define s_GHz(f)   ((shortfreq_t)((f)*(shortfreq_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 SCNfreq   "lf"
 scanf(3) format to be used for freq_t type
#define TSLSTSIZ   20
#define W(p)   Watts(p)
#define Watts(p)   ((int)((p)*1000))

Typedefs

typedef int ant_t
 Antenna number.
typedef struct cal_table cal_table_t
 calibration table type
typedef int(* chan_cb_t )(RIG *, channel_t **, int, const chan_t *, rig_ptr_t)
typedef struct chan_list chan_t
 chan_t type
typedef struct channel_cap channel_cap_t
 Channel cap.
typedef struct channel channel_t
 Channel structure typedef.
typedef int(* confval_cb_t )(RIG *, const struct confparams *, value_t *, rig_ptr_t)
typedef int(* dcd_cb_t )(RIG *, vfo_t, dcd_t, rig_ptr_t)
typedef enum dcd_e dcd_t
 DCD status.
typedef int(* freq_cb_t )(RIG *, vfo_t, freq_t, rig_ptr_t)
typedef struct freq_range_list freq_range_t
 Frequency range.
typedef double freq_t
 Frequency type, Frequency type unit in Hz, able to hold SHF frequencies.
typedef struct gran gran_t
 gran_t type
typedef int(* mode_cb_t )(RIG *, vfo_t, rmode_t, pbwidth_t, rig_ptr_t)
typedef shortfreq_t pbwidth_t
 Passband width, in Hz.
typedef int(* pltune_cb_t )(RIG *, vfo_t, freq_t *, rmode_t *, pbwidth_t *, rig_ptr_t)
typedef hamlib_port_t port_t
typedef int(* ptt_cb_t )(RIG *, vfo_t, ptt_t, rig_ptr_t)
typedef struct rig RIG
 Rig structure definition (see rig for details).
typedef enum rig_port_e rig_port_t
 Port type.
typedef int(* rig_probe_func_t )(const hamlib_port_t *, rig_model_t, rig_ptr_t)
typedef unsigned long setting_t
 Setting.
typedef signed long shortfreq_t
 Short frequency type Frequency in Hz restricted to 31bits, suitable for offsets, shifts, etc..
typedef long token_t
 configuration token
typedef unsigned int tone_t
 CTCSS and DCS type definition.
typedef int(* vfo_cb_t )(RIG *, vfo_t, rig_ptr_t)
typedef int vfo_t
 VFO definition.
typedef int(* vprintf_cb_t )(enum rig_debug_level_e, rig_ptr_t, const char *, va_list)

Enumerations

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
}
 

AGC delay settings.

More...
enum  ann_t {
  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)
}
 

Announce.

More...
enum  chan_type_t {
  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
}
 

Memory channel type definition.

More...
enum  dcd_e { RIG_DCD_OFF = 0, RIG_DCD_ON }
 

DCD status.

More...
enum  dcd_type_t {
  RIG_DCD_NONE = 0, RIG_DCD_RIG, RIG_DCD_SERIAL_DSR, RIG_DCD_SERIAL_CTS,
  RIG_DCD_SERIAL_CAR, RIG_DCD_PARALLEL
}
 

DCD type.

More...
enum  meter_level_e {
  RIG_METER_NONE = 0, RIG_METER_SWR = (1<<0), RIG_METER_COMP = (1<<1), RIG_METER_ALC = (1<<2),
  RIG_METER_IC = (1<<3), RIG_METER_DB = (1<<4), RIG_METER_PO = (1<<5), RIG_METER_VDD = (1<<6)
}
 

Level display meters.


enum  powerstat_t { RIG_POWER_OFF = 0, RIG_POWER_ON = (1<<0), RIG_POWER_STANDBY = (1<<1) }
 

Radio power state.

More...
enum  ptt_t { RIG_PTT_OFF = 0, RIG_PTT_ON, RIG_PTT_ON_MIC, RIG_PTT_ON_DATA }
 

PTT status.

More...
enum  ptt_type_t {
  RIG_PTT_NONE = 0, RIG_PTT_RIG, RIG_PTT_SERIAL_DTR, RIG_PTT_SERIAL_RTS,
  RIG_PTT_PARALLEL, RIG_PTT_RIG_MICDATA
}
 

PTT type.

More...
enum  reset_t {
  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 operation.

More...
enum  rig_conf_e {
  RIG_CONF_STRING, RIG_CONF_COMBO, RIG_CONF_NUMERIC, RIG_CONF_CHECKBUTTON,
  RIG_CONF_BUTTON
}
 

parameter types

More...
enum  rig_debug_level_e {
  RIG_DEBUG_NONE = 0, RIG_DEBUG_BUG, RIG_DEBUG_ERR, RIG_DEBUG_WARN,
  RIG_DEBUG_VERBOSE, RIG_DEBUG_TRACE
}
 

Hamlib debug levels.

More...
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
}
 

Hamlib error codes Error code definition that can be returned by the Hamlib functions. Unless stated otherwise, Hamlib functions return the negative value of rig_errcode_e definitions in case of error, or 0 when successful.

More...
enum  rig_func_e {
  RIG_FUNC_NONE = 0, RIG_FUNC_FAGC = (1<<0), RIG_FUNC_NB = (1<<1), RIG_FUNC_COMP = (1<<2),
  RIG_FUNC_VOX = (1<<3), RIG_FUNC_TONE = (1<<4), RIG_FUNC_TSQL = (1<<5), RIG_FUNC_SBKIN = (1<<6),
  RIG_FUNC_FBKIN = (1<<7), RIG_FUNC_ANF = (1<<8), RIG_FUNC_NR = (1<<9), RIG_FUNC_AIP = (1<<10),
  RIG_FUNC_APF = (1<<11), RIG_FUNC_MON = (1<<12), RIG_FUNC_MN = (1<<13), RIG_FUNC_RF = (1<<14),
  RIG_FUNC_ARO = (1<<15), RIG_FUNC_LOCK = (1<<16), RIG_FUNC_MUTE = (1<<17), RIG_FUNC_VSC = (1<<18),
  RIG_FUNC_REV = (1<<19), RIG_FUNC_SQL = (1<<20), RIG_FUNC_ABM = (1<<21), RIG_FUNC_BC = (1<<22),
  RIG_FUNC_MBC = (1<<23), RIG_FUNC_AFC = (1<<25), RIG_FUNC_SATMODE = (1<<26), RIG_FUNC_SCOPE = (1<<27),
  RIG_FUNC_RESUME = (1<<28), RIG_FUNC_TBURST = (1<<29), RIG_FUNC_TUNER = (1<<30)
}
 

Rig Function Settings.

More...
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 Settings.

More...
enum  rig_parm_e {
  RIG_PARM_NONE = 0, RIG_PARM_ANN = (1<<0), RIG_PARM_APO = (1<<1), RIG_PARM_BACKLIGHT = (1<<2),
  RIG_PARM_BEEP = (1<<4), RIG_PARM_TIME = (1<<5), RIG_PARM_BAT = (1<<6), RIG_PARM_KEYLIGHT = (1<<7)
}
 

Rig Parameters.

More...
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
}
 

Port type.

More...
enum  rig_status_e {
  RIG_STATUS_ALPHA = 0, RIG_STATUS_UNTESTED, RIG_STATUS_BETA, RIG_STATUS_STABLE,
  RIG_STATUS_BUGGY
}
 

Development status of the backend.

More...
enum  rig_type_t {
  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 flags.

More...
enum  rmode_t {
  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_TESTS_MAX
}
 

Radio mode.

More...
enum  rptr_shift_t { RIG_RPT_SHIFT_NONE = 0, RIG_RPT_SHIFT_MINUS, RIG_RPT_SHIFT_PLUS }
 

Repeater shift type.

More...
enum  scan_t {
  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)
}
 

Rig Scan operation.

More...
enum  serial_control_state_e { RIG_SIGNAL_UNSET = 0, RIG_SIGNAL_ON, RIG_SIGNAL_OFF }
 

Serial control state.

More...
enum  serial_handshake_e { RIG_HANDSHAKE_NONE = 0, RIG_HANDSHAKE_XONXOFF, RIG_HANDSHAKE_HARDWARE }
 

Serial handshake.

More...
enum  serial_parity_e {
  RIG_PARITY_NONE = 0, RIG_PARITY_ODD, RIG_PARITY_EVEN, RIG_PARITY_MARK,
  RIG_PARITY_SPACE
}
 

Serial parity.

More...
enum  split_t { RIG_SPLIT_OFF = 0, RIG_SPLIT_ON }
 

Split mode.

More...
enum  vfo_op_t {
  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 operation.

More...

Functions

static int add_opened_rig (RIG *rig)
int add_trn_rig (RIG *rig)
int foreach_opened_rig (int(*cfunc)(RIG *, rig_ptr_t), rig_ptr_t data)
 execs cfunc() on each opened rig
static int frontend_get_conf (RIG *rig, token_t token, char *val)
static int frontend_set_conf (RIG *rig, token_t token, const char *val)
static int generic_restore_channel (RIG *rig, const channel_t *chan)
static int generic_retr_extl (RIG *rig, const struct confparams *cfp, rig_ptr_t ptr)
static int generic_save_channel (RIG *rig, channel_t *chan)
int get_chan_all_cb_generic (RIG *rig, chan_cb_t chan_cb, rig_ptr_t arg)
int get_parm_all_cb_generic (RIG *rig, confval_cb_t parm_cb, rig_ptr_t cfgps, rig_ptr_t vals)
 HAMLIB_EXPORT (vfo_op_t) rig_has_vfo_op HAMLIB_PARAMS((RIG *rig
const char HAMLIB_EXPORT (vprintf_cb_t) rig_set_debug_callback HAMLIB_PARAMS((vprintf_cb_t cb
 HAMLIB_EXPORT (FILE *) rig_set_debug_file HAMLIB_PARAMS((FILE *stream))
 HAMLIB_EXPORT (RIG *) rig_init HAMLIB_PARAMS((rig_model_t rig_model))
 HAMLIB_EXPORT (scan_t) rig_has_scan HAMLIB_PARAMS((RIG *rig
 HAMLIB_EXPORT (rig_model_t) rig_probe HAMLIB_PARAMS((hamlib_port_t *p))
 HAMLIB_EXPORT (rmode_t) rig_parse_mode(const char *s)
 HAMLIB_EXPORT (shortfreq_t) rig_get_resolution HAMLIB_PARAMS((RIG *rig
const channel_t struct
confparams const value_t
*channel_t struct confparams
value_t
HAMLIB_EXPORT (const chan_t *) rig_lookup_mem_caps HAMLIB_PARAMS((RIG *rig
 HAMLIB_EXPORT (vfo_t) rig_parse_vfo(const char *s)
 HAMLIB_EXPORT (rptr_shift_t) rig_parse_rptr_shift(const char *s)
 HAMLIB_EXPORT (const struct confparams *) rig_ext_lookup HAMLIB_PARAMS((RIG *rig
 HAMLIB_EXPORT (chan_type_t) rig_parse_mtype(const char *s)
 HAMLIB_EXPORT (const char *) rig_get_info HAMLIB_PARAMS((RIG *rig))
 HAMLIB_EXPORT (token_t) rig_ext_token_lookup HAMLIB_PARAMS((RIG *rig
 HAMLIB_EXPORT (const struct rig_caps *) rig_get_caps HAMLIB_PARAMS((rig_model_t rig_model))
 HAMLIB_EXPORT (int) rig_open HAMLIB_PARAMS((RIG *rig))
 HAMLIB_EXPORT (const freq_range_t *) rig_get_range HAMLIB_PARAMS((const freq_range_t range_list[]
 HAMLIB_EXPORT (pbwidth_t) rig_passband_normal HAMLIB_PARAMS((RIG *rig
 HAMLIB_EXPORT (void) rig_set_debug HAMLIB_PARAMS((enum rig_debug_level_e debug_level))
 HAMLIB_EXPORT (setting_t) rig_has_get_level HAMLIB_PARAMS((RIG *rig
__BEGIN_DECLS HAMLIB_EXPORT_VAR (const char) hamlib_version[]
static int map_chan (RIG *rig, channel_t **chan, int channel_num, const chan_t *chan_list, rig_ptr_t arg)
static int map_parm (RIG *rig, const struct confparams *cfgps, value_t *value, rig_ptr_t arg)
static int remove_opened_rig (RIG *rig)
int remove_trn_rig (RIG *rig)
int HAMLIB_API rig_cleanup (RIG *rig)
 release a rig handle and free associated memory
int HAMLIB_API rig_close (RIG *rig)
 close the communication to the rig
struct confparams *HAMLIB_API rig_confparam_lookup (RIG *rig, const char *name)
 lookup a confparam struct
int HAMLIB_API rig_copy_channel (RIG *rig, channel_t *dest, const channel_t *src)
int HAMLIB_API rig_ext_level_foreach (RIG *rig, int(*cfunc)(RIG *, const struct confparams *, rig_ptr_t), rig_ptr_t data)
 Executes cfunc on all the elements stored in the extlevels table The callback cfunc is called until it returns a value which is not strictly positive. A zero value means a normal end of iteration, and a negative value an abnormal end, which will be the return value of rig_ext_level_foreach.
struct confparams *HAMLIB_API rig_ext_lookup (RIG *rig, const char *name)
 lookup ext token by its name, return pointer to confparams struct.
struct confparams *HAMLIB_API rig_ext_lookup_tok (RIG *rig, token_t token)
 lookup ext token, return pointer to confparams struct.
int HAMLIB_API rig_ext_parm_foreach (RIG *rig, int(*cfunc)(RIG *, const struct confparams *, rig_ptr_t), rig_ptr_t data)
 Executes cfunc on all the elements stored in the extparms table The callback cfunc is called until it returns a value which is not strictly positive. A zero value means a normal end of iteration, and a negative value an abnormal end, which will be the return value of rig_ext_parm_foreach.
token_t HAMLIB_API rig_ext_token_lookup (RIG *rig, const char *name)
 Simple lookup returning token id assicated with name.
int HAMLIB_API rig_get_ant (RIG *rig, vfo_t vfo, ant_t *ant)
 get the current antenna
int HAMLIB_API rig_get_chan_all (RIG *rig, channel_t chans[])
 get all channel data
int HAMLIB_API rig_get_chan_all_cb (RIG *rig, chan_cb_t chan_cb, rig_ptr_t arg)
 get all channel data, by callback
int HAMLIB_API rig_get_channel (RIG *rig, channel_t *chan)
 get channel data
int HAMLIB_API rig_get_conf (RIG *rig, token_t token, char *val)
 get the value of a configuration parameter
int HAMLIB_API rig_get_ctcss_sql (RIG *rig, vfo_t vfo, tone_t *tone)
 get the current CTCSS squelch
int HAMLIB_API rig_get_ctcss_tone (RIG *rig, vfo_t vfo, tone_t *tone)
 get the current CTCSS sub-tone frequency
int HAMLIB_API rig_get_dcd (RIG *rig, vfo_t vfo, dcd_t *dcd)
 get the status of the DCD
int HAMLIB_API rig_get_dcs_code (RIG *rig, vfo_t vfo, tone_t *code)
 get the current encoding DCS code
int HAMLIB_API rig_get_dcs_sql (RIG *rig, vfo_t vfo, tone_t *code)
 get the current DCS code
int HAMLIB_API rig_get_ext_level (RIG *rig, vfo_t vfo, token_t token, value_t *val)
 get the value of a level extra parameter
int HAMLIB_API rig_get_ext_parm (RIG *rig, token_t token, value_t *val)
 get the value of a parm extra parameter
int HAMLIB_API rig_get_freq (RIG *rig, vfo_t vfo, freq_t *freq)
 get the frequency of the target VFO
int HAMLIB_API rig_get_func (RIG *rig, vfo_t vfo, setting_t func, int *status)
 get the status of functions of the radio
const char *HAMLIB_API rig_get_info (RIG *rig)
 get general information from the radio
int HAMLIB_API rig_get_level (RIG *rig, vfo_t vfo, setting_t level, value_t *val)
 get the value of a level
int HAMLIB_API rig_get_mem (RIG *rig, vfo_t vfo, int *ch)
 get the current memory channel number
int HAMLIB_API rig_get_mem_all (RIG *rig, channel_t chans[], const struct confparams cfgps[], value_t vals[])
 get all channel and non-channel data
int HAMLIB_API rig_get_mem_all_cb (RIG *rig, chan_cb_t chan_cb, confval_cb_t parm_cb, rig_ptr_t arg)
 get all channel and non-channel data by call-back
int HAMLIB_API rig_get_mode (RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
 get the mode of the target VFO
int HAMLIB_API rig_get_parm (RIG *rig, setting_t parm, value_t *val)
 get the value of a parameter
int HAMLIB_API rig_get_powerstat (RIG *rig, powerstat_t *status)
 get the on/off status of the radio
int HAMLIB_API rig_get_ptt (RIG *rig, vfo_t vfo, ptt_t *ptt)
 get the status of the PTT
const freq_range_t *HAMLIB_API rig_get_range (const freq_range_t range_list[], freq_t freq, rmode_t mode)
 find the freq_range of freq/mode
shortfreq_t HAMLIB_API rig_get_resolution (RIG *rig, rmode_t mode)
 get the best frequency resolution of the rig
int HAMLIB_API rig_get_rit (RIG *rig, vfo_t vfo, shortfreq_t *rit)
 get the current RIT offset
int HAMLIB_API rig_get_rptr_offs (RIG *rig, vfo_t vfo, shortfreq_t *rptr_offs)
 get the current repeater offset
int HAMLIB_API rig_get_rptr_shift (RIG *rig, vfo_t vfo, rptr_shift_t *rptr_shift)
 get the current repeater shift
int HAMLIB_API rig_get_split_freq (RIG *rig, vfo_t vfo, freq_t *tx_freq)
 get the current split frequencies
int HAMLIB_API rig_get_split_mode (RIG *rig, vfo_t vfo, rmode_t *tx_mode, pbwidth_t *tx_width)
 get the current split modes
int HAMLIB_API rig_get_split_vfo (RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vfo)
 get the current split mode
int HAMLIB_API rig_get_trn (RIG *rig, int *trn)
 get the current transceive mode
int HAMLIB_API rig_get_ts (RIG *rig, vfo_t vfo, shortfreq_t *ts)
 get the current Tuning Step
int HAMLIB_API rig_get_vfo (RIG *rig, vfo_t *vfo)
 get the current VFO
int HAMLIB_API rig_get_xit (RIG *rig, vfo_t vfo, shortfreq_t *xit)
 get the current XIT offset
setting_t HAMLIB_API rig_has_get_func (RIG *rig, setting_t func)
 check ability of radio functions
setting_t HAMLIB_API rig_has_get_level (RIG *rig, setting_t level)
 check retrieval ability of level settings
setting_t HAMLIB_API rig_has_get_parm (RIG *rig, setting_t parm)
 check retrieval ability of parameter settings
scan_t HAMLIB_API rig_has_scan (RIG *rig, scan_t scan)
 check availability of scanning functions
setting_t HAMLIB_API rig_has_set_func (RIG *rig, setting_t func)
 check ability of radio functions
setting_t HAMLIB_API rig_has_set_level (RIG *rig, setting_t level)
 check settable ability of level settings
setting_t HAMLIB_API rig_has_set_parm (RIG *rig, setting_t parm)
 check settable ability of parameter settings
vfo_op_t HAMLIB_API rig_has_vfo_op (RIG *rig, vfo_op_t op)
 check retrieval ability of VFO operations
RIG *HAMLIB_API rig_init (rig_model_t rig_model)
 allocate a new RIG handle
const chan_t *HAMLIB_API rig_lookup_mem_caps (RIG *rig, int ch)
 lookup the memory type and capabilities
static int rig_mem_caps_empty (const channel_cap_t *mem_cap)
int HAMLIB_API rig_mem_count (RIG *rig)
 get memory channel count
int HAMLIB_API rig_mW2power (RIG *rig, float *power, unsigned int mwpower, freq_t freq, rmode_t mode)
 conversion utility from absolute in mW to relative range
int HAMLIB_API rig_open (RIG *rig)
 open the communication to the rig
pbwidth_t HAMLIB_API rig_passband_narrow (RIG *rig, rmode_t mode)
 get the narrow passband of a mode
pbwidth_t HAMLIB_API rig_passband_normal (RIG *rig, rmode_t mode)
 get the normal passband of a mode
pbwidth_t HAMLIB_API rig_passband_wide (RIG *rig, rmode_t mode)
 get the wide passband of a mode
int HAMLIB_API rig_power2mW (RIG *rig, unsigned int *mwpower, float power, freq_t freq, rmode_t mode)
 conversion utility from relative range to absolute in mW
rig_model_t HAMLIB_API rig_probe (hamlib_port_t *port)
 try to guess a rig
int HAMLIB_API rig_probe_all (hamlib_port_t *port, rig_probe_func_t cfunc, rig_ptr_t data)
 try to guess rigs
int rig_probe_all_backends (hamlib_port_t *p, rig_probe_func_t cfunc, rig_ptr_t data)
int rig_probe_first (hamlib_port_t *p)
int HAMLIB_API rig_recv_dtmf (RIG *rig, vfo_t vfo, char *digits, int *length)
 receive DTMF digits
int HAMLIB_API rig_reset (RIG *rig, reset_t reset)
 reset the radio
int HAMLIB_API rig_scan (RIG *rig, vfo_t vfo, scan_t scan, int ch)
 perform Memory/VFO operations
int HAMLIB_API rig_send_dtmf (RIG *rig, vfo_t vfo, const char *digits)
 send DTMF digits
int HAMLIB_API rig_send_morse (RIG *rig, vfo_t vfo, const char *msg)
 send morse code
int HAMLIB_API rig_set_ant (RIG *rig, vfo_t vfo, ant_t ant)
 set the antenna
int HAMLIB_API rig_set_bank (RIG *rig, vfo_t vfo, int bank)
 set the current memory bank
int HAMLIB_API rig_set_chan_all (RIG *rig, const channel_t chans[])
 set all channel data
int HAMLIB_API rig_set_chan_all_cb (RIG *rig, chan_cb_t chan_cb, rig_ptr_t arg)
 set all channel data, by callback
int HAMLIB_API rig_set_channel (RIG *rig, const channel_t *chan)
 set channel data
int HAMLIB_API rig_set_conf (RIG *rig, token_t token, const char *val)
 set a radio configuration parameter
int HAMLIB_API rig_set_ctcss_sql (RIG *rig, vfo_t vfo, tone_t tone)
 set CTCSS squelch
int HAMLIB_API rig_set_ctcss_tone (RIG *rig, vfo_t vfo, tone_t tone)
 set CTCSS sub-tone frequency
int HAMLIB_API rig_set_dcd_callback (RIG *rig, dcd_cb_t cb, rig_ptr_t arg)
 set the callback for dcd events
int HAMLIB_API rig_set_dcs_code (RIG *rig, vfo_t vfo, tone_t code)
 set the current encoding DCS code
int HAMLIB_API rig_set_dcs_sql (RIG *rig, vfo_t vfo, tone_t code)
 set the current DCS code
int HAMLIB_API rig_set_ext_level (RIG *rig, vfo_t vfo, token_t token, value_t val)
 set a radio level extra parameter
int HAMLIB_API rig_set_ext_parm (RIG *rig, token_t token, value_t val)
 set a radio parm extra parameter
int HAMLIB_API rig_set_freq (RIG *rig, vfo_t vfo, freq_t freq)
 set the frequency of the target VFO
int HAMLIB_API rig_set_freq_callback (RIG *rig, freq_cb_t cb, rig_ptr_t arg)
 set the callback for freq events
int HAMLIB_API rig_set_func (RIG *rig, vfo_t vfo, setting_t func, int status)
 activate/de-activate functions of radio
int HAMLIB_API rig_set_level (RIG *rig, vfo_t vfo, setting_t level, value_t val)
 set a radio level setting
int HAMLIB_API rig_set_mem (RIG *rig, vfo_t vfo, int ch)
 set the current memory channel number
int HAMLIB_API rig_set_mem_all (RIG *rig, const channel_t chans[], const struct confparams cfgps[], const value_t vals[])
 set all channel and non-channel data
int HAMLIB_API rig_set_mem_all_cb (RIG *rig, chan_cb_t chan_cb, confval_cb_t parm_cb, rig_ptr_t arg)
 set all channel and non-channel data by call-back
int HAMLIB_API rig_set_mode (RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width)
 set the mode of the target VFO
int HAMLIB_API rig_set_mode_callback (RIG *rig, mode_cb_t cb, rig_ptr_t arg)
 set the callback for mode events
int HAMLIB_API rig_set_parm (RIG *rig, setting_t parm, value_t val)
 set a radio parameter
int HAMLIB_API rig_set_pltune_callback (RIG *rig, pltune_cb_t cb, rig_ptr_t arg)
 set the callback for pipelined tuning module
int HAMLIB_API rig_set_powerstat (RIG *rig, powerstat_t status)
 turn on/off the radio
int HAMLIB_API rig_set_ptt (RIG *rig, vfo_t vfo, ptt_t ptt)
 set PTT on/off
int HAMLIB_API rig_set_ptt_callback (RIG *rig, ptt_cb_t cb, rig_ptr_t arg)
 set the callback for ptt events
int HAMLIB_API rig_set_rit (RIG *rig, vfo_t vfo, shortfreq_t rit)
 set the RIT
int HAMLIB_API rig_set_rptr_offs (RIG *rig, vfo_t vfo, shortfreq_t rptr_offs)
 set the repeater offset
int HAMLIB_API rig_set_rptr_shift (RIG *rig, vfo_t vfo, rptr_shift_t rptr_shift)
 set the repeater shift
int HAMLIB_API rig_set_split_freq (RIG *rig, vfo_t vfo, freq_t tx_freq)
 set the split frequencies
int HAMLIB_API rig_set_split_mode (RIG *rig, vfo_t vfo, rmode_t tx_mode, pbwidth_t tx_width)
 set the split modes
int HAMLIB_API rig_set_split_vfo (RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo)
 set the split mode
int HAMLIB_API rig_set_trn (RIG *rig, int trn)
 control the transceive mode
int HAMLIB_API rig_set_ts (RIG *rig, vfo_t vfo, shortfreq_t ts)
 set the Tuning Step
int HAMLIB_API rig_set_vfo (RIG *rig, vfo_t vfo)
 set the current VFO
int HAMLIB_API rig_set_vfo_callback (RIG *rig, vfo_cb_t cb, rig_ptr_t arg)
 set the callback for vfo events
int HAMLIB_API rig_set_xit (RIG *rig, vfo_t vfo, shortfreq_t xit)
 set the XIT
int HAMLIB_API rig_setting2idx (setting_t s)
 basically convert setting_t expressed 2^n to n
int HAMLIB_API rig_token_foreach (RIG *rig, int(*cfunc)(const struct confparams *, rig_ptr_t), rig_ptr_t data)
 call a function against each configuration token of a rig
token_t HAMLIB_API rig_token_lookup (RIG *rig, const char *name)
 lookup a token id
int HAMLIB_API rig_vfo_op (RIG *rig, vfo_t vfo, vfo_op_t op)
 perform Memory/VFO operations
const char *HAMLIB_API rigerror (int errnum)
 get string describing the error code
int set_chan_all_cb_generic (RIG *rig, chan_cb_t chan_cb, rig_ptr_t arg)
int set_parm_all_cb_generic (RIG *rig, confval_cb_t parm_cb, rig_ptr_t cfgps, rig_ptr_t vals)

Variables

vfo_t ant_t ant
const char rig_ptr_t arg
vfo_t int bank
int(* cfunc )(RIG *, const struct confparams *, rig_ptr_t)
vfo_t int ch
const channel_tchan
chan_cb_t chan_cb
const channel_t chans []
vfo_t tone_t code
const tone_t common_ctcss_list [] = { COMMON_CTCSS_LIST }
const tone_t common_dcs_list [] = { COMMON_DCS_LIST }
int(*) rig_ptr_ data )
vfo_t dcd_tdcd
vfo_t const char * digits
const char * fmt
vfo_t freq_t freq
static struct confparams frontend_cfg_params []
static struct confparams frontend_serial_cfg_params []
const tone_t full_ctcss_list [] = { FULL_CTCSS_LIST }
const tone_t full_dcs_list [] = { FULL_DCS_LIST }
setting_t func
const char hamlib_copyright [231] = "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
 Hamlib copyright notice.
const char hamlib_version [21] = "Hamlib " PACKAGE_VERSION
 Hamlib release number The version number has the format x.y.z.
vfo_t char int * length
vfo_t setting_t level
static const channel_cap_t mem_cap_all
vfo_t rmode_t mode
vfo_t const char * msg
unsigned int * mwpower
const char * name
vfo_t vfo_op_t op
static struct opened_rig_lopened_rig_list = { NULL }
setting_t parm
chan_cb_t confval_cb_t parm_cb
unsigned int float power
vfo_t ptt_t ptt
reset_t reset
chan_cb_t rig_ptr_t
static const char * rigerror_table []
vfo_t shortfreq_t rit
vfo_t shortfreq_t rptr_offs
vfo_t rptr_shift_t rptr_shift
vfo_t rx_vfo
vfo_t scan_t scan
vfo_t split_t split
powerstat_t status
token_t token
vfo_t tone_t tone
int trn
vfo_t shortfreq_t ts
vfo_t freq_t tx_freq
vfo_t rmode_t tx_mode
vfo_t split_t vfo_t tx_vfo
vfo_t rmode_t pbwidth_t tx_width
vfo_t setting_t value_t val
vfo_t vfo
vfo_t rmode_t pbwidth_t width
vfo_t shortfreq_t xit

Generated by  Doxygen 1.6.0   Back to index