mirror
/
Hamlib
kopia lustrzana https://github.com/Hamlib/Hamlib
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność
Hamlib/kylix/hamlib_rigapi.pas

1367 wiersze
55 KiB
Plaintext
Czysty Wina Historia

unit hamlib_rigapi;
{ Please note: This here is still some macro's missing. FGR 2002-01-12 }
interface
Uses
Libc;
{$MINENUMSIZE 4}
{* The $MINENUMSIZE directive controls the
* minimum storage size of enumerated types. *}
{$UNDEF HAVE_MAGIC_NUMBERS}
{$IFDEF HAVE_MAGIC_NUMBERS}
const
RIG_MAGIC = $1234BABE;
RIG_MAGIC_CAPS = $11223344;
RIG_MAGIC_STATE = $11111112;
RIG_MAGIC_CALLBACKS = $999A8889;
{$ENDIF}
const
{*
* Error codes that can be returned by the Hamlib functions
*}
RIG_OK = 0; {* completed sucessfully *}
RIG_EINVAL = 1; {* invalid parameter *}
RIG_ECONF = 2; {* invalid configuration (serial,..) *}
RIG_ENOMEM = 3; {* memory shortage *}
RIG_ENIMPL = 4; {* function not implemented, but will be *}
RIG_ETIMEOUT = 5; {* communication timed out *}
RIG_EIO = 6; {* IO error, including open failed *}
RIG_EINTERNAL = 7; {* Internal Hamlib error, huh! *}
RIG_EPROTO = 8; {* Protocol error *}
RIG_ERJCTED = 9; {* Command rejected by the rig *}
RIG_ETRUNC = 10; {* Command performed, but arg truncated *}
RIG_ENAVAIL = 11; {* function not available *}
RIG_ENTARGET = 12; {* VFO not targetable *}
type
rig_model_t = integer;
rig_ptr_t = pointer;
float = single;
tone_t = cardinal;
{* Forward struct references *}
//struct rig;
//struct rig_state; // how do i do this in pascal?
//typedef struct rig RIG;
const
RIGNAMSIZ = 30;
RIGVERSIZ = 8;
FILPATHLEN = 100;
FRQRANGESIZ = 30;
MAXCHANDESC = 30; {* describe channel eg: "WWV 5Mhz" *}
TSLSTSIZ = 20; {* max tuning step list size, zero ended *}
FLTLSTSIZ = 16; {* max mode/filter list size, zero ended *}
MAXDBLSTSIZ = 8; {* max preamp/att levels supported, zero ended *}
CHANLSTSIZ = 16; {* max mem_list size, zero ended *}
type
{*
* REM: Numeric order matters for debug level
*}
rig_debug_level_e = (
RIG_DEBUG_NONE = 0,
RIG_DEBUG_BUG, {* Should these values not correspond with syslog? *}
RIG_DEBUG_ERR,
RIG_DEBUG_WARN,
RIG_DEBUG_VERBOSE,
RIG_DEBUG_TRACE
);
{*
* Rig capabilities
*
* 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 enquiries about capablilities.
*}
rig_port_e = (
RIG_PORT_NONE = 0, {* as bizarre as it could be :) *}
RIG_PORT_SERIAL,
RIG_PORT_NETWORK,
RIG_PORT_DEVICE, {* Device driver, like the WiNRADiO *}
RIG_PORT_PACKET, {* e.g. SV8CS *}
RIG_PORT_DTMF, {* bridge via another rig, eg. Kenwood Sky Cmd System *}
RIG_PORT_ULTRA, {* IrDA Ultra protocol! *}
RIG_PORT_RPC {* RPC wrapper *}
);
serial_parity_e = (
RIG_PARITY_NONE = 0,
RIG_PARITY_ODD,
RIG_PARITY_EVEN
);
serial_handshake_e = (
RIG_HANDSHAKE_NONE = 0,
RIG_HANDSHAKE_XONXOFF,
RIG_HANDSHAKE_HARDWARE
);
const
RIG_FLAG_RECEIVER = 1 shl 1;
RIG_FLAG_TRANSMITTER = 1 shl 2;
RIG_FLAG_SCANNER = 1 shl 3;
RIG_FLAG_MOBILE = 1 shl 4;
RIG_FLAG_HANDHELD = 1 shl 5;
RIG_FLAG_COMPUTER = 1 shl 6;
RIG_FLAG_TRUNKING = 1 shl 7;
RIG_FLAG_APRS = 1 shl 8;
RIG_FLAG_TNC = 1 shl 9;
RIG_FLAG_DXCLUSTER = 1 shl 10;
RIG_FLAG_TRANSCEIVER = (RIG_FLAG_RECEIVER or RIG_FLAG_TRANSMITTER);
RIG_TYPE_MASK = (RIG_FLAG_TRANSCEIVER or RIG_FLAG_SCANNER or
RIG_FLAG_MOBILE or RIG_FLAG_HANDHELD or
RIG_FLAG_COMPUTER or RIG_FLAG_TRUNKING);
RIG_TYPE_OTHER = 0;
RIG_TYPE_TRANSCEIVER = (RIG_FLAG_TRANSCEIVER);
RIG_TYPE_HANDHELD = (RIG_FLAG_TRANSCEIVER or RIG_FLAG_HANDHELD);
RIG_TYPE_MOBILE = (RIG_FLAG_TRANSCEIVER or RIG_FLAG_MOBILE);
RIG_TYPE_RECEIVER = (RIG_FLAG_RECEIVER);
RIG_TYPE_PCRECEIVER = (RIG_FLAG_COMPUTER or RIG_FLAG_RECEIVER);
RIG_TYPE_SCANNER = (RIG_FLAG_SCANNER or RIG_FLAG_RECEIVER);
RIG_TYPE_TRUNKSCANNER = (RIG_TYPE_SCANNER or RIG_FLAG_TRUNKING);
RIG_TYPE_COMPUTER = (RIG_FLAG_TRANSCEIVER or RIG_FLAG_COMPUTER);
type
{*
* Development status of the backend
*}
rig_status_e = (
RIG_STATUS_ALPHA = 0,
RIG_STATUS_UNTESTED, {* written from specs, rig unavailable for test, feedback most wanted! *}
RIG_STATUS_BETA,
RIG_STATUS_STABLE,
RIG_STATUS_BUGGY, {* was stable, but something broke it! *}
RIG_STATUS_NEW
);
rptr_shift_e = (
RIG_RPT_SHIFT_NONE = 0,
RIG_RPT_SHIFT_MINUS,
RIG_RPT_SHIFT_PLUS
);
rptr_shift_t = rptr_shift_e;
split_e = (
RIG_SPLIT_OFF = 0,
RIG_SPLIT_ON
);
split_t = split_e;
{*
* freq_t: frequency type in Hz, must be >32bits for SHF!
* shortfreq_t: frequency on 31bits, suitable for offsets, shifts, etc..
*}
freq_t = int64;
shortfreq_t = longint;
{ TODO: convert macros to functions }
//#define Hz(f) ((freq_t)(f))
//#define kHz(f) ((freq_t)((f)*1000))
//#define MHz(f) ((freq_t)((f)*1000000L))
//#define GHz(f) ((freq_t)((f)*1000000000LL))
//#define RIG_FREQ_NONE Hz(0)
const
RIG_FREQ_NONE = 0;
RIG_VFO_CURR = 0; {* current "tunable channel"/VFO *}
RIG_VFO_NONE = 0; {* used in caps *}
RIG_VFO_ALL = -1; {* apply to all VFO (when used as target) *}
{*
* Or should it be better designated
* as a "tunable channel" (RIG_CTRL_MEM) ? --SF
*}
RIG_VFO_MEM = -2; {* means Memory mode, to be used with set_vfo *}
RIG_VFO_VFO = -3; {* means (any)VFO mode, with set_vfo *}
RIG_VFO1 = (1 shl 0);
RIG_VFO2 = (1 shl 1);
RIG_CTRL_MAIN = 1;
RIG_CTRL_SUB = 2;
{*
* one byte per "tunable channel":
*
* MSB LSB
* 8 1
* +-+-+-+-+-+-+-+-+
* | | |
* CTL VFO
*}
function RIG_CTRL_BAND(band,vfo: integer): integer; // macro
function RIG_VFO_A: integer; // macro
function RIG_VFO_B: integer; // macro
function RIG_VFO_C: integer; // macro
function RIG_VFO_MAIN: integer; // macro
function RIG_VFO_SUB: integer; // macro
type
{*
* could RIG_VFO_ALL be useful?
* i.e. apply to all VFO, when used as target
*}
vfo_t = integer;
const
RIG_TARGETABLE_NONE = $00;
RIG_TARGETABLE_FREQ = $01;
RIG_TARGETABLE_MODE = $02;
RIG_TARGETABLE_ALL = $ffffffff;
//const
// RIG_PASSBAND_NORMAL = 0;
type
{*
* also see rig_passband_normal(rig,mode),
* rig_passband_narrow(rig,mode) and rig_passband_wide(rig,mode)
*}
pbwidth_t = shortfreq_t;
dcd_e = (
RIG_DCD_OFF = 0,
RIG_DCD_ON);
dcd_t = dcd_e;
dcd_type_e = (
RIG_DCD_NONE = 0, {* not available *}
RIG_DCD_RIG, {* i.e. has get_dcd cap *}
RIG_DCD_SERIAL_DSR,
RIG_DCD_SERIAL_CTS,
RIG_DCD_PARALLEL {* DCD comes from ?? DATA1? STROBE? *}
{$ifdef TODO_MORE_DCD}
RIG_DCD_PTT {* follow ptt_type, i.e. ptt=RTS -> dcd=CTS on same line --SF *}
{$endif}
);
dcd_type_t = dcd_type_e;
ptt_e = (
RIG_PTT_OFF = 0,
RIG_PTT_ON);
ptt_t = ptt_e;
ptt_type_e = (
RIG_PTT_NONE = 0, {* not available *}
RIG_PTT_RIG, {* legacy PTT *}
RIG_PTT_SERIAL_DTR,
RIG_PTT_SERIAL_RTS,
RIG_PTT_PARALLEL); {* PTT accessed through DATA0 *}
ptt_type_t = ptt_type_e;
powerstat_e = (
RIG_POWER_OFF = 0,
RIG_POWER_ON,
RIG_POWER_STANDBY
);
powerstat_t = powerstat_e;
reset_e = (
RIG_RESET_NONE = 0,
RIG_RESET_SOFT,
RIG_RESET_VFO,
RIG_RESET_MCALL, (* memory clear *)
RIG_RESET_MASTER
);
reset_t = reset_e;
const
{* VFO/MEM mode are set by set_vfo *}
RIG_OP_NONE = 0;
RIG_OP_CPY = (1 shl 0); {* VFO A = VFO B *}
RIG_OP_XCHG = (1 shl 1); {* Exchange VFO A/B *}
RIG_OP_FROM_VFO = (1 shl 2); {* VFO->MEM *}
RIG_OP_TO_VFO = (1 shl 3); {* MEM->VFO *}
RIG_OP_MCL = (1 shl 4); {* Memory clear *}
RIG_OP_UP = (1 shl 5); {* UP *}
RIG_OP_DOWN = (1 shl 6); {* DOWN *}
RIG_OP_BAND_UP = (1 shl 7); {* Band UP *}
RIG_OP_BAND_DOWN = (1 shl 8); {* Band DOWN *}
type
{*
* RIG_MVOP_DUAL_ON/RIG_MVOP_DUAL_OFF (Dual watch off/Dual watch on)
* better be set by set_func IMHO,
* or is it the balance (-> set_level) ? --SF
*}
vfo_op_t = longint;
const
RIG_SCAN_NONE = 0L;
RIG_SCAN_STOP = RIG_SCAN_NONE;
RIG_SCAN_MEM = (1 shl 0); {* Scan all memory channels *}
RIG_SCAN_SLCT = (1 shl 1); {* Scan all selected memory channels *}
RIG_SCAN_PRIO = (1 shl 2); {* Priority watch (mem or call channel) *}
RIG_SCAN_PROG = (1 shl 3); {* Programmed(edge) scan *}
RIG_SCAN_DELTA = (1 shl 4); {* delta-f scan *}
type
scan_t = longint;
{*
* configuration token
*}
token_t = longint;
const
RIG_CONF_END = 0;
//#define RIG_TOKEN_BACKEND(t) (t)
//#define RIG_TOKEN_FRONTEND(t) ((t)|(1<<30))
//#define RIG_IS_TOKEN_FRONTEND(t) ((t)&(1<<30))
{*
* strongly inspired from soundmedem. Thanks Thomas!
*}
RIG_CONF_STRING = 0;
RIG_CONF_COMBO = 1;
RIG_CONF_NUMERIC = 2;
RIG_CONF_CHECKBUTTON = 3;
RIG_COMBO_MAX = 8;
type
confparams = packed record
token : token_t;
name : PChar; {* try to avoid spaces in the name *}
labelcf : PChar; // renamed to avoid clash with pascal reserved word
tooltip : PChar;
dflt : PChar;
typecf : longword; // renamed to avoid clash with pascal reserved word
u : record
case integer of
0: (n: record
min: float;
max: float;
step: float;
end; );
1: (c: record
combostr : array[0..RIG_COMBO_MAX-1] of PChar;
end; );
end;
end;
TConfParms = confparams;
PConfParms = ^TConfParms;
const
{*
* When optional speech synthesizer is installed
* what about RIG_ANN_ENG and RIG_ANN_JAPAN? and RIG_ANN_CW?
*}
RIG_ANN_NONE = 0;
RIG_ANN_OFF = RIG_ANN_NONE;
RIG_ANN_FREQ = (1 shl 0);
RIG_ANN_RXMODE = (1 shl 1);
RIG_ANN_ALL = (1 shl 2);
type
ann_t = longint;
{* Antenna number *}
ant_t = integer;
agc_level_e = (
RIG_AGC_OFF = 0,
RIG_AGC_SUPERFAST,
RIG_AGC_FAST,
RIG_AGC_SLOW
);
meter_level_e = (
RIG_METER_NONE = 0,
RIG_METER_SWR,
RIG_METER_COMP,
RIG_METER_ALC,
RIG_METER_IC,
RIG_METER_DB
);
{*
* Universal approach for use by set_level/get_level
*}
value_u = packed record
case integer of
0: (i : integer);
1: (f : float);
end;
value_t = value_u;
const
RIG_LEVEL_NONE = 0ULL;
RIG_LEVEL_PREAMP = (1 shl 0); {* Preamp, arg int (dB) *}
RIG_LEVEL_ATT = (1 shl 1); {* Attenuator, arg int (dB) *}
RIG_LEVEL_VOX = (1 shl 2); {* VOX delay, arg int (tenth of seconds) *}
RIG_LEVEL_AF = (1 shl 3); {* Volume, arg float [0.0..1.0] *}
RIG_LEVEL_RF = (1 shl 4); {* RF gain (not TX power), arg float [0.0..1.0] or in dB ?? -20..20 ? *}
RIG_LEVEL_SQL = (1 shl 5); {* Squelch, arg float [0.0 .. 1.0] *}
RIG_LEVEL_IF = (1 shl 6); {* IF, arg int (Hz) *}
RIG_LEVEL_APF = (1 shl 7); {* APF, arg float [0.0 .. 1.0] *}
RIG_LEVEL_NR = (1 shl 8); {* Noise Reduction, arg float [0.0 .. 1.0] *}
RIG_LEVEL_PBT_IN = (1 shl 9); {* Twin PBT (inside), arg float [0.0 .. 1.0] *}
RIG_LEVEL_PBT_OUT = (1 shl 10); {* Twin PBT (outside), arg float [0.0 .. 1.0] *}
RIG_LEVEL_CWPITCH = (1 shl 11); {* CW pitch, arg int (Hz) *}
RIG_LEVEL_RFPOWER = (1 shl 12); {* RF Power, arg float [0.0 .. 1.0] *}
RIG_LEVEL_MICGAIN = (1 shl 13); {* MIC Gain, arg float [0.0 .. 1.0] *}
RIG_LEVEL_KEYSPD = (1 shl 14); {* Key Speed, arg int (WPM) *}
RIG_LEVEL_NOTCHF = (1 shl 15); {* Notch Freq., arg int (Hz) *}
RIG_LEVEL_COMP = (1 shl 16); {* Compressor, arg float [0.0 .. 1.0] *}
RIG_LEVEL_AGC = (1 shl 17); {* AGC, arg int (see enum agc_level_e) *}
RIG_LEVEL_BKINDL = (1 shl 18); {* BKin Delay, arg int (tenth of dots) *}
RIG_LEVEL_BALANCE = (1 shl 19); {* Balance (Dual Watch), arg float [0.0 .. 1.0] *}
RIG_LEVEL_METER = (1 shl 20); {* Display meter, arg int (see enum meter_level_e) *}
{* These ones are not settable *}
RIG_LEVEL_SQLSTAT = (1 shl 27); {* SQL status, arg int (open=1/closed=0). Deprecated, use get_dcd instead *}
RIG_LEVEL_SWR = (1 shl 28); {* SWR, arg float *}
RIG_LEVEL_ALC = (1 shl 29); {* ALC, arg float *}
RIG_LEVEL_STRENGTH= (1 shl 30); {* Signal strength, arg int (dB) *}
RIG_LEVEL_FLOAT_LIST = (RIG_LEVEL_AF or RIG_LEVEL_RF or
RIG_LEVEL_SQL or RIG_LEVEL_APF or
RIG_LEVEL_NR or RIG_LEVEL_PBT_IN or
RIG_LEVEL_PBT_OUT or RIG_LEVEL_RFPOWER or
RIG_LEVEL_MICGAIN or RIG_LEVEL_COMP or
RIG_LEVEL_BALANCE or RIG_LEVEL_SWR or
RIG_LEVEL_ALC);
RIG_LEVEL_READONLY_LIST = (RIG_LEVEL_SQLSTAT or RIG_LEVEL_SWR or
RIG_LEVEL_ALC or RIG_LEVEL_STRENGTH);
// RIG_LEVEL_IS_FLOAT(l) ((l)&RIG_LEVEL_FLOAT_LIST) // macro
// RIG_LEVEL_SET(l) ((l)&~RIG_LEVEL_READONLY_LIST) // macro
{*
* Parameters are settings that are not VFO specific
*}
RIG_PARM_NONE = 0;
RIG_PARM_ANN = (1 shl 0); {* "Announce" level, see ann_t *}
RIG_PARM_APO = (1 shl 1); {* Auto power off, int in minute *}
RIG_PARM_BACKLIGHT = (1 shl 2); {* LCD light, float [0.0..1.0] *}
RIG_PARM_BEEP = (1 shl 4); {* Beep on keypressed, int (0,1) *}
RIG_PARM_TIME = (1 shl 5); {* hh:mm:ss, int in seconds from 00:00:00 *}
RIG_PARM_BAT = (1 shl 6); {* battery level, float [0.0..1.0] *}
RIG_PARM_FLOAT_LIST = (RIG_PARM_BACKLIGHT or RIG_PARM_BAT);
RIG_PARM_READONLY_LIST = (RIG_PARM_BAT);
// RIG_PARM_IS_FLOAT(l) ((l)&RIG_PARM_FLOAT_LIST) // macro
// RIG_PARM_SET(l) ((l)&~RIG_PARM_READONLY_LIST) // macro
RIG_SETTING_MAX = 64;
type
setting_t = int64; {* hope 64 bits will be enough.. *}
const
{*
* tranceive mode, ie. the rig notify the host of any event,
* like freq changed, mode changed, etc.
*}
RIG_TRN_OFF = 0;
RIG_TRN_RIG = 1;
RIG_TRN_POLL = 2;
{*
* These are activated functions.
*}
RIG_FUNC_NONE = 0;
RIG_FUNC_FAGC = (1 shl 0); {* Fast AGC *}
RIG_FUNC_NB = (1 shl 1); {* Noise Blanker *}
RIG_FUNC_COMP = (1 shl 2); {* Compression *}
RIG_FUNC_VOX = (1 shl 3); {* VOX *}
RIG_FUNC_TONE = (1 shl 4); {* Tone *}
RIG_FUNC_TSQL = (1 shl 5); {* may require a tone field *}
RIG_FUNC_SBKIN = (1 shl 6); {* Semi Break-in *}
RIG_FUNC_FBKIN = (1 shl 7); {* Full Break-in, for CW mode *}
RIG_FUNC_ANF = (1 shl 8); {* Automatic Notch Filter (DSP); *}
RIG_FUNC_NR = (1 shl 9); {* Noise Reduction (DSP); *}
RIG_FUNC_AIP = (1 shl 10); {* AIP (Kenwood); *}
RIG_FUNC_APF = (1 shl 11); {* Auto Passband Filter *}
RIG_FUNC_MON = (1 shl 12); {* Monitor transmitted signal, != rev *}
RIG_FUNC_MN = (1 shl 13); {* Manual Notch (Icom); *}
RIG_FUNC_RNF = (1 shl 14); {* RTTY Filter Notch (Icom); *}
RIG_FUNC_ARO = (1 shl 15); {* Auto Repeater Offset *}
RIG_FUNC_LOCK = (1 shl 16); {* Lock *}
RIG_FUNC_MUTE = (1 shl 17); {* Mute, could be emulated by LEVEL_AF*}
RIG_FUNC_VSC = (1 shl 18); {* Voice Scan Control *}
RIG_FUNC_REV = (1 shl 19); {* Reverse tx and rx freqs *}
RIG_FUNC_SQL = (1 shl 20); {* Turn Squelch Monitor on/off*}
RIG_FUNC_ABM = (1 shl 21); {* Auto Band Mode *}
RIG_FUNC_BC = (1 shl 22); {* Beat Canceller *}
RIG_FUNC_MBC = (1 shl 23); {* Manual Beat Canceller *}
RIG_FUNC_LMP = (1 shl 24); {* LCD lamp ON/OFF *}
{*
* power unit macros, converts to mW
* This is limited to 2MW on 32 bits systems.
*}
//#define mW(p) ((int)(p)) // macro
//#define Watts(p) ((int)((p)*1000)) // macro
//#define W(p) Watts(p) // macro
//#define kW(p) ((int)((p)*1000000L)) // macro
type
rmode_t = cardinal; {* radio mode *}
const
{*
* Do not use an enum since this will be used w/ rig_mode_t bit fields.
* Also, how should CW reverse sideband and RTTY reverse
* sideband be handled?
*}
RIG_MODE_NONE = 0;
RIG_MODE_AM = (1 shl 0);
RIG_MODE_CW = (1 shl 1);
RIG_MODE_USB = (1 shl 2); {* select somewhere else the filters ? *}
RIG_MODE_LSB = (1 shl 3);
RIG_MODE_RTTY = (1 shl 4);
RIG_MODE_FM = (1 shl 5);
RIG_MODE_WFM = (1 shl 6); {* after all, Wide FM is a mode on its own *}
{* macro for backends, no to be used by rig_set_mode et al. *}
RIG_MODE_SSB = (RIG_MODE_USB or RIG_MODE_LSB);
//#define RIG_DBLST_END 0 {* end marker in a preamp/att level list *}
//#define RIG_IS_DBLST_END(d) ((d)==0) // macro
type
{*
* Put together a bunch of this struct in an array to define
* what your rig have access to
*}
freq_range_list = packed record
start: freq_t;
endfq: freq_t; // Renamed to avoid clash with pascal reserved name
modes: rmode_t; {* bitwise OR'ed RIG_MODE_* *}
low_power : integer; {* in mW, -1 for no power (ie. rx list) *}
high_power: integer; {* in mW, -1 for no power (ie. rx list) *}
vfo : vfo_t; {* VFOs that can access this range *}
ant : ant_t;
end;
freq_range_t = freq_range_list;
//#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))
const
RIG_ITU_REGION1 = 1;
RIG_ITU_REGION2 = 2;
RIG_ITU_REGION3 = 3;
type
{*
* Lists the tuning steps available for each mode
*}
tuning_step_list = packed record
modes : rmode_t; {* bitwise OR'ed RIG_MODE_* *}
ts : shortfreq_t; {* tuning step in Hz *}
end;
//#define RIG_TS_END {RIG_MODE_NONE,0}
//#define RIG_IS_TS_END(t) ((t).modes == RIG_MODE_NONE && (t).ts == 0) // macro
{*
* 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 this mode (cf rig_set_mode).
*}
filter_list = packed record
modes : rmode_t; {* bitwise OR'ed RIG_MODE_* *}
width : pbwidth_t; {* passband width in Hz *}
end;
//#define RIG_FLT_END {RIG_MODE_NONE,0}
//#define RIG_IS_FLT_END(f) ((f).modes == RIG_MODE_NONE)
{*
* Convenience struct, describes a freq/vfo/mode combo
* Also useful for memory handling -- FS
*
* TODO: skip flag, split, shift, etc.
*}
channel = packed record
channel_num : integer;
freq : freq_t;
mode : rmode_t;
width : pbwidth_t;
tx_freq : freq_t;
tx_mode : rmode_t;
tx_width : pbwidth_t;
split : split_t;
rptr_shift : rptr_shift_t;
rptr_offs : shortfreq_t;
vfo : vfo_t;
ant : integer; {* antenna number *}
tuning_step : shortfreq_t;
rit : shortfreq_t;
xit : shortfreq_t;
funcs : setting_t;
levels : array[0..RIG_SETTING_MAX-1] of value_t;
ctcss_tone : tone_t;
ctcss_sql : tone_t;
dcs_code : tone_t;
dcs_sql : tone_t;
channel_desc : array[0..MAXCHANDESC-1] of char;
end;
channel_t = channel;
(*
* chan_t is used to describe what memory your rig is equipped with
* cf. chan_list field in caps
* Example for the Ic706MkIIG (99 memory channels, 2 scan edges, 2 call chans):
* chan_t chan_list[] = {
* { 1, 99, RIG_MTYPE_MEM, 0 },
* { 100, 103, RIG_MTYPE_EDGE, 0 },
* { 104, 105, RIG_MTYPE_CALL, 0 },
* RIG_CHAN_END
* }
*)
chan_type_e = (
RIG_MTYPE_NONE=0,
RIG_MTYPE_MEM, {* regular *}
RIG_MTYPE_EDGE, {* scan edge *}
RIG_MTYPE_CALL, {* call channel *}
RIG_MTYPE_MEMOPAD, {* inaccessible on Icom, what about others? *}
RIG_MTYPE_SAT {* satellite *}
);
chan_list = packed record
start : integer; {* rig memory channel _number_ *}
endch : integer; // Note: two members renamed due to name conflict with pascal reserved word.
typech : chan_type_e; {* among EDGE, MEM, CALL, .. *}
reserved : integer; {* don't know yet, maybe something like flags *}
end;
chan_t = chan_list;
//#define RIG_CHAN_END {0,0,RIG_MTYPE_NONE,0}
//#define RIG_IS_CHAN_END(c) ((c).type == RIG_MTYPE_NONE)
{* 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 enquiries about capablilities.
*}
{*
* 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.
*}
type
PRig = ^TRig; // forward declaration
rig_caps = packed record
rig_model : rig_model_t;
model_name : PChar;
mfg_name : PChar;
version : PChar;
copyright : PChar;
status : rig_status_e;
rig_type : integer;
ptt_type : ptt_type_e;
dcd_type : dcd_type_e;
port_type : rig_port_e;
serial_rate_min : integer;
serial_rate_max : integer;
serial_data_bits : integer;
serial_stop_bits : integer;
serial_parity : serial_parity_e;
serial_handshake : serial_handshake_e;
write_delay : integer;
post_write_delay : integer;
timeout : integer;
retry : integer;
has_get_func : setting_t;
has_set_func : setting_t;
has_get_level : setting_t;
has_set_level : setting_t;
has_get_parm : setting_t;
has_set_parm : setting_t;
level_gran : array[0..RIG_SETTING_MAX-1] of integer;
parm_gran : array[0..RIG_SETTING_MAX-1] of integer;
ctcss_list : ^tone_t; // ?? How do I make it a const ?
dcs_list : ^tone_t;
preamp : array[0..MAXDBLSTSIZ-1] of integer;
attenuator : array[0..MAXDBLSTSIZ-1] of integer;
max_rit : shortfreq_t;
max_xit : shortfreq_t;
max_ifshift : shortfreq_t;
announces : ann_t;
vfo_ops : vfo_op_t;
scan_ops : scan_t;
targetable_vfo : integer;
transceive : integer;
bank_qty : integer;
chan_desc_sz : integer;
chan_list : array[0..CHANLSTSIZ-1] of chan_t;
rx_range_list1 : array[0..FRQRANGESIZ-1] of freq_range_t; {* ITU region 1 *}
tx_range_list1 : array[0..FRQRANGESIZ-1] of freq_range_t;
rx_range_list2 : array[0..FRQRANGESIZ-1] of freq_range_t; {* ITU region 2 *}
tx_range_list2 : array[0..FRQRANGESIZ-1] of freq_range_t;
tuning_steps : array[0..TSLSTSIZ-1] of tuning_step_list;
filters : array[0..FLTLSTSIZ-1] of filter_list; {* mode/filter table, at -6dB *}
cfgparams : PConfparms;
priv : rig_ptr_t;
{*
* Rig Admin API
*
*}
rig_init : function(rig: PRig): integer; cdecl;
rig_open : function(rig: PRig): integer; cdecl;
rig_close : function(rig: PRig): integer; cdecl;
rig_cleanup : function(rig: PRig): integer; cdecl;
{*
* General API commands, from most primitive to least.. :()
* List Set/Get functions pairs
*}
set_freq : function(rig: PRig; vfo: vfo_t; freq: freq_t): integer; cdecl;
get_freq : function(rig: PRig; vfo: vfo_t; var freq: freq_t): integer; cdecl;
set_mode : function(rig: PRig; vfo: vfo_t; mode: rmode_t; width: pbwidth_t): integer; cdecl;
get_mode : function(rig: PRig; vfo: vfo_t; var mode: rmode_t; var width: pbwidth_t): integer; cdecl;
set_vfo : function(rig: PRig; vfo: vfo_t): integer; cdecl;
get_vfo : function(rig: PRig; var vfo: vfo_t): integer; cdecl;
set_ptt : function(rig: PRig; vfo: vfo_t; ptt: ptt_t): integer; cdecl;
get_ptt : function(rig: PRig; vfo: vfo_t; var ptt: ptt_t): integer; cdecl;
get_dcd : function(rig: PRig; vfo: vfo_t; var dcd: dcd_t): integer; cdecl;
set_rptr_shift : function(rig: PRig; vfo: vfo_t; rptr_shift: rptr_shift_t): integer; cdecl;
get_rptr_shift : function(rig: PRig; vfo: vfo_t; var rptr_shift: rptr_shift_t): integer; cdecl;
set_rptr_offs : function(rig: PRig; vfo: vfo_t; offs: shortfreq_t): integer; cdecl;
get_rptr_offs : function(rig: PRig; vfo: vfo_t; var offs: shortfreq_t): integer; cdecl;
set_split_freq : function(rig: PRig; vfo: vfo_t; tx_freq: freq_t): integer; cdecl;
get_split_freq : function(rig: PRig; vfo: vfo_t; var tx_freqs: freq_t): integer; cdecl;
set_split_mode : function(rig: PRig; vfo: vfo_t; tx_mode: rmode_t; tx_width : pbwidth_t): integer; cdecl;
get_split_mode : function(rig: PRig; vfo: vfo_t; var tx_mode: rmode_t; var tx_width : pbwidth_t): integer; cdecl;
set_split : function(rig: PRig; vfo: vfo_t; split : split_t): integer; cdecl;
get_split : function(rig: PRig; vfo: vfo_t; var split: split_t): integer; cdecl;
set_rit : function(rig: PRig; vfo: vfo_t; rit : shortfreq_t): integer; cdecl;
get_rit : function(rig: PRig; vfo: vfo_t; var rit: shortfreq_t): integer; cdecl;
set_xit : function(rig: PRig; vfo: vfo_t; xit : shortfreq_t): integer; cdecl;
get_xit : function(rig: PRig; vfo: vfo_t; var xit: shortfreq_t): integer; cdecl;
set_ts : function(rig: PRig; vfo: vfo_t; ts : shortfreq_t): integer; cdecl;
get_ts : function(rig: PRig; vfo: vfo_t; var ts: shortfreq_t): integer; cdecl;
set_ctcss_tone : function(rig: PRig; vfo: vfo_t; tone : tone_t): integer; cdecl;
get_ctcss_tone : function(rig: PRig; vfo: vfo_t; var tone: tone_t): integer; cdecl;
set_dcs_code : function(rig: PRig; vfo: vfo_t; code : tone_t): integer; cdecl;
get_dcs_code : function(rig: PRig; vfo: vfo_t; var code: tone_t): integer; cdecl;
set_dcs_sql : function(rig: PRig; vfo: vfo_t; code : tone_t): integer; cdecl;
get_dcs_sql : function(rig: PRig; vfo: vfo_t; var code: tone_t): integer; cdecl;
set_ctcss_sql : function(rig: PRig; vfo: vfo_t; tone : tone_t): integer; cdecl;
get_ctcss_sql : function(rig: PRig; vfo: vfo_t; var tone: tone_t): integer; cdecl;
{*
* It'd be nice to have a power2mW and mW2power functions
* that could tell at what power (watts) the rig is running.
* Unfortunately, on most rigs, the formula is not the same
* on all bands/modes. Have to work this out.. --SF
*}
power2mW : function(rig: PRig; var mwpower: cardinal; power : float; freq : freq_t; mode: rmode_t): integer; cdecl;
mW2power : function(rig: PRig; var power : float; mwpower: cardinal; freq : freq_t; mode: rmode_t): integer; cdecl;
set_powerstat : function(rig: PRig; status : powerstat_t): integer; cdecl;
get_powerstat : function(rig: PRig; var status : powerstat_t): integer; cdecl;
reset : function(rig: PRig; reset : reset_t): integer; cdecl;
set_ant : function(rig: PRig; vfo: vfo_t; ant : ant_t): integer; cdecl;
get_ant : function(rig: PRig; vfo: vfo_t; var ant : ant_t): integer; cdecl;
set_level : function(rig: PRig; vfo: vfo_t; level : setting_t; val : value_t): integer; cdecl;
get_level : function(rig: PRig; vfo: vfo_t; level : setting_t; var val : value_t): integer; cdecl;
set_func : function(rig: PRig; vfo: vfo_t; func : setting_t; status : integer): integer; cdecl;
get_func : function(rig: PRig; vfo: vfo_t; func : setting_t; var status : integer): integer; cdecl;
set_parm : function(rig: PRig; parm : setting_t; val : value_t): integer; cdecl;
get_parm : function(rig: PRig; parm : setting_t; var val : value_t): integer; cdecl;
set_conf : function(rig: PRig; token : token_t; val : PChar): integer; cdecl;
get_conf : function(rig: PRig; token : token_t; val : PChar): integer; cdecl;
send_dtmf : function(rig: PRig; vfo: vfo_t; digits : PChar): integer; cdecl;
recv_dtmf : function(rig: PRig; vfo: vfo_t; digits : PChar; var length : integer): integer; cdecl;
send_morse : function(rig: PRig; vfo: vfo_t; msg : PChar): integer; cdecl;
set_bank : function(rig: PRig; vfo: vfo_t; bank : integer): integer; cdecl;
set_mem : function(rig: PRig; vfo: vfo_t; ch : integer): integer; cdecl;
get_mem : function(rig: PRig; vfo: vfo_t; var ch : integer): integer; cdecl;
vfo_op : function(rig: PRig; vfo: vfo_t; op : vfo_op_t): integer; cdecl;
scan : function(rig: PRig; vfo: vfo_t; scan: scan_t; ch : integer): integer; cdecl;
set_trn : function(rig: PRig; trn: integer): integer; cdecl;
get_trn : function(rig: PRig; var trn: integer): integer; cdecl;
decode_event : function(rig: PRig): integer; cdecl;
{*
* Convenience Functions
*}
set_channel : function(rig: PRig; const chan: channel_t): integer; cdecl;
get_channel : function(rig: PRig; var chan: channel_t): integer; cdecl;
{* get firmware info, etc. *}
get_info : function(rig: PRig): PChar; cdecl;
{$IFDEF HAVE_MAGIC_NUMBERS}
magic: cardinal;
{$ENDIF}
end;
TRigCaps = rig_caps;
PRigCaps = ^TRigCaps;
port_t = packed record
ptype : record
case integer of
0: ( rig: rig_port_e; );
1: ( ptt: ptt_type_e; );
2: ( dcd: dcd_type_e; );
end;
fd : integer;
stream: pointer;
{$ifdef WINDOWS}
handle: HANDLE;
{$endif}
write_delay: integer;
post_write_delay: integer;
post_write_date: timeval;
timeout: integer;
retry: integer;
pathname: array[0..FILPATHLEN-1] of char;
parm : record
case integer of
0: ( serial : record
rate: integer;
data_bits: integer;
stop_bits: integer;
parity: serial_parity_e;
handshake: serial_parity_e;
end; );
1: ( parallel: record
pin: integer;
end; );
2: ( device: record
{ place holder }
end; );
{$ifdef NET}
3: ( network: record
saddr: struct_socketaddr; // look in libc.pas for correct.
end; );
{$endif}
end;
end;
TPort = port_t;
PPort = ^TPort;
{*
* Rig state
*
* 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.
*}
TRigState = packed record
{*
* overridable fields
*}
rigport : port_t;
pttport : port_t;
dcdport : port_t;
vfo_comp : double;
itu_region : integer;
rx_range_list : array [0..FRQRANGESIZ-1] of freq_range_t;
tx_range_list : array[0..FRQRANGESIZ-1] of freq_range_t;
tuning_steps : array[0..TSLSTSIZ-1] of tuning_step_list;
filters : array[0..FLTLSTSIZ-1] of filter_list;
chan_list : array[0..CHANLSTSIZ-1] of chan_t;
max_rit : shortfreq_t;
max_xit : shortfreq_t;
max_ifshift : shortfreq_t;
announces : ann_t;
preamp : array[0..MAXDBLSTSIZ-1] of integer;
attenuator : array[0..MAXDBLSTSIZ-1] of integer;
has_get_func : setting_t;
has_set_func : setting_t;
has_get_level : setting_t;
has_set_level : setting_t;
has_get_parm : setting_t;
has_set_parm : setting_t;
level_gran : array[0..RIG_SETTING_MAX-1] of integer;
{*
* non overridable fields, internal use
*}
hold_decode : integer;
current_vfo : vfo_t;
transceive : integer;
vfo_list : integer;
comm_state : integer;
{*
* Pointer to private data
*}
priv : pointer;
{*
* internal use by hamlib++ & Kylix for event handling
*}
obj : pointer; // Pointer to the Hamlib Component of this rig.
{$IFDEF HAVE_MAGIC_NUMBERS}
magic : cardinal;
{$ENDIF}
end;
TRigCallbacks = packed record
freq_event: function(rig: PRig; vfo: vfo_t; freq: freq_t): integer; cdecl;
mode_event: function(rig: PRig; vfo: vfo_t; mode: rmode_t; width: pbwidth_t): integer; cdecl;
vfo_event : function(rig: PRig; vfo: vfo_t): integer; cdecl;
ptt_event : function(rig: PRig; mode: ptt_t): integer; cdecl;
dcd_event : function(rig: PRig; mode: dcd_t): integer; cdecl;
{$IFDEF HAVE_MAGIC_NUMBERS}
magic : cardinal;
{$ENDIF}
end;
rig = packed record
caps: PRigCaps;
state: TRigState;
callbacks: TRigCallbacks;
{$IFDEF HAVE_MAGIC_NUMBERS}
magic: cardinal;
{$ENDIF}
end;
TRig = rig;
//PRig = ^TRig // declared previously
{* --------------- API function prototypes -----------------*}
function rig_init (rig_model : rig_model_t): PRig; cdecl;
function rig_open (rig: PRig): integer; cdecl;
function rig_close (rig: PRig): integer; cdecl;
function rig_cleanup (rig: PRig): integer; cdecl;
function rig_probe (p: PPort): rig_model_t; cdecl;
{*
* General API commands, from most primitive to least.. :()
* List Set/Get functions pairs
*}
function rig_set_freq (rig: PRig; vfo: vfo_t; freq: freq_t): integer; cdecl;
function rig_get_freq (rig: PRig; vfo: vfo_t; var freq: freq_t): integer; cdecl;
function rig_set_mode (rig: PRig; vfo: vfo_t; mode: rmode_t; width: pbwidth_t): integer; cdecl;
function rig_get_mode (rig: PRig; vfo: vfo_t; var mode: rmode_t; var width: pbwidth_t): integer; cdecl;
function rig_set_vfo (rig: PRig; vfo: vfo_t): integer; cdecl;
function rig_get_vfo (rig: PRig; var vfo: vfo_t): integer; cdecl;
function rig_set_ptt (rig: PRig; vfo: vfo_t; ptt: ptt_t): integer; cdecl;
function rig_get_ptt (rig: PRig; vfo: vfo_t; var ptt: ptt_t): integer; cdecl;
function rig_get_dcd (rig: PRig; vfo: vfo_t; var dcd: dcd_t): integer; cdecl;
function rig_set_rptr_shift (rig: PRig; vfo: vfo_t; rptr_shift: rptr_shift_t): integer; cdecl;
function rig_get_rptr_shift (rig: PRig; vfo: vfo_t; var rptr_shift: rptr_shift_t): integer; cdecl;
function rig_set_rptr_offs (rig: PRig; vfo: vfo_t; offs: shortfreq_t): integer; cdecl;
function rig_get_rptr_offs (rig: PRig; vfo: vfo_t; var offs: shortfreq_t): integer; cdecl;
function rig_set_ctcss_tode (rig: PRig; vfo: vfo_t; tone : tone_t): integer; cdecl;
function rig_get_ctcss_tode (rig: PRig; vfo: vfo_t; var tone: tone_t): integer; cdecl;
function rig_set_dcs_code (rig: PRig; vfo: vfo_t; code : tone_t): integer; cdecl;
function rig_get_dcs_code (rig: PRig; vfo: vfo_t; var code: tone_t): integer; cdecl;
function rig_set_ctcss_sql (rig: PRig; vfo: vfo_t; tone : tone_t): integer; cdecl;
function rig_get_ctcss_sql (rig: PRig; vfo: vfo_t; var tone: tone_t): integer; cdecl;
function rig_set_dcs_sql (rig: PRig; vfo: vfo_t; code : tone_t): integer; cdecl;
function rig_get_dcs_sql (rig: PRig; vfo: vfo_t; var code: tone_t): integer; cdecl;
function rig_set_split_freq (rig: PRig; vfo: vfo_t; tx_freq: freq_t): integer; cdecl;
function rig_get_split_freq (rig: PRig; vfo: vfo_t; var tx_freqs: freq_t): integer; cdecl;
function rig_set_split_mode (rig: PRig; vfo: vfo_t; tx_mode: rmode_t; tx_width : pbwidth_t): integer; cdecl;
function rig_get_split_mode (rig: PRig; vfo: vfo_t; var tx_mode: rmode_t; var tx_width : pbwidth_t): integer; cdecl;
function rig_set_split (rig: PRig; vfo: vfo_t; split : split_t): integer; cdecl;
function rig_get_split (rig: PRig; vfo: vfo_t; var split: split_t): integer; cdecl;
function rig_set_rit (rig: PRig; vfo: vfo_t; rit : shortfreq_t): integer; cdecl;
function rig_get_rit (rig: PRig; vfo: vfo_t; var rit: shortfreq_t): integer; cdecl;
function rig_set_xit (rig: PRig; vfo: vfo_t; xit : shortfreq_t): integer; cdecl;
function rig_get_xit (rig: PRig; vfo: vfo_t; var xit: shortfreq_t): integer; cdecl;
function rig_set_ts (rig: PRig; vfo: vfo_t; ts : shortfreq_t): integer; cdecl;
function rig_get_ts (rig: PRig; vfo: vfo_t; var ts: shortfreq_t): integer; cdecl;
function rig_power2mW (rig: PRig; var mwpower: cardinal; power : float; freq : freq_t; mode: rmode_t): integer; cdecl;
function rig_mW2power (rig: PRig; var power : float; mwpower: cardinal; freq : freq_t; mode: rmode_t): integer; cdecl;
function rig_get_resolution (rig: PRig; mode: rmode_t): shortfreq_t; cdecl;
//#define rig_get_strength(r,v,s) rig_get_level((r),(v),RIG_LEVEL_STRENGTH, (value_t * )(s)) // macro
function rig_set_func (rig: PRig; vfo: vfo_t; func : setting_t; status : integer): integer; cdecl;
function rig_get_func (rig: PRig; vfo: vfo_t; func : setting_t; var status : integer): integer; cdecl;
function rig_set_level (rig: PRig; vfo: vfo_t; level : setting_t; val : value_t): integer; cdecl;
function rig_get_level (rig: PRig; vfo: vfo_t; level : setting_t; var val : value_t): integer; cdecl;
function rig_set_parm (rig: PRig; parm : setting_t; val : value_t): integer; cdecl;
function rig_get_parm (rig: PRig; parm : setting_t; var val : value_t): integer; cdecl;
function rig_set_conf (rig: PRig; token : token_t; val : PChar): integer; cdecl;
function rig_get_conf (rig: PRig; token : token_t; val : PChar): integer; cdecl;
function rig_set_powerstat (rig: PRig; status : powerstat_t): integer; cdecl;
function rig_get_powerstat (rig: PRig; var status : powerstat_t): integer; cdecl;
function rig_set_ant (rig: PRig; vfo: vfo_t; ant : ant_t): integer; cdecl;
function rig_get_ant (rig: PRig; vfo: vfo_t; var ant : ant_t): integer; cdecl;
function rig_reset (rig: PRig; reset : reset_t): integer; cdecl;
type __cfunc_3 = function(const _conf : TConfParms; _data: pointer): integer; cdecl;
function rig_token_foreach (rig: PRig; cfunc: __cfunc_3; data: pointer): integer; cdecl;
function rig_confparam_lookup (rig: PRig; name : PChar): PConfParms; cdecl;
function rig_token_lookup (rig: PRig; name : PChar): token_t; cdecl;
function rig_has_get_func (rig: PRig; func : setting_t): setting_t; cdecl;
function rig_has_set_func (rig: PRig; func : setting_t): setting_t; cdecl;
function rig_has_get_level (rig: PRig; level : setting_t): setting_t; cdecl;
function rig_has_set_level (rig: PRig; level : setting_t): setting_t; cdecl;
function rig_has_get_parm (rig: PRig; parm : setting_t): setting_t; cdecl;
function rig_has_set_parm (rig: PRig; parm : setting_t): setting_t; cdecl;
function rig_send_dtmf (rig: PRig; vfo: vfo_t; digits : PChar): integer; cdecl;
function rig_recv_dtmf (rig: PRig; vfo: vfo_t; digits : PChar; var length : integer): integer; cdecl;
function rig_send_morse (rig: PRig; vfo: vfo_t; msg : PChar): integer; cdecl;
function rig_set_bank (rig: PRig; vfo: vfo_t; bank : integer): integer; cdecl;
function rig_set_mem (rig: PRig; vfo: vfo_t; ch : integer): integer; cdecl;
function rig_get_mem (rig: PRig; vfo: vfo_t; var ch : integer): integer; cdecl;
function rig_vfo_op (rig: PRig; vfo: vfo_t; op : vfo_op_t): integer; cdecl;
function rig_scan (rig: PRig; vfo: vfo_t; scan: scan_t; ch : integer): integer; cdecl;
function rig_has_vfo_op (rig: PRig; op : vfo_op_t): vfo_op_t; cdecl;
function rig_has_scan (rig: PRig; scan : scan_t): scan_t; cdecl;
function rig_set_trn (rig: PRig; trn: integer): integer; cdecl;
function rig_get_trn (rig: PRig; var trn: integer): integer; cdecl;
function rig_decode_event (rig: PRig): integer; cdecl;
function rig_get_info (rig: PRig): PChar; cdecl;
function rig_set_channel (rig: PRig; const chan: channel_t): integer; cdecl; {* mem *}
function rig_get_channel (rig: PRig; var chan: channel_t): integer; cdecl;
function rig_restore_channel (rig: PRig; const chan: channel_t): integer; cdecl; {* curr VFO *}
function rig_save_channel (rig: PRig; var chan: channel_t): integer; cdecl;
function rig_get_caps (rig_model: rig_model_t): PRigCaps; cdecl;
//function rig_get_range (const range_list: array of freq_range_t; freq: freq_t; rmode_t mode): PFreqRange; cdecl;
function rig_passband_normal (rig: PRig; mode: rmode_t): pbwidth_t; cdecl;
function rig_passband_narrow (rig: PRig; mode: rmode_t): pbwidth_t; cdecl;
function rig_passband_wide (rig: PRig; mode: rmode_t): pbwidth_t; cdecl;
function rig_setting2idx (s: setting_t): integer; cdecl;
// #define rig_idx2setting(i) (1<<(i)) // macro
{*
* Even if these functions are prefixed with "rig_", they are not rig specific
* Maybe "hamlib_" would have been better. Let me know. --SF
*}
function rigerror (errnum: integer): PChar; cdecl;
procedure rig_set_debug (debug_level: rig_debug_level_e); cdecl;
function rig_need_debug (debug_level: rig_debug_level_e): integer; cdecl;
procedure rig_debug (debug_level: rig_debug_level_e; fmt: PChar); cdecl; varargs;
function rig_register (caps : PRigCaps): integer; cdecl;
function rig_unregister (rig_model : rig_model_t): integer; cdecl;
type __cfunc_4 = function(const _rig_caps: TRigCaps; _data: pointer): integer; cdecl;
function rig_list_foreach (cfunc: __cfunc_4; data: pointer): integer; cdecl;
function rig_load_backend (be_name: PChar): integer; cdecl;
function rig_check_backend (rig_model : rig_model_t): integer; cdecl;
function rig_load_all_backends : integer; cdecl;
function rig_probe_all (port : PPort) : rig_model_t; cdecl;
{$IFDEF HAVE_MAGIC_NUMBERS}
function rig_check_magic (rig: PRig): integer; cdecl;
function rigapi_check_magic(rig: PRig): cardinal; cdecl;
{$ENDIF}
function rig_check_types : integer; cdecl;
procedure rigapi_check_types;
const
hamlib_modulename = 'libhamlib.so';
implementation
uses
SysUtils;
function rig_init; external hamlib_modulename name 'rig_init';
function rig_open; external hamlib_modulename name 'rig_open';
function rig_close; external hamlib_modulename name 'rig_close';
function rig_cleanup; external hamlib_modulename name 'rig_cleanup';
function rig_probe; external hamlib_modulename name 'rig_probe';
function rig_set_freq; external hamlib_modulename name 'rig_set_freq';
function rig_get_freq; external hamlib_modulename name 'rig_get_freq';
function rig_set_mode; external hamlib_modulename name 'rig_set_mode';
function rig_get_mode; external hamlib_modulename name 'rig_get_mode';
function rig_set_vfo; external hamlib_modulename name 'rig_set_vfo';
function rig_get_vfo; external hamlib_modulename name 'rig_get_vfo';
function rig_set_ptt; external hamlib_modulename name 'rig_set_ptt';
function rig_get_ptt; external hamlib_modulename name 'rig_get_ptt';
function rig_get_dcd; external hamlib_modulename name 'rig_get_dcd';
function rig_set_rptr_shift; external hamlib_modulename name 'rig_set_rptr_shift';
function rig_get_rptr_shift; external hamlib_modulename name 'rig_get_rptr_shift';
function rig_set_rptr_offs; external hamlib_modulename name 'rig_set_rptr_offs';
function rig_get_rptr_offs; external hamlib_modulename name 'rig_get_rptr_offs';
function rig_set_ctcss_tode; external hamlib_modulename name 'rig_set_ctcss_tode';
function rig_get_ctcss_tode; external hamlib_modulename name 'rig_get_ctcss_tode';
function rig_set_dcs_code; external hamlib_modulename name 'rig_set_dcs_code';
function rig_get_dcs_code; external hamlib_modulename name 'rig_get_dcs_code';
function rig_set_ctcss_sql; external hamlib_modulename name 'rig_set_ctcss_sql';
function rig_get_ctcss_sql; external hamlib_modulename name 'rig_get_ctcss_sql';
function rig_set_dcs_sql; external hamlib_modulename name 'rig_set_dcs_sql';
function rig_get_dcs_sql; external hamlib_modulename name 'rig_get_dcs_sql';
function rig_set_split_freq; external hamlib_modulename name 'rig_set_split_freq';
function rig_get_split_freq; external hamlib_modulename name 'rig_get_split_freq';
function rig_set_split_mode; external hamlib_modulename name 'rig_set_split_mode';
function rig_get_split_mode; external hamlib_modulename name 'rig_get_split_mode';
function rig_set_split; external hamlib_modulename name 'rig_set_split';
function rig_get_split; external hamlib_modulename name 'rig_get_split';
function rig_set_rit; external hamlib_modulename name 'rig_set_rit';
function rig_get_rit; external hamlib_modulename name 'rig_get_rit';
function rig_set_xit; external hamlib_modulename name 'rig_set_xit';
function rig_get_xit; external hamlib_modulename name 'rig_get_xit';
function rig_set_ts; external hamlib_modulename name 'rig_set_ts';
function rig_get_ts; external hamlib_modulename name 'rig_get_ts';
function rig_power2mW; external hamlib_modulename name 'rig_power2mW';
function rig_mW2power; external hamlib_modulename name 'rig_mW2power';
function rig_get_resolution; external hamlib_modulename name 'rig_get_resolution';
function rig_set_func; external hamlib_modulename name 'rig_set_func';
function rig_get_func; external hamlib_modulename name 'rig_get_func';
function rig_set_level; external hamlib_modulename name 'rig_set_level';
function rig_get_level; external hamlib_modulename name 'rig_get_level';
function rig_set_parm; external hamlib_modulename name 'rig_set_parm';
function rig_get_parm; external hamlib_modulename name 'rig_get_parm';
function rig_set_conf; external hamlib_modulename name 'rig_set_conf';
function rig_get_conf; external hamlib_modulename name 'rig_get_conf';
function rig_set_powerstat; external hamlib_modulename name 'rig_set_powerstat';
function rig_get_powerstat; external hamlib_modulename name 'rig_get_powerstat';
function rig_set_ant; external hamlib_modulename name 'rig_set_ant';
function rig_get_ant; external hamlib_modulename name 'rig_get_ant';
function rig_reset; external hamlib_modulename name 'rig_reset';
function rig_token_foreach; external hamlib_modulename name 'rig_token_foreach';
function rig_confparam_lookup; external hamlib_modulename name 'rig_confparam_lookup';
function rig_token_lookup; external hamlib_modulename name 'rig_token_lookup';
function rig_has_get_func; external hamlib_modulename name 'rig_has_get_func';
function rig_has_set_func; external hamlib_modulename name 'rig_has_set_func';
function rig_has_get_level; external hamlib_modulename name 'rig_has_get_level';
function rig_has_set_level; external hamlib_modulename name 'rig_has_set_level';
function rig_has_get_parm; external hamlib_modulename name 'rig_has_get_parm';
function rig_has_set_parm; external hamlib_modulename name 'rig_has_set_parm';
function rig_send_dtmf; external hamlib_modulename name 'rig_send_dtmf';
function rig_recv_dtmf; external hamlib_modulename name 'rig_recv_dtmf';
function rig_send_morse; external hamlib_modulename name 'rig_send_morse';
function rig_set_bank; external hamlib_modulename name 'rig_set_bank';
function rig_set_mem; external hamlib_modulename name 'rig_set_mem';
function rig_get_mem; external hamlib_modulename name 'rig_get_mem';
function rig_vfo_op; external hamlib_modulename name 'rig_vfo_op';
function rig_scan; external hamlib_modulename name 'rig_scan';
function rig_has_vfo_op; external hamlib_modulename name 'rig_has_vfo_op';
function rig_has_scan; external hamlib_modulename name 'rig_has_scan';
function rig_set_trn; external hamlib_modulename name 'rig_set_trn';
function rig_get_trn; external hamlib_modulename name 'rig_get_trn';
function rig_decode_event; external hamlib_modulename name 'rig_decode_event';
function rig_get_info; external hamlib_modulename name 'rig_get_info';
function rig_set_channel; external hamlib_modulename name 'rig_set_channel';
function rig_get_channel; external hamlib_modulename name 'rig_get_channel';
function rig_restore_channel; external hamlib_modulename name 'rig_restore_channel';
function rig_save_channel; external hamlib_modulename name 'rig_save_channel';
function rig_get_caps; external hamlib_modulename name 'rig_get_caps';
//function rig_get_range; external hamlib_modulename name 'rig_get_range';
function rig_passband_normal; external hamlib_modulename name 'rig_passband_normal';
function rig_passband_narrow; external hamlib_modulename name 'rig_passband_narrow';
function rig_passband_wide; external hamlib_modulename name 'rig_passband_wide';
function rig_setting2idx; external hamlib_modulename name 'rig_setting2idx';
function rigerror; external hamlib_modulename name 'rigerror';
procedure rig_set_debug; external hamlib_modulename name 'rig_set_debug';
function rig_need_debug; external hamlib_modulename name 'rig_need_debug';
procedure rig_debug; external hamlib_modulename name 'rig_debug';
function rig_register; external hamlib_modulename name 'rig_register';
function rig_unregister; external hamlib_modulename name 'rig_unregister';
function rig_list_foreach; external hamlib_modulename name 'rig_list_foreach';
function rig_load_backend; external hamlib_modulename name 'rig_load_backend';
function rig_check_backend; external hamlib_modulename name 'rig_check_backend';
function rig_load_all_backends; external hamlib_modulename name 'rig_load_all_backends';
function rig_probe_all; external hamlib_modulename name 'rig_probe_all';
{$IFDEF HAVE_MAGIC_NUMBERS}
function rig_check_magic; external hamlib_modulename name 'rig_check_magic';
function rigapi_check_magic(rig: PRig): cardinal;
begin
if (rig = nil)
then result := $FFFF
else begin
result := 0;
if (rig^.magic <> RIG_MAGIC)
then result := result or (1 shl 1);
if (rig^.caps = nil)
then result := result or (1 shl 2)
else if (rig^.caps^.magic <> RIG_MAGIC_CAPS)
then result := result or (1 shl 3);
if (rig^.state.magic <> RIG_MAGIC_STATE)
then result := result or (1 shl 4);
if (rig^.callbacks.magic <> RIG_MAGIC_CALLBACKS)
then result := result or (1 shl 5);
end;
end;
{$ENDIF}
{* Macro implementations *}
function RIG_CTRL_BAND(band, vfo: integer): integer;
begin
RIG_CTRL_BAND := (($80 shl (8*((band)-1))) or (vfo shl (8*((band)-1))) );
end;
function RIG_VFO_A : integer;
begin
RIG_VFO_A := (RIG_CTRL_BAND(RIG_CTRL_MAIN, RIG_VFO1));
end;
function RIG_VFO_B : integer;
begin
RIG_VFO_B := (RIG_CTRL_BAND(RIG_CTRL_MAIN, RIG_VFO2));
end;
function RIG_VFO_C : integer;
begin
RIG_VFO_C := (RIG_CTRL_BAND(RIG_CTRL_SUB, RIG_VFO1));
end;
function RIG_VFO_MAIN : integer;
begin
RIG_VFO_MAIN := (RIG_CTRL_BAND(RIG_CTRL_MAIN, RIG_VFO_CURR));
end;
function RIG_VFO_SUB : integer;
begin
RIG_VFO_SUB := (RIG_CTRL_BAND(RIG_CTRL_SUB, RIG_VFO_CURR));
end;
function rig_check_types; external hamlib_modulename name 'rig_check_types';
procedure rigapi_check_types;
begin
rig_debug(RIG_DEBUG_TRACE, 'Type Checking for Pascal -----------------------------'+chr($a));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(TRig) = '+ IntToStr(sizeof(TRig))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(TRigCaps) = '+ IntToStr(sizeof(TRigCaps))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(TRigState) = '+ IntToStr(sizeof(TRigState))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(TRigCallbacks) = '+ IntToStr(sizeof(TRigCallbacks))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(TPort) = '+ IntToStr(sizeof(TPort))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(chan_list) = '+ IntToStr(sizeof(chan_list))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(chan_type_e) = '+ IntToStr(sizeof(chan_type_e))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(filter_list) = '+ IntToStr(sizeof(filter_list))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(tuning_step_list) = '+ IntToStr(sizeof(tuning_step_list))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(freq_range_list) = '+ IntToStr(sizeof(freq_range_list))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(setting_t) = '+ IntToStr(sizeof(setting_t))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(value_t) = '+ IntToStr(sizeof(value_t))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(agc_level_e) = '+ IntToStr(sizeof(agc_level_e))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(meter_level_e) = '+ IntToStr(sizeof(meter_level_e))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(confparams) = '+ IntToStr(sizeof(confparams))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(powerstat_e) = '+ IntToStr(sizeof(powerstat_e))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(reset_e) = '+ IntToStr(sizeof(reset_e))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(ptt_type_e) = '+ IntToStr(sizeof(ptt_type_e))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(ptt_e) = '+ IntToStr(sizeof(ptt_e))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(dcd_e) = '+ IntToStr(sizeof(dcd_e))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(dcd_type_e) = '+ IntToStr(sizeof(dcd_type_e))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(pbwidth_t) = '+ IntToStr(sizeof(pbwidth_t))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(freq_t) = '+ IntToStr(sizeof(freq_t))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(shortfreq) = '+ IntToStr(sizeof(shortfreq_t))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(split_e) = '+ IntToStr(sizeof(split_e))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(rptr_shift_e) = '+ IntToStr(sizeof(rptr_shift_e))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(rig_status_e) = '+ IntToStr(sizeof(rig_status_e))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(serial_parity_e) = '+ IntToStr(sizeof(serial_parity_e))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(serial_handshake_e) = '+ IntToStr(sizeof(serial_handshake_e))+chr($a) ));
rig_debug(RIG_DEBUG_TRACE, PChar('sizeof(rig_debug_level_e) = '+ IntToStr(sizeof(rig_debug_level_e))+chr($a) ));
end;
end.
Reference in New Issue View Git Blame Kopiuj bezpośredni odnośnik