kopia lustrzana https://github.com/Hamlib/Hamlib
Added working TS-2000 files. There are some changes left out but this
is the minimum I could commit and have a functional rig. The cost is that I've broken kylix and others that duplicate rig.h. I'm in the process of repairing the damage. Please be patient. I hope a day or so, but am asking for up to a week. E-mail me about *anything* you find broken. Kylix (and similar) is (are) known to not work. git-svn-id: https://hamlib.svn.sourceforge.net/svnroot/hamlib/trunk@1083 7ae35d74-ebe9-4afe-98af-79ac388436b8Hamlib-1.1.4
Dale E. Edmons, KD7ENI
rodzic
9820f82939
commit
7212a11aa8
|
|
@ -2,7 +2,7 @@
|
|||
* Hamlib Interface - API header
|
||||
* Copyright (c) 2000-2002 by Stephane Fillod and Frank Singleton
|
||||
*
|
||||
* $Id: rig.h,v 1.64 2002-04-23 21:49:04 fillods Exp $
|
||||
* $Id: rig.h,v 1.65 2002-06-30 10:17:03 dedmons 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
|
||||
|
|
@ -59,9 +59,7 @@
|
|||
#include <hamlib/rig_dll.h>
|
||||
|
||||
|
||||
__BEGIN_DECLS
|
||||
|
||||
extern HAMLIB_EXPORT_VAR(const char) hamlib_version[];
|
||||
__BEGIN_DECLS extern HAMLIB_EXPORT_VAR(const char) hamlib_version[];
|
||||
extern HAMLIB_EXPORT_VAR(const char) hamlib_copyright[];
|
||||
|
||||
typedef unsigned int tone_t;
|
||||
|
|
@ -192,14 +190,16 @@ enum rig_status_e {
|
|||
enum rptr_shift_e {
|
||||
RIG_RPT_SHIFT_NONE = 0,
|
||||
RIG_RPT_SHIFT_MINUS,
|
||||
RIG_RPT_SHIFT_PLUS
|
||||
RIG_RPT_SHIFT_PLUS,
|
||||
RIG_RPT_SHIFT_1750 // ts2000 E-type '='
|
||||
};
|
||||
|
||||
typedef enum rptr_shift_e rptr_shift_t;
|
||||
|
||||
/* hopefully, this is obsolete? --Dale kd7eni */
|
||||
enum split_e {
|
||||
RIG_SPLIT_OFF = 0,
|
||||
RIG_SPLIT_ON,
|
||||
RIG_SPLIT_ON
|
||||
};
|
||||
|
||||
typedef enum split_e split_t;
|
||||
|
|
@ -218,48 +218,97 @@ typedef signed long shortfreq_t;
|
|||
|
||||
#define RIG_FREQ_NONE Hz(0)
|
||||
|
||||
|
||||
#define RIG_VFO_CURR 0 /* current "tunable channel"/VFO */
|
||||
#define RIG_VFO_NONE 0 /* used in caps */
|
||||
#define 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
|
||||
* I've cleaned up the VFO definition to make it easier to change
|
||||
* when the MoonMelter is finally released. Essentially, I've
|
||||
* done nothing. --Dale :)
|
||||
*/
|
||||
#define RIG_VFO_MEM -2 /* means Memory mode, to be used with set_vfo */
|
||||
#define RIG_VFO_VFO -3 /* means (any)VFO mode, with set_vfo */
|
||||
|
||||
#define RIG_VFO1 (1<<0)
|
||||
#define RIG_VFO2 (1<<1)
|
||||
#define RIG_CTRL_MAIN 1
|
||||
#define RIG_CTRL_SUB 2
|
||||
|
||||
/*
|
||||
* one byte per "tunable channel":
|
||||
* Upper segment: "rig Major"
|
||||
* Lower segment: "VFO minor"
|
||||
*
|
||||
* MSB LSB
|
||||
* 8 1
|
||||
* +-+-+-+-+-+-+-+-+
|
||||
* N n+1 n 0
|
||||
* +-+-+-+-+-+-+-+-+-+-+-+
|
||||
* | | |
|
||||
* CTL VFO
|
||||
* Rig VFO
|
||||
* Major minor
|
||||
*/
|
||||
typedef unsigned int vfo_t;
|
||||
|
||||
#define BIT(a) ( ((vfo_t) 1) << (a))
|
||||
//#define BIT(a) (1L << (a))
|
||||
|
||||
#define RIG_MINOR 6
|
||||
/* M=Major, m=minor */
|
||||
#define RIG_SET_VFO(M,m) ((vfo_t) ( ((M) << (RIG_MINOR+1)) | (m) ))
|
||||
/* Note: prior definition exibited exponential growth in bit count */
|
||||
|
||||
#define RIG_VFO_CTRL RIG_SET_VFO(0, BIT(0))
|
||||
#define RIG_VFO_PTT RIG_SET_VFO(0, BIT(1))
|
||||
|
||||
/* VFO Minor */
|
||||
#define RIG_VFO1 RIG_SET_VFO(0, BIT(2)) // VFO_A
|
||||
#define RIG_VFO2 RIG_SET_VFO(0, BIT(3)) // VFO_B
|
||||
#define RIG_VFO3 RIG_SET_VFO(0, BIT(4)) // VFO_C
|
||||
#define RIG_VFO4 RIG_SET_VFO(0, BIT(5)) // MEM
|
||||
#define RIG_VFO5 RIG_SET_VFO(0, BIT(6)) // CALL
|
||||
/* |
|
||||
* RIG_MINOR = n :== MAX >-----------------'
|
||||
*/
|
||||
|
||||
/* How to call it? "tunable channel"? Control band? */
|
||||
#define RIG_CTRL_BAND(band,vfo) ( (0x80<<(8*((band)-1))) | ((vfo)<<(8*((band)-1))) )
|
||||
/* Rig Major */
|
||||
#define RIG_CTRL_MAIN RIG_SET_VFO(BIT(0), 0)
|
||||
#define RIG_CTRL_SUB RIG_SET_VFO(BIT(1), 0)
|
||||
#define RIG_CTRL_MEM RIG_SET_VFO(BIT(2), 0)
|
||||
#define RIG_CTRL_CALL RIG_SET_VFO(BIT(3), 0)
|
||||
#define RIG_CTRL_SPLIT RIG_SET_VFO(BIT(4), 0)
|
||||
#define RIG_CTRL_SCAN RIG_SET_VFO(BIT(5), 0)
|
||||
#define RIG_CTRL_SAT RIG_SET_VFO(BIT(6), 0)
|
||||
#define RIG_CTRL_REV RIG_SET_VFO(BIT(7), 0)
|
||||
|
||||
/* macros */
|
||||
#define RIG_VFO_A (RIG_CTRL_BAND(RIG_CTRL_MAIN, RIG_VFO1))
|
||||
#define RIG_VFO_B (RIG_CTRL_BAND(RIG_CTRL_MAIN, RIG_VFO2))
|
||||
#define RIG_VFO_C (RIG_CTRL_BAND(RIG_CTRL_SUB, RIG_VFO1))
|
||||
#define RIG_VFO_MAIN (RIG_CTRL_BAND(RIG_CTRL_MAIN, RIG_VFO_CURR))
|
||||
#define RIG_VFO_SUB (RIG_CTRL_BAND(RIG_CTRL_SUB, RIG_VFO_CURR))
|
||||
/* VFO stuff that may be handy. */
|
||||
#define RIG_VFO_MASK (RIG_VFO1 | RIG_VFO2 | RIG_VFO3 | RIG_VFO4 | RIG_VFO5)
|
||||
#define RIG_CTRL_MASK (RIG_CTRL_MAIN | RIG_CTRL_SUB | RIG_CTRL_MEM \
|
||||
| RIG_CTRL_CALL | RIG_CTRL_SPLIT | RIG_CTRL_SCAN \
|
||||
| RIG_CTRL_SAT | RIG_CTRL_REV)
|
||||
#define RIG_VFO_VALID (RIG_CTRL_MASK | RIG_VFO_MASK)
|
||||
#define RIG_VFO_TEST(v) (((v) & RIG_VFO_VALID) != 0)
|
||||
|
||||
/* The following are for compatibility with existing code! */
|
||||
|
||||
/* Standard VFO's for common use */
|
||||
#define RIG_VFO_A (RIG_CTRL_MAIN | RIG_VFO1)
|
||||
#define RIG_VFO_B (RIG_CTRL_MAIN | RIG_VFO2)
|
||||
#define RIG_VFO_C (RIG_CTRL_SUB | RIG_VFO3)
|
||||
|
||||
/* More standard VFO' but these are new! */
|
||||
// How is it possible for rig_get_vfo() to tell use we're split otherwise?
|
||||
#define RIG_VFO_AB ((RIG_CTRL_SPLIT | RIG_CTRL_MAIN) | (RIG_VFO1 | RIG_VFO2))
|
||||
#define RIG_VFO_BA ((RIG_CTRL_REV | RIG_CTRL_SPLIT | RIG_CTRL_MAIN) \
|
||||
| (RIG_VFO1 | RIG_VFO2))
|
||||
/* memories (except temp) */
|
||||
#define RIG_VFO_MEM_A ((RIG_CTRL_MEM | RIG_CTRL_MAIN) | RIG_VFO4)
|
||||
#define RIG_VFO_MEM_C ((RIG_CTRL_MEM | RIG_CTRL_SUB) | RIG_VFO4)
|
||||
#define RIG_VFO_CALL_A ((RIG_CTRL_MEM | RIG_CTRL_MAIN) | RIG_VFO5)
|
||||
#define RIG_VFO_CALL_C ((RIG_CTRL_CALL | RIG_CTRL_SUB) | RIG_VFO5)
|
||||
|
||||
/* Standard control's for common use */
|
||||
#define RIG_VFO_MEM (RIG_CTRL_MEM | RIG_VFO_VFO)
|
||||
#define RIG_VFO_MAIN RIG_CTRL_MAIN
|
||||
#define RIG_VFO_SUB RIG_CTRL_SUB
|
||||
|
||||
/* pseudo targets */
|
||||
#define RIG_VFO_CURR RIG_VFO_VALID
|
||||
#define RIG_VFO_VFO RIG_VFO_MASK
|
||||
|
||||
/* Hopefully, to following will be dropped */
|
||||
#define RIG_VFO_NONE (~RIG_VFO_VALID)
|
||||
#define RIG_VFO_ALL ~RIG_VFO_MASK
|
||||
/*
|
||||
* could RIG_VFO_ALL be useful?
|
||||
* i.e. apply to all VFO, when used as target
|
||||
* Ahhh. Now I can live happy and die free! --Dale
|
||||
*/
|
||||
typedef int vfo_t;
|
||||
|
||||
#define RIG_TARGETABLE_NONE 0x00
|
||||
#define RIG_TARGETABLE_FREQ 0x01
|
||||
|
|
@ -350,9 +399,7 @@ typedef enum reset_e reset_t;
|
|||
* or is it the balance (-> set_level) ? --SF
|
||||
*/
|
||||
|
||||
typedef long vfo_op_t;
|
||||
|
||||
|
||||
typedef unsigned int vfo_op_t;
|
||||
|
||||
#define RIG_SCAN_NONE 0L
|
||||
#define RIG_SCAN_STOP RIG_SCAN_NONE
|
||||
|
|
@ -361,6 +408,10 @@ typedef long vfo_op_t;
|
|||
#define RIG_SCAN_PRIO (1L<<2) /* Priority watch (mem or call channel) */
|
||||
#define RIG_SCAN_PROG (1L<<3) /* Programmed(edge) scan */
|
||||
#define RIG_SCAN_DELTA (1L<<4) /* delta-f scan */
|
||||
#define RIG_SCAN_VFO (1L<<5) /* most basic scan --kd7eni */
|
||||
|
||||
#define RIG_SCAN_ALL (RIG_SCAN_MEM | RIG_SCAN_SLCT | RIG_SCAN_PRIO \
|
||||
| RIG_SCAN_PROG | RIG_SCAN_DELTA | RIG_SCAN_VFO)
|
||||
|
||||
typedef long scan_t;
|
||||
|
||||
|
|
@ -420,7 +471,8 @@ enum agc_level_e {
|
|||
RIG_AGC_OFF = 0,
|
||||
RIG_AGC_SUPERFAST,
|
||||
RIG_AGC_FAST,
|
||||
RIG_AGC_SLOW
|
||||
RIG_AGC_SLOW,
|
||||
RIG_AGC_USER /* some rig's are selectable :) --kd7eni */
|
||||
};
|
||||
|
||||
enum meter_level_e {
|
||||
|
|
@ -474,6 +526,16 @@ typedef union value_u value_t;
|
|||
#define RIG_LEVEL_ALC (1<<29) /* ALC, arg float */
|
||||
#define RIG_LEVEL_STRENGTH (1<<30) /* Signal strength, arg int (dB) */
|
||||
|
||||
#define RIG_LEVEL_ALL (RIG_LEVEL_PREAMP | RIG_LEVEL_ATT | RIG_LEVEL_VOX \
|
||||
| RIG_LEVEL_AF | RIG_LEVEL_RF | RIG_LEVEL_SQL \
|
||||
| RIG_LEVEL_IF | RIG_LEVEL_APF | RIG_LEVEL_NR \
|
||||
| RIG_LEVEL_PBT_IN | RIG_LEVEL_PBT_OUT | RIG_LEVEL_CWPITCH \
|
||||
| RIG_LEVEL_RFPOWER | RIG_LEVEL_MICGAIN | RIG_LEVEL_KEYSPD \
|
||||
| RIG_LEVEL_NOTCHF | RIG_LEVEL_COMP | RIG_LEVEL_AGC \
|
||||
| RIG_LEVEL_BKINDL | RIG_LEVEL_BALANCE | RIG_LEVEL_METER \
|
||||
| RIG_LEVEL_VOXGAIN | RIG_LEVEL_VOXDELAY | RIG_LEVEL_SQLSTAT \
|
||||
| RIG_LEVEL_SWR | RIG_LEVEL_ALC | RIG_LEVEL_STRENGTH)
|
||||
|
||||
#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)
|
||||
|
|
@ -489,9 +551,14 @@ typedef union value_u value_t;
|
|||
#define RIG_PARM_ANN (1<<0) /* "Announce" level, see ann_t */
|
||||
#define RIG_PARM_APO (1<<1) /* Auto power off, int in minute */
|
||||
#define RIG_PARM_BACKLIGHT (1<<2) /* LCD light, float [0.0..1.0] */
|
||||
#define RIG_PARM_BEEP (1<<4) /* Beep on keypressed, int (0,1) */
|
||||
#define RIG_PARM_BEEP (1<<4) /* Beep on keypressed, int (0...10) */
|
||||
#define RIG_PARM_TIME (1<<5) /* hh:mm:ss, int in seconds from 00:00:00 */
|
||||
#define RIG_PARM_BAT (1<<6) /* battery level, float [0.0..1.0] */
|
||||
#define RIG_PARM_KEYLIGHT (1<<7) /* Button backlight, on/off */
|
||||
|
||||
#define RIG_PARM_ALL (RIG_PARM_ANN | RIG_PARM_APO | RIG_PARM_BACKLIGHT \
|
||||
| RIG_PARM_BEEP | RIG_PARM_TIME | RIG_PARM_BAT \
|
||||
| RIG_PARM_KEYLIGHT )
|
||||
|
||||
#define RIG_PARM_FLOAT_LIST (RIG_PARM_BACKLIGHT|RIG_PARM_BAT)
|
||||
#define RIG_PARM_READONLY_LIST (RIG_PARM_BAT)
|
||||
|
|
@ -545,6 +612,16 @@ typedef unsigned long long setting_t; /* hope 64 bits will be enough.. */
|
|||
#define RIG_FUNC_SCOPE (1<<27) /* Simple bandscope ON/OFF (IC-910H) */
|
||||
#define RIG_FUNC_RESUME (1<<28) /* Scan resume */
|
||||
|
||||
#define RIG_FUNC_ALL (RIG_FUNC_FAGC | RIG_FUNC_NB | RIG_FUNC_COMP \
|
||||
| RIG_FUNC_VOX | RIG_FUNC_TONE | RIG_FUNC_TSQL \
|
||||
| RIG_FUNC_SBKIN | RIG_FUNC_FBKIN | RIG_FUNC_ANF \
|
||||
| RIG_FUNC_NR | RIG_FUNC_AIP | RIG_FUNC_MON \
|
||||
| RIG_FUNC_MN | RIG_FUNC_RNF | RIG_FUNC_ARO \
|
||||
| RIG_FUNC_LOCK | RIG_FUNC_MUTE | RIG_FUNC_VSC \
|
||||
| RIG_FUNC_REV | RIG_FUNC_SQL | RIG_FUNC_BC \
|
||||
| RIG_FUNC_MBC | RIG_FUNC_LMP | RIG_FUNC_AFC \
|
||||
| RIG_FUNC_SATMODE | RIG_FUNC_SCOPE | RIG_FUNC_RESUME)
|
||||
|
||||
/*
|
||||
* power unit macros, converts to mW
|
||||
* This is limited to 2MW on 32 bits systems.
|
||||
|
|
@ -637,6 +714,7 @@ struct channel {
|
|||
int bank_num;
|
||||
vfo_t vfo;
|
||||
int ant;
|
||||
char lock; /* added, I use this --kd7eni */
|
||||
freq_t freq;
|
||||
rmode_t mode;
|
||||
pbwidth_t width;
|
||||
|
|
@ -651,10 +729,14 @@ struct channel {
|
|||
shortfreq_t xit;
|
||||
setting_t funcs;
|
||||
value_t levels[RIG_SETTING_MAX];
|
||||
tone_t tone; /* added --Dale kd7eni */
|
||||
tone_t tone_sql; /* added --Dale kd7eni */
|
||||
tone_t ctcss_tone;
|
||||
tone_t ctcss_sql;
|
||||
tone_t dcs_code;
|
||||
tone_t dcs_sql;
|
||||
scan_t scan;
|
||||
int scan_group; /* added, I use this often --kd7eni */
|
||||
int flags; /* to be defined */
|
||||
char channel_desc[MAXCHANDESC];
|
||||
};
|
||||
|
|
@ -678,7 +760,13 @@ enum chan_type_e {
|
|||
RIG_MTYPE_EDGE, /* scan edge */
|
||||
RIG_MTYPE_CALL, /* call channel */
|
||||
RIG_MTYPE_MEMOPAD, /* inaccessible on Icom, what about others? */
|
||||
RIG_MTYPE_SAT /* satellite */
|
||||
/* ts2000 can store/recall, but not read --kd7eni */
|
||||
RIG_MTYPE_SAT, /* satellite */
|
||||
|
||||
/* added some for ts2000 --kd7eni */
|
||||
RIG_MTYPE_MENU, /* menus A or B */
|
||||
RIG_MTYPE_SETUP, /* bank 0-5; seems to save only menus */
|
||||
RIG_MTYPE_PCT, /* Packet cluster buffered memories */
|
||||
};
|
||||
|
||||
struct chan_list {
|
||||
|
|
@ -686,6 +774,10 @@ struct chan_list {
|
|||
int end;
|
||||
enum chan_type_e type; /* among EDGE, MEM, CALL, .. */
|
||||
int reserved; /* don't know yet, maybe smthing like flags */
|
||||
/* FIXME : some memories available only in special modes or on main
|
||||
rather than sub-receiver. This could help especially if
|
||||
rig only responds with error or worse, silently ignores you!
|
||||
Add 'mode' or some such for future use? --D.E. kd7eni */
|
||||
};
|
||||
|
||||
#define RIG_CHAN_END {0,0,RIG_MTYPE_NONE,0}
|
||||
|
|
@ -797,8 +889,10 @@ struct rig_caps {
|
|||
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_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);
|
||||
|
|
@ -807,16 +901,20 @@ struct rig_caps {
|
|||
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_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_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) (RIG * rig, vfo_t vfo, split_t split);
|
||||
int (*get_split) (RIG * rig, vfo_t vfo, split_t * split);
|
||||
|
||||
|
|
@ -830,11 +928,15 @@ struct rig_caps {
|
|||
|
||||
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);
|
||||
|
||||
|
|
@ -844,8 +946,10 @@ struct rig_caps {
|
|||
* Unfortunately, on most rigs, the formula is not the same
|
||||
* on all bands/modes. Have to work this out.. --SF
|
||||
*/
|
||||
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 (*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);
|
||||
|
|
@ -854,11 +958,14 @@ struct rig_caps {
|
|||
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_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 (*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);
|
||||
|
|
@ -886,7 +993,7 @@ struct rig_caps {
|
|||
* Convenience Functions
|
||||
*/
|
||||
|
||||
int (*set_channel)(RIG *rig, const channel_t *chan);
|
||||
int (*set_channel) (RIG * rig, channel_t * chan);
|
||||
int (*get_channel) (RIG * rig, channel_t * chan);
|
||||
|
||||
/* get firmware info, etc. */
|
||||
|
|
@ -1022,6 +1129,7 @@ struct rig_state {
|
|||
*
|
||||
* Event based programming, really appropriate in a GUI.
|
||||
* So far, Icoms are able to do that in Transceive mode, and PCR-1000 too.
|
||||
* TS-2000 does also (90%). --kd7eni
|
||||
*/
|
||||
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);
|
||||
|
|
@ -1057,161 +1165,301 @@ struct rig {
|
|||
|
||||
/* --------------- 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));
|
||||
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_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_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_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_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_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_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_tone HAMLIB_PARAMS((RIG * rig, vfo_t vfo, tone_t tone));
|
||||
extern HAMLIB_EXPORT(int)
|
||||
rig_set_ctcss_tone HAMLIB_PARAMS((RIG * rig, vfo_t vfo, tone_t tone));
|
||||
extern HAMLIB_EXPORT(int)
|
||||
rig_get_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_tone_sql HAMLIB_PARAMS((RIG * rig, vfo_t vfo, tone_t tone));
|
||||
extern HAMLIB_EXPORT(int)
|
||||
rig_get_tone_sql HAMLIB_PARAMS((RIG * rig, vfo_t vfo, tone_t * tone));
|
||||
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 HAMLIB_PARAMS((RIG *rig, vfo_t vfo, split_t split));
|
||||
extern HAMLIB_EXPORT(int) rig_get_split HAMLIB_PARAMS((RIG *rig, vfo_t vfo, split_t *split));
|
||||
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 HAMLIB_PARAMS((RIG * rig, vfo_t vfo, split_t split));
|
||||
extern HAMLIB_EXPORT(int)
|
||||
rig_get_split HAMLIB_PARAMS((RIG * rig, vfo_t vfo, split_t * split));
|
||||
|
||||
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_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_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(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(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));
|
||||
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_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_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_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_reset HAMLIB_PARAMS((RIG * rig, reset_t reset)); /* dangerous! */
|
||||
|
||||
|
||||
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_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_close HAMLIB_PARAMS((RIG * rig));
|
||||
extern HAMLIB_EXPORT(int)
|
||||
rig_cleanup HAMLIB_PARAMS((RIG * rig));
|
||||
|
||||
extern HAMLIB_EXPORT(rig_model_t) rig_probe HAMLIB_PARAMS((port_t *p));
|
||||
extern HAMLIB_EXPORT(rig_model_t)
|
||||
rig_probe HAMLIB_PARAMS((port_t * p));
|
||||
|
||||
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(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_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_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(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_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_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_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_restore_channel HAMLIB_PARAMS((RIG *rig, const channel_t *chan)); /* curr VFO */
|
||||
extern HAMLIB_EXPORT(int) rig_save_channel HAMLIB_PARAMS((RIG *rig, channel_t *chan));
|
||||
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_restore_channel HAMLIB_PARAMS((RIG * rig, const channel_t * chan)); /* curr VFO */
|
||||
extern HAMLIB_EXPORT(int)
|
||||
rig_save_channel HAMLIB_PARAMS((RIG * rig, channel_t * chan));
|
||||
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_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_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(const char *) rig_get_info HAMLIB_PARAMS((RIG *rig));
|
||||
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(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(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(const char *)
|
||||
rigerror HAMLIB_PARAMS((int errnum));
|
||||
|
||||
extern HAMLIB_EXPORT(int) rig_setting2idx HAMLIB_PARAMS((setting_t s));
|
||||
extern HAMLIB_EXPORT(int)
|
||||
rig_setting2idx HAMLIB_PARAMS((setting_t s));
|
||||
#define rig_idx2setting(i) (1ULL<<(i))
|
||||
|
||||
/*
|
||||
* Even if these functions are prefixed with "rig_", they are not rig specific
|
||||
* Maybe "hamlib_" would have been better. Let me know. --SF
|
||||
*/
|
||||
extern HAMLIB_EXPORT(void) rig_set_debug HAMLIB_PARAMS((enum rig_debug_level_e debug_level));
|
||||
extern HAMLIB_EXPORT(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(void)
|
||||
rig_set_debug HAMLIB_PARAMS((enum rig_debug_level_e 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(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(());
|
||||
extern HAMLIB_EXPORT(rig_model_t) rig_probe_all HAMLIB_PARAMS((port_t *p));
|
||||
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(());
|
||||
extern HAMLIB_EXPORT(rig_model_t)
|
||||
rig_probe_all HAMLIB_PARAMS((port_t * p));
|
||||
|
||||
|
||||
__END_DECLS
|
||||
|
||||
#endif /* _RIG_H */
|
||||
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
TSSRCLIST = ts850.c ts870s.c ts570.c ts450s.c ts950.c ts50s.c \
|
||||
ts790.c thd7.c thf7.c
|
||||
ts790.c thd7.c thf7.c ts2000.c
|
||||
|
||||
lib_LTLIBRARIES = libhamlib-kenwood.la
|
||||
libhamlib_kenwood_la_SOURCES = $(TSSRCLIST) kenwood.c th.c ts2k.c
|
||||
libhamlib_kenwood_la_LDFLAGS = -no-undefined -module -version-info 0:0:0
|
||||
libhamlib_kenwood_la_LIBADD = ../src/libhamlib.la
|
||||
|
||||
noinst_HEADERS = kenwood.h th.h ts2k.h ts2000.h
|
||||
noinst_HEADERS = kenwood.h th.h ts2k.h
|
||||
|
|
|
|||
147
kenwood/ts2k.c
147
kenwood/ts2k.c
|
|
@ -2,7 +2,7 @@
|
|||
* Hamlib Kenwood backend - TS2000 description
|
||||
* Copyright (c) 2000-2002 by Stephane Fillod
|
||||
*
|
||||
* $Id: ts2k.c,v 1.4 2002-06-29 09:54:50 dedmons Exp $
|
||||
* $Id: ts2k.c,v 1.5 2002-06-30 10:17:03 dedmons 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
|
||||
|
|
@ -44,9 +44,7 @@
|
|||
|
||||
#include <ctype.h>
|
||||
#include <hamlib/rig.h>
|
||||
/* we shouldn't depend on kenwood right now */
|
||||
//#include "kenwood.h"
|
||||
#include "ts2000.h"
|
||||
#include "kenwood.h"
|
||||
#include "ts2k.h"
|
||||
|
||||
|
||||
|
|
@ -65,7 +63,7 @@
|
|||
* Hamlib Kenwood backend - main file
|
||||
* Copyright (c) 2000-2002 by Stephane Fillod
|
||||
*
|
||||
* $Id: ts2k.c,v 1.4 2002-06-29 09:54:50 dedmons Exp $
|
||||
* $Id: ts2k.c,v 1.5 2002-06-30 10:17:03 dedmons Exp $
|
||||
*/
|
||||
|
||||
|
||||
|
|
@ -157,7 +155,7 @@ const int ts2k_ctcss_list[] = {
|
|||
670, 719, 744, 770, 797, 825, 854, 885, 915, 948,
|
||||
974, 1000, 1035, 1072, 1109, 1148, 1188, 1230, 1273, 1318,
|
||||
1365, 1413, 1462, 1514, 1567, 1622, 1679, 1738, 1799, 1862,
|
||||
1928, 2035, 2107, 2181, 2257, 2336, 2418, 2503, 17500,
|
||||
1928, 2035, 2107, 2181, 2257, 2336, 2418, 2503, // 17500,
|
||||
/* Note: 17500 is not available as ctcss, only tone. --kd7eni */
|
||||
0,
|
||||
};
|
||||
|
|
@ -197,9 +195,9 @@ ts2k_transaction(RIG * rig, const char *cmdstr, int cmd_len,
|
|||
int retval;
|
||||
const char *cmdtrm = EOM_KEN; /* Default Command/Reply termination char */
|
||||
int retry_read = 0;
|
||||
// char *errtxt;
|
||||
char *errtxt;
|
||||
|
||||
#define MAX_RETRY_READ 32
|
||||
#define MAX_RETRY_READ 5
|
||||
|
||||
rs = &rig->state;
|
||||
rs->hold_decode = 1;
|
||||
|
|
@ -357,19 +355,19 @@ int ts2k_set_vfo(RIG * rig, vfo_t vfo)
|
|||
switch (vfo) {
|
||||
case RIG_VFO_A:
|
||||
case RIG_VFO_B:
|
||||
// case RIG_VFO_AB: // split
|
||||
// case RIG_VFO_BA:
|
||||
// case RIG_VFO_SAT: // FIXME: Not even close to correct
|
||||
case RIG_VFO_AB: // split
|
||||
case RIG_VFO_BA:
|
||||
case RIG_CTRL_SAT: // FIXME: Not even close to correct
|
||||
case RIG_VFO_MAIN:
|
||||
// case RIG_VFO_MEM_A:
|
||||
// case RIG_VFO_CALL_A:
|
||||
case RIG_VFO_MEM_A:
|
||||
case RIG_VFO_CALL_A:
|
||||
ctrl = TS2K_CTRL_ON_MAIN; // FIXME : these are independent!
|
||||
ptt = TS2K_PTT_ON_MAIN;
|
||||
break;
|
||||
case RIG_VFO_C:
|
||||
case RIG_VFO_SUB:
|
||||
// case RIG_VFO_MEM_C:
|
||||
// case RIG_VFO_CALL_C:
|
||||
case RIG_VFO_MEM_C:
|
||||
case RIG_VFO_CALL_C:
|
||||
ctrl = TS2K_CTRL_ON_SUB;
|
||||
ptt = TS2K_PTT_ON_SUB;
|
||||
break;
|
||||
|
|
@ -388,9 +386,9 @@ int ts2k_set_vfo(RIG * rig, vfo_t vfo)
|
|||
|| (vfo == RIG_VFO_MAIN)
|
||||
|| (vfo == RIG_VFO_CURR)
|
||||
|| (vfo == RIG_VFO_VFO)
|
||||
|| (vfo == RIG_VFO_ALL) // yea, I know
|
||||
// || (vfo == RIG_VFO_ALL) // yea, I know
|
||||
/* bit mask checks */
|
||||
// || (vfo & RIG_CTRL_SAT) // "fr...;", "ft...;" won't do!
|
||||
|| (vfo & RIG_CTRL_SAT) // "fr...;", "ft...;" won't do!
|
||||
;
|
||||
|
||||
rig_debug(RIG_DEBUG_ERR, __FUNCTION__ \
|
||||
|
|
@ -408,16 +406,16 @@ int ts2k_set_vfo(RIG * rig, vfo_t vfo)
|
|||
|
||||
// RX Active Tuning
|
||||
switch (vfo) {
|
||||
//ouch! case RIG_VFO_AB: // TX is opposite
|
||||
case RIG_VFO_AB: // TX is opposite
|
||||
case RIG_VFO_A:
|
||||
case RIG_VFO_C:
|
||||
vfo_function = '0';
|
||||
break;
|
||||
//ouch! case RIG_VFO_BA: // TX is opposite
|
||||
case RIG_VFO_BA: // TX is opposite
|
||||
case RIG_VFO_B:
|
||||
vfo_function = '1';
|
||||
break;
|
||||
/* case RIG_VFO_MEM_A:
|
||||
case RIG_VFO_MEM_A:
|
||||
case RIG_VFO_MEM_C:
|
||||
vfo_function = '2';
|
||||
break;
|
||||
|
|
@ -425,7 +423,7 @@ int ts2k_set_vfo(RIG * rig, vfo_t vfo)
|
|||
case RIG_VFO_CALL_C:
|
||||
vfo_function = '3';
|
||||
break;
|
||||
ouch! */
|
||||
|
||||
default:
|
||||
rig_debug(RIG_DEBUG_ERR, __FUNCTION__
|
||||
": unsupported VFO %u\n", vfo);
|
||||
|
|
@ -447,14 +445,14 @@ ouch! */
|
|||
switch (vfo) {
|
||||
case RIG_VFO_A:
|
||||
case RIG_VFO_C:
|
||||
//ouch! case RIG_VFO_BA: // opposite of above
|
||||
case RIG_VFO_BA: // opposite of above
|
||||
vfo_function = '0';
|
||||
break;
|
||||
//ouch! case RIG_VFO_AB: // opposite of above
|
||||
case RIG_VFO_AB: // opposite of above
|
||||
case RIG_VFO_B:
|
||||
vfo_function = '1';
|
||||
break;
|
||||
/* case RIG_VFO_MEM_A:
|
||||
case RIG_VFO_MEM_A:
|
||||
case RIG_VFO_MEM_C: // FIXME: need to handle vfo/mem split
|
||||
vfo_function = '2';
|
||||
break;
|
||||
|
|
@ -462,7 +460,7 @@ ouch! */
|
|||
case RIG_VFO_CALL_C:
|
||||
vfo_function = '3';
|
||||
break;
|
||||
"I'll be back!" ouch!*/
|
||||
|
||||
default:
|
||||
rig_debug(RIG_DEBUG_ERR, __FUNCTION__
|
||||
": unsupported VFO %u\n",
|
||||
|
|
@ -483,8 +481,7 @@ ouch! */
|
|||
return retval;
|
||||
|
||||
} else { // Check further for special modes not using "fr...;", "ft...;"
|
||||
// if(vfo & RIG_CTRL_SAT) { // test the SAT bit
|
||||
if(vfo & 0) { // test the SAT bit
|
||||
if(vfo & RIG_CTRL_SAT) { // test the SAT bit
|
||||
retval = ts2k_sat_on(rig, vfo);
|
||||
if (retval != RIG_OK)
|
||||
return retval;
|
||||
|
|
@ -515,8 +512,8 @@ int ts2k_sat_on(RIG *rig, vfo_t vfo)
|
|||
|
||||
acklen = 20;
|
||||
|
||||
// if(!(vfo & RIG_CTRL_SAT))
|
||||
// return -RIG_EINTERNAL; // All right. Who called us!?
|
||||
if(!(vfo & RIG_CTRL_SAT))
|
||||
return -RIG_EINTERNAL; // All right. Who called us!?
|
||||
|
||||
// cmdlen = sprintf(cmd, "sa%07u;", 0); // Initial string to modify
|
||||
acklen = ts2k_transaction(rig, "sa;", 3, ack, &acklen);
|
||||
|
|
@ -544,15 +541,13 @@ int ts2k_sat_on(RIG *rig, vfo_t vfo)
|
|||
// FIXME: Add Sat Trace here!
|
||||
|
||||
// Trace REV
|
||||
// if(vfo & RIG_CTRL_REV)
|
||||
if(vfo & 0)
|
||||
if(vfo & RIG_CTRL_REV)
|
||||
ack[7] = '1'; // sat trace REV
|
||||
else
|
||||
ack[7] = '0';
|
||||
|
||||
// CTRL to main or sub?
|
||||
// if ((vfo & RIG_VFO_CTRL) && (vfo & RIG_CTRL_SUB))
|
||||
if ((vfo & 0) && (vfo & 0)) // ouch!
|
||||
if ((vfo & RIG_VFO_CTRL) && (vfo & RIG_CTRL_SUB))
|
||||
ack[5] = '1'; // sat CTRL on sub
|
||||
else
|
||||
ack[5] = '0'; // sat CTRL on main
|
||||
|
|
@ -621,9 +616,7 @@ int ts2k_get_vfo(RIG * rig, vfo_t * vfo)
|
|||
rig_debug(RIG_DEBUG_ERR, __FUNCTION__": SAT=%s\n", vfobuf);
|
||||
if(vfobuf[2] == '1') {
|
||||
/* yes, we're in satellite mode! */
|
||||
// *vfo = RIG_CTRL_SAT; // FIXME: set the rest!
|
||||
// we know what it is, we're just not tellin'
|
||||
*vfo = RIG_VFO_CURR; // FIXME: set the rest!
|
||||
*vfo = RIG_CTRL_SAT; // FIXME: set the rest!
|
||||
/* TODO: write get_sat() and let it do the work */
|
||||
return RIG_OK;
|
||||
}
|
||||
|
|
@ -674,7 +667,7 @@ int ts2k_get_vfo(RIG * rig, vfo_t * vfo)
|
|||
// only valid on Main--no checks required.
|
||||
*vfo = RIG_VFO_B;
|
||||
break;
|
||||
/* case '2':
|
||||
case '2':
|
||||
if (ctrl_ptt[3] == '0') // we use CTRL as Active Transceiver.
|
||||
*vfo = RIG_VFO_MEM_A;
|
||||
else if (ctrl_ptt[3] == '1')
|
||||
|
|
@ -690,7 +683,7 @@ int ts2k_get_vfo(RIG * rig, vfo_t * vfo)
|
|||
else
|
||||
return -RIG_EPROTO;
|
||||
break;
|
||||
sniff, sniff*/
|
||||
|
||||
default: // Different or newer rig types...
|
||||
rig_debug(RIG_DEBUG_ERR,
|
||||
"ts2k_get_vfo: unsupported VFO %c\n",
|
||||
|
|
@ -699,8 +692,8 @@ sniff, sniff*/
|
|||
|
||||
} // end switch
|
||||
} else { // end rx == tx; start split checks.
|
||||
rig_debug(RIG_DEBUG_ERR, "ts2k_get_vfo: Split gone.\n");
|
||||
/*
|
||||
rig_debug(RIG_DEBUG_ERR, "ts2k_get_vfo: Split.\n");
|
||||
|
||||
if (r_vfo == '0' && vfobuf[2] == '1')
|
||||
*vfo = RIG_VFO_AB;
|
||||
else if (r_vfo == '1' && vfobuf[2] == '0')
|
||||
|
|
@ -711,7 +704,6 @@ sniff, sniff*/
|
|||
":FIXME: vfo<->mem split! -kd7eni!\n");
|
||||
return -RIG_EPROTO;
|
||||
}
|
||||
ouch!*/
|
||||
}
|
||||
|
||||
return RIG_OK;
|
||||
|
|
@ -2269,9 +2261,9 @@ int ts2k_get_rptr_shift(RIG * rig, vfo_t vfo, rptr_shift_t * rptr_shift)
|
|||
case '2':
|
||||
*rptr_shift = RIG_RPT_SHIFT_PLUS;
|
||||
break;
|
||||
// case '3':
|
||||
// *rptr_shift = RIG_RPT_SHIFT_1750;
|
||||
// break;
|
||||
case '3':
|
||||
*rptr_shift = RIG_RPT_SHIFT_1750;
|
||||
break;
|
||||
|
||||
default:
|
||||
return -RIG_EINVAL;
|
||||
|
|
@ -2409,7 +2401,7 @@ int ts2k_set_split_freq(RIG * rig, vfo_t vfo, freq_t tx_freq)
|
|||
* send a ' ' or you'll get a "?;" response. Always
|
||||
* set memory with (e.g.) "mc1020;". --kd7eni
|
||||
*/
|
||||
int ts2k_get_channel(RIG * rig, vfo_t vfo, channel_t *chan)
|
||||
int ts2k_get_channel(RIG * rig, channel_t *chan)
|
||||
{
|
||||
// channel_t tch; // needed?
|
||||
char rxtx, mrtxt[2][60], mrcmd[15], ack[60], tmp[20];
|
||||
|
|
@ -2427,10 +2419,8 @@ int ts2k_get_channel(RIG * rig, vfo_t vfo, channel_t *chan)
|
|||
}
|
||||
|
||||
// get needed info if rig's mem pointers used
|
||||
|
||||
// if( ( vfo == RIG_VFO_MEM_A
|
||||
// || vfo == RIG_VFO_MEM_C ) ) {
|
||||
if( vfo == RIG_VFO_MEM ) // which one! (tmp I hope!)
|
||||
if( ( vfo == RIG_VFO_MEM_A
|
||||
|| vfo == RIG_VFO_MEM_C ) ) {
|
||||
rig_debug(RIG_DEBUG_ERR, __FUNCTION__": using rig's ptr\n");
|
||||
retval = ts2k_get_vfo(rig, &curr_vfo);
|
||||
CHKERR(retval);
|
||||
|
|
@ -2438,7 +2428,6 @@ int ts2k_get_channel(RIG * rig, vfo_t vfo, channel_t *chan)
|
|||
CHKERR(retval);
|
||||
chan->channel_num = curr_mem;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
mrtxt_len = ack_len = 60;
|
||||
|
|
@ -2495,7 +2484,7 @@ int ts2k_get_channel(RIG * rig, vfo_t vfo, channel_t *chan)
|
|||
// At any rate, it's currently unused.
|
||||
chan->bank_num = 0; // I merge the two--do not use! --Dale
|
||||
|
||||
//ouch! chan->lock = int_n(tmp, &mrtxt[0][18], 1);
|
||||
chan->lock = int_n(tmp, &mrtxt[0][18], 1);
|
||||
chan->freq = int_n(tmp, &mrtxt[0][06], 11);
|
||||
chan->mode = ts2k_mode_list[ int_n(tmp, &mrtxt[0][17], 1) ];
|
||||
if(chan->mode == RIG_MODE_AM || chan->tx_mode == RIG_MODE_FM)
|
||||
|
|
@ -2529,7 +2518,7 @@ int ts2k_get_channel(RIG * rig, vfo_t vfo, channel_t *chan)
|
|||
chan->ctcss_sql = int_n(tmp, &mrtxt[1][19], 1);
|
||||
chan->dcs_code = ts2k_dcs_list[ int_n(tmp, &mrtxt[1][24], 3) ];
|
||||
chan->dcs_sql = int_n(tmp, &mrtxt[1][19], 1);
|
||||
//ouch! chan->scan_group = int_n(tmp, &mrtxt[1][40], 1);
|
||||
chan->scan_group = int_n(tmp, &mrtxt[1][40], 1);
|
||||
// chan->flags = curr_vfo; // n/a
|
||||
// FIXME : The following may have trailing garbage
|
||||
strncpy( chan->channel_desc, &mrtxt[1][41], 8);
|
||||
|
|
@ -2537,10 +2526,10 @@ int ts2k_get_channel(RIG * rig, vfo_t vfo, channel_t *chan)
|
|||
|
||||
#ifdef _USEVFO
|
||||
// if curr mem is changed at top, this'll restore it
|
||||
/* if( ( vfo == RIG_VFO_MEM_A
|
||||
if( ( vfo == RIG_VFO_MEM_A
|
||||
|| vfo == RIG_VFO_MEM_C ) ) {
|
||||
}
|
||||
now we're in the dark, ouch!*/
|
||||
|
||||
rig_debug(RIG_DEBUG_ERR, __FUNCTION__": restoring mem=%i\n", curr_mem);
|
||||
retval = ts2k_set_mem(rig, curr_vfo, curr_mem);
|
||||
CHKERR(retval);
|
||||
|
|
@ -2565,9 +2554,9 @@ now we're in the dark, ouch!*/
|
|||
* for the design document and hopefully I'll know which way
|
||||
* to go when things aren't the way they should be. We'll
|
||||
* see how things go.
|
||||
* --Dale kd7eni
|
||||
* --Dale kd7e
|
||||
*/
|
||||
int ts2k_set_channel(RIG * rig, vfo_t vfo, channel_t *chan)
|
||||
int ts2k_set_channel(RIG * rig, const channel_t *chan)
|
||||
{
|
||||
char mrtxt[2][60], mrcmd[10], ack[60];
|
||||
int retval, i, j, mr_len[2], ack_len;
|
||||
|
|
@ -2618,7 +2607,7 @@ int ts2k_set_channel(RIG * rig, vfo_t vfo, channel_t *chan)
|
|||
break;
|
||||
}
|
||||
p5 = (unsigned int) j; // FIXME: either not found, or last!
|
||||
//ouch! p6 = (unsigned int) chan->lock;
|
||||
p6 = (unsigned int) chan->lock;
|
||||
p7 = 0; // FIXME: to lazy to sort this out right now
|
||||
p8 = 0; // " " " " "
|
||||
p9 = 0; // " " " " "
|
||||
|
|
@ -2627,7 +2616,7 @@ int ts2k_set_channel(RIG * rig, vfo_t vfo, channel_t *chan)
|
|||
p12 = 0; // " " " " "
|
||||
p13 = 0; // " " " " "
|
||||
p14 = 0; // " " " " "
|
||||
//ouch! p15 = (unsigned int) chan->scan_group;
|
||||
p15 = (unsigned int) chan->scan_group;
|
||||
p16 = &(chan->channel_desc[0]);
|
||||
|
||||
mr_len[i] = sprintf( &(mrtxt[i][0]),
|
||||
|
|
@ -2667,19 +2656,19 @@ int ts2k_vfo_ctrl(RIG * rig, vfo_t vfo)
|
|||
switch (vfo) {
|
||||
case RIG_VFO_A:
|
||||
case RIG_VFO_B:
|
||||
//ouch! case RIG_VFO_AB: // split
|
||||
//ouch! case RIG_VFO_BA:
|
||||
//ouch! case RIG_VFO_SAT: // Should be PTT on main CTRL on sub (?)
|
||||
case RIG_VFO_AB: // split
|
||||
case RIG_VFO_BA:
|
||||
case RIG_CTRL_SAT: // Should be PTT on main CTRL on sub (?)
|
||||
case RIG_VFO_MAIN:
|
||||
//ouch! case RIG_VFO_MEM_A:
|
||||
//ouch! case RIG_VFO_CALL_A:
|
||||
case RIG_VFO_MEM_A:
|
||||
case RIG_VFO_CALL_A:
|
||||
ctrl = TS2K_CTRL_ON_MAIN; // FIXME : these are independent!
|
||||
ptt = TS2K_PTT_ON_MAIN;
|
||||
break;
|
||||
case RIG_VFO_C:
|
||||
case RIG_VFO_SUB:
|
||||
//ouch! case RIG_VFO_MEM_C:
|
||||
//ouch! case RIG_VFO_CALL_C:
|
||||
case RIG_VFO_MEM_C:
|
||||
case RIG_VFO_CALL_C:
|
||||
ctrl = TS2K_CTRL_ON_SUB;
|
||||
ptt = TS2K_PTT_ON_SUB;
|
||||
break;
|
||||
|
|
@ -2742,7 +2731,7 @@ int ts2k_set_split_mode(RIG * rig,
|
|||
vfo_t vfo, rmode_t txmode, pbwidth_t txwidth)
|
||||
{
|
||||
vfo_t vtmp;
|
||||
/*
|
||||
|
||||
switch(vfo) {
|
||||
case RIG_VFO_AB:
|
||||
vtmp = RIG_VFO_B; break;
|
||||
|
|
@ -2751,8 +2740,6 @@ int ts2k_set_split_mode(RIG * rig,
|
|||
default:
|
||||
return -RIG_EINVAL;
|
||||
}
|
||||
rig.c, knows all, sees all. ouch!*/
|
||||
vtmp = vfo;
|
||||
return ts2k_set_mode(rig, vtmp, txmode, txwidth);
|
||||
}
|
||||
|
||||
|
|
@ -2760,7 +2747,6 @@ int ts2k_get_split_mode(RIG *rig,
|
|||
vfo_t vfo, rmode_t *txmode, pbwidth_t *txwidth)
|
||||
{
|
||||
vfo_t vtmp;
|
||||
/*
|
||||
switch(vfo) {
|
||||
case RIG_VFO_AB:
|
||||
vtmp = RIG_VFO_B; break;
|
||||
|
|
@ -2769,8 +2755,6 @@ int ts2k_get_split_mode(RIG *rig,
|
|||
default:
|
||||
return -RIG_EINVAL;
|
||||
}
|
||||
rig.c, knows all, sees all. ouch!*/
|
||||
vtmp = vfo;
|
||||
return ts2k_get_mode(rig, vtmp, txmode, txwidth);
|
||||
}
|
||||
|
||||
|
|
@ -2798,11 +2782,11 @@ int ts2k_scan(RIG *rig, vfo_t vfo, scan_t scan, int ch)
|
|||
// set proper vfo first (already done?)
|
||||
switch(v) {
|
||||
case RIG_VFO_MEM: // Currently selected Main/Sub
|
||||
//ouch! case RIG_VFO_MEM_A: // Main
|
||||
//ouch! case RIG_VFO_MEM_C: // Sub
|
||||
case RIG_VFO_MEM_A: // Main
|
||||
case RIG_VFO_MEM_C: // Sub
|
||||
// FIXME: we should set the group and fall through
|
||||
/* nobreak */
|
||||
// case RIG_VFO_VFO: // Currently selected Main/Sub???
|
||||
// case RIG_VFO_VFO: // Currently selected Main/Sub
|
||||
case RIG_VFO_A: // Main
|
||||
case RIG_VFO_B: // Main
|
||||
case RIG_VFO_C: // Sub
|
||||
|
|
@ -2810,9 +2794,8 @@ int ts2k_scan(RIG *rig, vfo_t vfo, scan_t scan, int ch)
|
|||
CHKERR(retval);
|
||||
break;
|
||||
|
||||
//ouch! case RIG_VFO_CALL_A:
|
||||
//ouch! case RIG_VFO_CALL_C:
|
||||
// Can't feel a thing!
|
||||
case RIG_VFO_CALL_A: //
|
||||
case RIG_VFO_CALL_C:
|
||||
default:
|
||||
rig_debug(RIG_DEBUG_ERR, __FUNCTION__": vfo 'defaulted'\n");
|
||||
return -RIG_ENIMPL; // unimplemented, but valid scan
|
||||
|
|
@ -2891,8 +2874,8 @@ int ts2k_get_parm(RIG *rig, setting_t parm, value_t *val)
|
|||
cmdlen = sprintf(cmd, "ex0120000;"); break;
|
||||
case RIG_PARM_BACKLIGHT:
|
||||
cmdlen = sprintf(cmd, "ex0000000;"); break;
|
||||
// case RIG_PARM_KEYLIGHT:
|
||||
//ouch! cmdlen = sprintf(cmd, "ex0010000;"); break;
|
||||
case RIG_PARM_KEYLIGHT:
|
||||
cmdlen = sprintf(cmd, "ex0010000;"); break;
|
||||
case RIG_PARM_APO:
|
||||
cmdlen = sprintf(cmd, "ex0570000;"); break;
|
||||
case RIG_PARM_ANN:
|
||||
|
|
@ -2910,7 +2893,7 @@ int ts2k_get_parm(RIG *rig, setting_t parm, value_t *val)
|
|||
val->i = (int)(ack[9] - '0');
|
||||
break;
|
||||
case RIG_PARM_BACKLIGHT:
|
||||
//ouch! case RIG_PARM_KEYLIGHT:
|
||||
case RIG_PARM_KEYLIGHT:
|
||||
val->f = (float)(ack[9] - '0');
|
||||
break;
|
||||
case RIG_PARM_APO:
|
||||
|
|
@ -2945,10 +2928,10 @@ int ts2k_set_parm(RIG *rig, setting_t parm, value_t val)
|
|||
(int) ((val.f>1.0)? 4.0 : val.f*4.0) );
|
||||
break;
|
||||
|
||||
/* case RIG_PARM_KEYLIGHT:
|
||||
case RIG_PARM_KEYLIGHT:
|
||||
cmdlen = sprintf(cmd, "ex0010000%01u;", (val.i==0)? 0: 1);
|
||||
break;
|
||||
ouch!*/
|
||||
|
||||
case RIG_PARM_ANN:
|
||||
return -RIG_ENIMPL;
|
||||
|
||||
|
|
|
|||
129
kenwood/ts2k.h
129
kenwood/ts2k.h
|
|
@ -2,7 +2,7 @@
|
|||
* Hamlib TS2000 backend - main header
|
||||
* Copyright (c) 2000-2002 by Stephane Fillod
|
||||
*
|
||||
* $Id: ts2k.h,v 1.2 2002-06-29 09:54:50 dedmons Exp $
|
||||
* $Id: ts2k.h,v 1.3 2002-06-30 10:17:03 dedmons 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
|
||||
|
|
@ -125,8 +125,8 @@ int ts2k_set_trn(RIG *rig, int trn);
|
|||
int ts2k_scan(RIG *rig, vfo_t vfo, scan_t scan, int ch);
|
||||
int ts2k_scan_on(RIG *rig, char ch);
|
||||
int ts2k_scan_off(RIG *rig);
|
||||
int ts2k_get_channel(RIG *rig, vfo_t vfo, channel_t *chan);
|
||||
int ts2k_set_channel(RIG *rig, vfo_t vfo, channel_t *chan);
|
||||
int ts2k_get_channel(RIG *rig, channel_t *chan);
|
||||
int ts2k_set_channel(RIG *rig, const channel_t *chan);
|
||||
char *ts2k_get_ctrl(RIG *rig);
|
||||
int ts2k_set_ctrl(RIG *rig, int ptt, int ctrl);
|
||||
int ts2k_vfo_ctrl(RIG *rig, vfo_t vfo);
|
||||
|
|
@ -172,127 +172,4 @@ extern const struct rig_caps ts2000_caps;
|
|||
extern BACKEND_EXPORT(int) initrigs_ts2k(void *be_handle);
|
||||
extern BACKEND_EXPORT(rig_model_t) proberigs_ts2k(port_t *port);
|
||||
|
||||
|
||||
#endif /* _TS2000_H */
|
||||
|
||||
|
||||
/************** Temporary local copy of rig.h *************************/
|
||||
|
||||
|
||||
|
||||
#ifndef _RIG_H_TEMP
|
||||
#define _RIG_H_TEMP 1
|
||||
|
||||
#define RIG_RPT_SHIFT_1750 (RIG_RPT_SHIFT_PLUS + 1)
|
||||
|
||||
/*
|
||||
* I've cleaned up the VFO definition to make it easier to change
|
||||
* when the MoonMelter is finally released. Essentially, I've
|
||||
* done nothing. --Dale :)
|
||||
*/
|
||||
|
||||
/*
|
||||
* Upper segment: "rig Major"
|
||||
* Lower segment: "VFO minor"
|
||||
*
|
||||
* MSB LSB
|
||||
* N n+1 n 0
|
||||
* +-+-+-+-+-+-+-+-+-+-+-+
|
||||
* | | |
|
||||
* Rig VFO
|
||||
* Major minor
|
||||
*/
|
||||
//typedef unsigned int vfo_t;
|
||||
|
||||
#define BIT(a) ( ((vfo_t) 1) << (a))
|
||||
//#define BIT(a) (1L << (a))
|
||||
|
||||
#define RIG_MINOR 3
|
||||
/* M=Major, m=minor */
|
||||
#define RIG_SET_VFO(M,m) ((vfo_t) ( ((M) << (RIG_MINOR+1)) | (m) ))
|
||||
/* Note: prior definition exibited exponential growth in bit count */
|
||||
|
||||
#define RIG_VFO_RESERVED RIG_SET_VFO(0, BIT(0))
|
||||
#define RIG_VFO_RESERVED2 RIG_SET_VFO(0, BIT(1))
|
||||
|
||||
/* VFO Minor */
|
||||
#define RIG_VFO1 RIG_SET_VFO(0, BIT(2))
|
||||
#define RIG_VFO2 RIG_SET_VFO(0, BIT(3))
|
||||
#define RIG_VFO3 RIG_SET_VFO(0, BIT(4))
|
||||
/* |
|
||||
* RIG_MINOR = n :== MAX >-----------------'
|
||||
*/
|
||||
|
||||
/* Rig Major */
|
||||
#define RIG_CTRL_MAIN RIG_SET_VFO(BIT(0), 0)
|
||||
#define RIG_CTRL_SUB RIG_SET_VFO(BIT(1), 0)
|
||||
#define RIG_CTRL_MEM RIG_SET_VFO(BIT(2), 0)
|
||||
|
||||
/* Standard VFO's for common use */
|
||||
#define RIG_VFO_A (RIG_CTRL_MAIN | RIG_VFO1)
|
||||
#define RIG_VFO_B (RIG_CTRL_MAIN | RIG_VFO2)
|
||||
#define RIG_VFO_C (RIG_CTRL_SUB | RIG_VFO1)
|
||||
#define RIG_VFO_MEM RIG_CTRL_MEM
|
||||
/* VFOC should be VFO3 because ambiguities may arise someday */
|
||||
|
||||
/* VFO stuff that may be handy. */
|
||||
#define RIG_VFO_MASK (RIG_VFO1 | RIG_VFO2 | RIG_VFO3)
|
||||
#define RIG_CTRL_MASK (RIG_CTRL_MAIN | RIG_CTRL_SUB | RIG_CTRL_MEM)
|
||||
#define RIG_VFO_VALID (RIG_CTRL_MASK | RIG_VFO_MASK)
|
||||
#define RIG_VFO_TEST(v) (((v) & RIG_VFO_VALID) != 0)
|
||||
|
||||
/* The following are for compatibility with existing code! */
|
||||
#define RIG_VFO_NONE (~RIG_VFO_VALID)
|
||||
#define RIG_VFO_CURR RIG_SET_VFO(0,0)
|
||||
#define RIG_VFO_ALL RIG_VFO_MASK
|
||||
#define RIG_VFO_MAIN RIG_CTRL_MAIN
|
||||
#define RIG_VFO_SUB RIG_CTRL_SUB
|
||||
#define RIG_VFO_VFO (RIG_VFO_VALID & ~RIG_VFO_MEM)
|
||||
/*
|
||||
* Ahhh. Now I can live happy and die free! --Dale
|
||||
*/
|
||||
|
||||
#define RIG_SCAN_VFO (1L<<4) /* most basic of scans! */
|
||||
|
||||
#define RIG_SCAN_ALL (RIG_SCAN_STOP | RIG_SCAN_MEM | RIG_SCAN_SLCT \
|
||||
| RIG_SCAN_PRIO | RIG_SCAN_PROG | RIG_SCAN_DELTA \
|
||||
| RIG_SCAN_VFO)
|
||||
#define RIG_SCAN_EXCLUDE(e) (RIG_SCAN_ALL & ~(e))
|
||||
|
||||
/* There's no reason for every back-end to write huge lists. The guys
|
||||
* with about 50% features still have some work. Someone that knows
|
||||
* many rigs should make RIG_LEVEL_COMMON, RIG_FUNC_COMMON --Dale
|
||||
*/
|
||||
#define RIG_LEVEL_ALL (RIG_LEVEL_PREAMP | RIG_LEVEL_ATT | RIG_LEVEL_VOX \
|
||||
| RIG_LEVEL_AF | RIG_LEVEL_RF | RIG_LEVEL_SQL \
|
||||
| RIG_LEVEL_IF | RIG_LEVEL_APF | RIG_LEVEL_NR | RIG_LEVEL_PBT_IN \
|
||||
| RIG_LEVEL_PBT_OUT | RIG_LEVEL_CWPITCH | RIG_LEVEL_RFPOWER \
|
||||
| RIG_LEVEL_MICGAIN | RIG_LEVEL_KEYSPD | RIG_LEVEL_NOTCHF \
|
||||
| RIG_LEVEL_COMP | RIG_LEVEL_AGC | RIG_LEVEL_BKINDL \
|
||||
| RIG_LEVEL_BALANCE | RIG_LEVEL_METER | RIG_LEVEL_VOXGAIN \
|
||||
| RIG_LEVEL_VOXDELAY | RIG_LEVEL_ANTIVOX | RIG_LEVEL_SQLSTAT \
|
||||
| RIG_LEVEL_SWR | RIG_LEVEL_ALC | RIG_LEVEL_STRENGTH )
|
||||
|
||||
/* simplification macro */
|
||||
#define RIG_LEVEL_EXCLUDE(e) (RIG_LEVEL_ALL & ~(e))
|
||||
|
||||
/* more simplification macros */
|
||||
#define RIG_PARM_ALL (RIG_PARM_ANN | RIG_PARM_APO | RIG_PARM_BACKLIGHT \
|
||||
| RIG_PARM_BEEP | RIG_PARM_TIME | RIG_PARM_BAT )
|
||||
#define RIG_PARM_EXCLUDE(e) (RIG_PARM_ALL & ~(e))
|
||||
|
||||
/* For the Ham who has it all --Dale */
|
||||
#define RIG_FUNC_ALL (RIG_FUNC_FAGC | RIG_FUNC_NB | RIG_FUNC_COMP \
|
||||
| RIG_FUNC_VOX | RIG_FUNC_TONE | RIG_FUNC_TSQL \
|
||||
| RIG_FUNC_SBKIN | RIG_FUNC_FBKIN | RIG_FUNC_ANF | RIG_FUNC_NR \
|
||||
| RIG_FUNC_AIP | RIG_FUNC_APF | RIG_FUNC_MON | RIG_FUNC_MN \
|
||||
| RIG_FUNC_RNF | RIG_FUNC_ARO | RIG_FUNC_LOCK | RIG_FUNC_MUTE \
|
||||
| RIG_FUNC_VSC | RIG_FUNC_REV | RIG_FUNC_SQL | RIG_FUNC_ABM \
|
||||
| RIG_FUNC_BC | RIG_FUNC_MBC | RIG_FUNC_LMP | RIG_FUNC_AFC \
|
||||
| RIG_FUNC_SATMODE | RIG_FUNC_SCOPE | RIG_FUNC_RESUME )
|
||||
|
||||
/* Those of us who don't have everything */
|
||||
//#define RIG_FUNC_EXCLUDE(f) (RIG_FUNC_ALL & ~(f))
|
||||
|
||||
#endif /* _RIG_H */
|
||||
|
||||
|
|
|
|||
|
|
@ -6,6 +6,10 @@
|
|||
* License: GNU
|
||||
*/
|
||||
|
||||
/*
|
||||
* status: Never been compiled!
|
||||
*/
|
||||
|
||||
/*
|
||||
* Functions to initialize, read, set, and list menus
|
||||
* for the TS-2000. These functions will be added to
|
||||
|
|
|
|||
76
src/misc.c
76
src/misc.c
|
|
@ -2,7 +2,7 @@
|
|||
* Hamlib Interface - toolbox
|
||||
* Copyright (c) 2000-2002 by Stephane Fillod and Frank Singleton
|
||||
*
|
||||
* $Id: misc.c,v 1.17 2002-06-17 20:59:51 fillods Exp $
|
||||
* $Id: misc.c,v 1.18 2002-06-30 10:17:03 dedmons 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
|
||||
|
|
@ -267,10 +267,15 @@ const char * strmode(rmode_t mode)
|
|||
case RIG_MODE_FM: return "FM";
|
||||
case RIG_MODE_WFM: return "WFM";
|
||||
case RIG_MODE_NONE: return "";
|
||||
default:
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* shouldn't this use the same table as parse_vfo()?
|
||||
* It already caused me one bug. :) --Dale
|
||||
*/
|
||||
const char *strvfo(vfo_t vfo)
|
||||
{
|
||||
switch (vfo) {
|
||||
|
|
@ -292,6 +297,20 @@ const char *strvfo(vfo_t vfo)
|
|||
return "Main";
|
||||
case RIG_VFO_SUB:
|
||||
return "Sub";
|
||||
case RIG_CTRL_SAT:
|
||||
return "SAT";
|
||||
case RIG_VFO_MEM_A:
|
||||
return "MEMA";
|
||||
case RIG_VFO_MEM_C:
|
||||
return "MEMC";
|
||||
case RIG_VFO_CALL_A:
|
||||
return "CALLA";
|
||||
case RIG_VFO_CALL_C:
|
||||
return "CALLC";
|
||||
case RIG_VFO_AB:
|
||||
return "VFOAB";
|
||||
case RIG_VFO_BA:
|
||||
return "VFOBA";
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -329,6 +348,7 @@ const char *strfunc(setting_t func)
|
|||
case RIG_FUNC_RESUME: return "RESUME";
|
||||
|
||||
case RIG_FUNC_NONE: return "";
|
||||
default:
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -366,6 +386,7 @@ const char *strlevel(setting_t level)
|
|||
case RIG_LEVEL_STRENGTH: return "STRENGTH";
|
||||
|
||||
case RIG_LEVEL_NONE: return "";
|
||||
default:
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -381,6 +402,7 @@ const char *strparm(setting_t parm)
|
|||
case RIG_PARM_BAT: return "BAT";
|
||||
|
||||
case RIG_PARM_NONE: return "";
|
||||
default:
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -392,6 +414,7 @@ const char *strptrshift(rptr_shift_t shift)
|
|||
case RIG_RPT_SHIFT_PLUS: return "-";
|
||||
|
||||
case RIG_RPT_SHIFT_NONE: return "None";
|
||||
default:
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -412,18 +435,22 @@ const char *strvfop(vfo_op_t op)
|
|||
case RIG_OP_RIGHT: return "RIGHT";
|
||||
|
||||
case RIG_OP_NONE: return "";
|
||||
default:
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char *strscan(scan_t scan)
|
||||
const char *strscan(scan_t rscan)
|
||||
{
|
||||
switch (scan) {
|
||||
switch (rscan) {
|
||||
case RIG_SCAN_STOP: return "STOP";
|
||||
case RIG_SCAN_MEM: return "MEM";
|
||||
case RIG_SCAN_SLCT: return "SLCT";
|
||||
case RIG_SCAN_PRIO: return "PRIO";
|
||||
case RIG_SCAN_PROG: return "PROG";
|
||||
case RIG_SCAN_DELTA: return "DELTA";
|
||||
case RIG_SCAN_VFO: return "VFO";
|
||||
default:
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -547,16 +574,16 @@ int sprintf_vfop(char *str, vfo_op_t op)
|
|||
}
|
||||
|
||||
|
||||
int sprintf_scan(char *str, scan_t scan)
|
||||
int sprintf_scan(char *str, scan_t rscan)
|
||||
{
|
||||
int i, len=0;
|
||||
|
||||
*str = '\0';
|
||||
if (scan == RIG_SCAN_NONE)
|
||||
if (rscan == RIG_SCAN_NONE)
|
||||
return 0;
|
||||
|
||||
for (i = 0; i < 30; i++) {
|
||||
const char *ms = strscan(scan & (1UL<<i));
|
||||
const char *ms = strscan(rscan & (1UL<<i));
|
||||
if (!ms || !ms[0])
|
||||
continue; /* unknown, FIXME! */
|
||||
strcat(str, ms);
|
||||
|
|
@ -600,12 +627,20 @@ static struct {
|
|||
{ RIG_VFO_A, "VFOA" },
|
||||
{ RIG_VFO_B, "VFOB" },
|
||||
{ RIG_VFO_C, "VFOC" },
|
||||
{ RIG_VFO_CURR, "currVFO" },
|
||||
{ RIG_VFO_ALL, "allVFO" },
|
||||
{ RIG_VFO_MEM, "MEM" },
|
||||
{ RIG_VFO_VFO, "VFO" },
|
||||
{ RIG_VFO_AB, "VFOAB" },
|
||||
{ RIG_VFO_BA, "VFOBA" },
|
||||
{ RIG_VFO_MEM_A, "MEMA" },
|
||||
{ RIG_VFO_MEM_C, "MEMC" },
|
||||
{ RIG_CTRL_SAT, "SAT" },
|
||||
{ RIG_VFO_CALL_A, "CALLA" },
|
||||
{ RIG_VFO_CALL_C, "CALLC" },
|
||||
{ RIG_VFO_MAIN, "Main" },
|
||||
{ RIG_VFO_SUB, "Sub" },
|
||||
// one or more of the following may be ambiguous --Dale
|
||||
{ RIG_VFO_CURR, "currVFO" },
|
||||
{ RIG_VFO_VFO, "VFO" },
|
||||
{ RIG_VFO_MEM, "MEM" },
|
||||
// { RIG_VFO_ALL, "allVFO" },
|
||||
{ RIG_VFO_NONE, NULL },
|
||||
};
|
||||
|
||||
|
|
@ -761,14 +796,16 @@ vfo_op_t parse_vfo_op(const char *s)
|
|||
}
|
||||
|
||||
static struct {
|
||||
scan_t scan;
|
||||
scan_t SCan;
|
||||
const char *str;
|
||||
} scan_str[] = {
|
||||
{ RIG_SCAN_STOP, "STOP" },
|
||||
{ RIG_SCAN_MEM, "MEM" },
|
||||
{ RIG_SCAN_SLCT, "SLCT" },
|
||||
{ RIG_SCAN_PRIO, "PRIO" },
|
||||
{ RIG_SCAN_PROG, "PROG" },
|
||||
{ RIG_SCAN_DELTA, "DELTA" },
|
||||
{ RIG_SCAN_VFO, "VFO" },
|
||||
{ RIG_SCAN_NONE, NULL },
|
||||
};
|
||||
|
||||
|
|
@ -776,18 +813,25 @@ scan_t parse_scan(const char *s)
|
|||
{
|
||||
int i;
|
||||
|
||||
for (i=0 ; scan_str[i].str != NULL; i++)
|
||||
if (!strcmp(s, scan_str[i].str))
|
||||
return scan_str[i].scan;
|
||||
printf(__FUNCTION__": parsing %s...\n",s);
|
||||
|
||||
for (i=0 ; scan_str[i].str != NULL; i++) {
|
||||
if (strcmp(s, scan_str[i].str) == 0) {
|
||||
return scan_str[i].SCan;
|
||||
}
|
||||
}
|
||||
|
||||
return RIG_SCAN_NONE;
|
||||
}
|
||||
|
||||
rptr_shift_t parse_rptr_shift(const char *s)
|
||||
{
|
||||
if (!strcmp(s, "+"))
|
||||
if (strcmp(s, "+") == 0)
|
||||
return RIG_RPT_SHIFT_PLUS;
|
||||
else if (!strcmp(s, "-"))
|
||||
else if (strcmp(s, "-") == 0)
|
||||
return RIG_RPT_SHIFT_MINUS;
|
||||
else if (strcmp(s, "=") == 0)
|
||||
return RIG_RPT_SHIFT_1750;
|
||||
else
|
||||
return RIG_RPT_SHIFT_NONE;
|
||||
}
|
||||
|
|
|
|||
Ładowanie…
Reference in New Issue