2007-11-22 04:48:43 +00:00
/*
* hamlib - ( C ) Frank Singleton 2000 ( javabear at users . sourceforge . net )
* and the Hamlib Group ( hamlib - developer at lists . sourceforge . net )
*
* newcat . c - ( C ) Nate Bargmann 2007 ( n0nb at arrl . net )
2010-10-06 07:25:14 +00:00
* ( C ) Stephane Fillod 2008 - 2010
2010-01-04 23:52:43 +00:00
* ( C ) Terry Embry 2008 - 2010
2015-04-04 16:55:20 +00:00
* ( C ) David Fannin ( kk6df at arrl . net )
2007-11-22 04:48:43 +00:00
*
* This shared library provides an API for communicating
* via serial interface to any newer Yaesu radio using the
* " new " text CAT interface .
*
2011-08-23 02:26:44 +00:00
* This library is free software ; you can redistribute it and / or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
* version 2.1 of the License , or ( at your option ) any later version .
*
* This library is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU
* Lesser General Public License for more details .
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library ; if not , write to the Free Software
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
2007-11-22 04:48:43 +00:00
*
*/
# ifdef HAVE_CONFIG_H
# include "config.h"
# endif
# include <stdlib.h>
# include <string.h> /* String function definitions */
2020-10-23 09:32:10 +00:00
# include <math.h>
2007-11-22 04:48:43 +00:00
# include "hamlib/rig.h"
# include "iofunc.h"
2015-12-04 00:04:51 +00:00
# include "misc.h"
2020-07-29 21:03:54 +00:00
# include "cal.h"
2007-11-22 04:48:43 +00:00
# include "newcat.h"
/* global variables */
2009-01-10 14:52:49 +00:00
static const char cat_term = ' ; ' ; /* Yaesu command terminator */
2016-02-06 06:48:54 +00:00
// static const char cat_unknown_cmd[] = "?;"; /* Yaesu ? */
2007-11-22 04:48:43 +00:00
2009-01-05 23:03:15 +00:00
/* Internal Backup and Restore VFO Memory Channels */
# define NC_MEM_CHANNEL_NONE 2012
# define NC_MEM_CHANNEL_VFO_A 2013
2009-01-10 14:52:49 +00:00
# define NC_MEM_CHANNEL_VFO_B 2014
2009-01-04 00:05:25 +00:00
2008-12-31 18:17:56 +00:00
/* ID 0310 == 310, Must drop leading zero */
2019-11-30 16:19:08 +00:00
typedef enum nc_rigid_e
{
2009-01-07 00:50:53 +00:00
NC_RIGID_NONE = 0 ,
NC_RIGID_FT450 = 241 ,
2018-08-09 21:19:24 +00:00
NC_RIGID_FT450D = 244 ,
2009-01-07 00:50:53 +00:00
NC_RIGID_FT950 = 310 ,
2017-06-27 15:48:44 +00:00
NC_RIGID_FT891 = 135 ,
2015-07-06 04:44:21 +00:00
NC_RIGID_FT991 = 135 ,
2009-01-07 00:50:53 +00:00
NC_RIGID_FT2000 = 251 ,
2009-04-30 22:38:47 +00:00
NC_RIGID_FT2000D = 252 ,
2020-10-26 08:06:38 +00:00
NC_RIGID_FTDX1200 = 583 ,
2009-01-07 00:50:53 +00:00
NC_RIGID_FTDX9000D = 101 ,
NC_RIGID_FTDX9000Contest = 102 ,
2010-10-06 07:25:14 +00:00
NC_RIGID_FTDX9000MP = 103 ,
2018-11-20 16:48:08 +00:00
NC_RIGID_FTDX5000 = 362 ,
2019-10-10 17:16:07 +00:00
NC_RIGID_FTDX3000 = 460 ,
NC_RIGID_FTDX101D = 681 ,
NC_RIGID_FTDX101MP = 682
2008-12-30 18:52:32 +00:00
} nc_rigid_t ;
2008-12-28 13:53:13 +00:00
2008-09-22 21:34:45 +00:00
/*
* The following table defines which commands are valid for any given
* rig supporting the " new " CAT interface .
*/
2019-11-30 16:19:08 +00:00
typedef struct _yaesu_newcat_commands
{
2008-09-22 21:34:45 +00:00
char * command ;
ncboolean ft450 ;
ncboolean ft950 ;
2017-06-27 15:48:44 +00:00
ncboolean ft891 ;
2015-07-06 04:44:21 +00:00
ncboolean ft991 ;
2008-09-22 21:34:45 +00:00
ncboolean ft2000 ;
ncboolean ft9000 ;
2010-10-06 07:25:14 +00:00
ncboolean ft5000 ;
2015-04-04 16:55:20 +00:00
ncboolean ft1200 ;
2018-11-20 16:48:08 +00:00
ncboolean ft3000 ;
2019-10-10 17:16:07 +00:00
ncboolean ft101 ;
2020-12-28 21:17:49 +00:00
ncboolean ft10 ;
2008-09-22 21:34:45 +00:00
} yaesu_newcat_commands_t ;
2020-10-23 09:32:10 +00:00
/**
* Yaesu FT - 991 S - meter scale , default for new Yaesu rigs .
* Determined by data from W6HN - - seems to be pretty linear
*
* SMeter , rig answer , % fullscale
* S0 SM0000 0
* S2 SM0026 10
* S4 SM0051 20
* S6 SM0081 30
* S7 .5 SM0105 40
* S9 SM0130 50
* + 12 db SM0157 60
* + 25 db SM0186 70
* + 35 db SM0203 80
* + 50 db SM0237 90
* + 60 db SM0255 100
*
* 114 dB range over 0 - 255 referenced to S0 of - 54 dB
*/
const cal_table_t yaesu_default_str_cal =
{
2020-10-23 09:33:42 +00:00
11 ,
2020-10-23 09:32:10 +00:00
{
{ 0 , - 54 , } , // S0
{ 26 , - 42 , } , // S2
{ 51 , - 30 , } , // S4
{ 81 , - 18 , } , // S6
{ 105 , - 9 , } , // S7.5
{ 130 , 0 , } , // S9
{ 157 , 12 , } , // S9+12dB
{ 186 , 25 , } , // S9+25dB
{ 203 , 35 , } , // S9+35dB
{ 237 , 50 , } , // S9+50dB
{ 255 , 60 , } , // S9+60dB
}
} ;
2020-10-24 07:55:11 +00:00
/**
* First cut at generic Yaesu table , need more points probably
* based on testing by Adam M7OTP on FT - 991
*/
2020-07-29 21:03:54 +00:00
const cal_table_float_t yaesu_default_swr_cal =
{
2020-10-04 22:14:29 +00:00
5 ,
2020-08-28 17:16:17 +00:00
{
2020-07-29 21:03:54 +00:00
{ 12 , 1.0f } ,
{ 39 , 1.35f } ,
2020-10-04 22:14:29 +00:00
{ 65 , 1.5f } ,
2020-07-29 21:03:54 +00:00
{ 89 , 2.0f } ,
{ 242 , 5.0f }
}
} ;
2020-10-24 07:55:11 +00:00
// TODO: Provide sane defaults
2020-10-23 08:24:09 +00:00
const cal_table_float_t yaesu_default_alc_cal =
{
3 ,
{
{ 0 , 0.0f } ,
{ 128 , 1.0f } ,
{ 255 , 2.0f } ,
}
} ;
2020-10-24 07:55:11 +00:00
// TODO: Provide sane defaults
2020-10-23 08:24:09 +00:00
const cal_table_float_t yaesu_default_comp_meter_cal =
{
2 ,
{
{ 0 , 0.0f } ,
2020-12-12 14:24:33 +00:00
{ 255 , 100.0f } ,
2020-10-23 08:24:09 +00:00
}
} ;
2020-10-24 07:55:11 +00:00
// TODO: Provide sane defaults
2020-10-23 08:24:09 +00:00
const cal_table_float_t yaesu_default_rfpower_meter_cal =
{
2020-12-16 23:47:49 +00:00
3 ,
2020-10-23 08:24:09 +00:00
{
{ 0 , 0.0f } ,
2020-12-16 23:47:49 +00:00
{ 148 , 50.0f } ,
{ 255 , 100.0f } ,
2020-10-23 08:24:09 +00:00
}
} ;
2020-10-24 07:55:11 +00:00
// TODO: Provide sane defaults
2020-10-23 08:24:09 +00:00
const cal_table_float_t yaesu_default_vd_meter_cal =
{
2 ,
{
{ 0 , 0.0f } ,
{ 255 , 1.0f } ,
}
} ;
2020-10-24 07:55:11 +00:00
// TODO: Provide sane defaults
2020-10-23 08:24:09 +00:00
const cal_table_float_t yaesu_default_id_meter_cal =
{
2 ,
{
{ 0 , 0.0f } ,
{ 255 , 1.0f } ,
}
} ;
2020-05-26 16:53:47 +00:00
// Easy reference to rig model -- it is set in newcat_valid_command
static ncboolean is_ft450 ;
static ncboolean is_ft891 ;
static ncboolean is_ft950 ;
static ncboolean is_ft991 ;
static ncboolean is_ft2000 ;
2020-11-05 09:05:37 +00:00
static ncboolean is_ftdx9000 ;
2020-10-26 08:06:38 +00:00
static ncboolean is_ftdx5000 ;
static ncboolean is_ftdx1200 ;
static ncboolean is_ftdx3000 ;
static ncboolean is_ftdx101 ;
2020-12-28 21:17:49 +00:00
static ncboolean is_ftdx10 ;
2020-05-26 16:53:47 +00:00
2011-07-09 03:27:06 +00:00
/*
2010-01-04 23:52:43 +00:00
* Even thought this table does make a handy reference , it could be depreciated as it is not really needed .
2010-10-06 07:25:14 +00:00
* All of the CAT commands used in the newcat interface are available on the FT - 950 , FT - 2000 , FT - 5000 , and FT - 9000.
2010-01-04 23:52:43 +00:00
* There are 5 CAT commands used in the newcat interface that are not available on the FT - 450.
* Thesec CAT commands are XT - TX Clarifier ON / OFF , AN - Antenna select , PL - Speech Proc Level ,
* PR - Speech Proc ON / OFF , and BC - Auto Notch filter ON / OFF .
* The FT - 450 returns - RIG_ENVAIL for these unavailable CAT commands .
*
2008-09-22 21:34:45 +00:00
* NOTE : The following table must be in alphabetical order by the
* command . This is because it is searched using a binary search
* to determine whether or not a command is valid for a given rig .
*
* The list of supported commands is obtained from the rig ' s operator ' s
* or CAT programming manual .
*
*/
2019-11-30 16:19:08 +00:00
static const yaesu_newcat_commands_t valid_commands [ ] =
{
2020-12-28 21:17:49 +00:00
/* Command FT-450 FT-950 FT-891 FT-991 FT-2000 FT-9000 FT-5000 FT-1200 FT-3000 FTDX101D FTDX10 */
{ " AB " , FALSE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " AC " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " AG " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " AI " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " AM " , FALSE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " AN " , FALSE , TRUE , FALSE , FALSE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , FALSE } ,
{ " AO " , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , TRUE , TRUE } ,
{ " BA " , FALSE , FALSE , TRUE , TRUE , FALSE , FALSE , FALSE , TRUE , TRUE , TRUE , TRUE } ,
{ " BC " , FALSE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " BD " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " BI " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " BM " , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , TRUE , TRUE } ,
{ " BP " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " BS " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " BU " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " BY " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " CH " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " CN " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " CO " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " CS " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " CT " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " DA " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " DN " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " DT " , FALSE , FALSE , TRUE , TRUE , FALSE , FALSE , FALSE , TRUE , FALSE , TRUE , TRUE } ,
{ " DP " , FALSE , TRUE , FALSE , FALSE , TRUE , TRUE , TRUE , FALSE , FALSE , FALSE , FALSE } ,
{ " DS " , TRUE , FALSE , FALSE , FALSE , TRUE , TRUE , TRUE , FALSE , FALSE , FALSE , FALSE } ,
{ " ED " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " EK " , FALSE , TRUE , TRUE , TRUE , TRUE , TRUE , FALSE , TRUE , TRUE , FALSE , FALSE } ,
{ " EM " , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , TRUE , TRUE } ,
{ " EN " , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , TRUE , TRUE , TRUE , TRUE } ,
{ " EU " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " EX " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " FA " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " FB " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " FK " , FALSE , TRUE , FALSE , FALSE , TRUE , TRUE , FALSE , FALSE , FALSE , FALSE , FALSE } ,
{ " FN " , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , TRUE , TRUE } ,
{ " FR " , FALSE , TRUE , FALSE , FALSE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " FS " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " FT " , TRUE , TRUE , FALSE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " GT " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " ID " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " IF " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " IS " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " KM " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " KP " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " KR " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " KS " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " KY " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " LK " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " LM " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " MA " , FALSE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " MB " , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , TRUE , TRUE } ,
{ " MC " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " MD " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " MG " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " MK " , TRUE , TRUE , FALSE , FALSE , TRUE , TRUE , TRUE , FALSE , FALSE , FALSE , FALSE } ,
{ " ML " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " MR " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " MS " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " MT " , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , TRUE , TRUE } ,
{ " MW " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " MX " , FALSE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " NA " , TRUE , TRUE , TRUE , TRUE , TRUE , FALSE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " NB " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " NL " , FALSE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " NR " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " OI " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " OS " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " PA " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " PB " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " PC " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " PL " , FALSE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " PR " , FALSE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " PS " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " QI " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " QR " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " QS " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " RA " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " RC " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " RD " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " RF " , FALSE , TRUE , FALSE , FALSE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " RG " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " RI " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " RL " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " RM " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " RO " , FALSE , TRUE , FALSE , FALSE , TRUE , TRUE , TRUE , TRUE , TRUE , FALSE , FALSE } ,
{ " RP " , TRUE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE } ,
{ " RS " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " RT " , TRUE , TRUE , FALSE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " RU " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " SC " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " SD " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " SF " , FALSE , TRUE , FALSE , FALSE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " SH " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " SM " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " SQ " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " SS " , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , TRUE , TRUE } ,
2020-06-10 21:25:19 +00:00
// ST command has two meanings Step or Split Status
// If new rig is added that has ST ensure it means Split
// Otherwise modify newcat_get_tx_vfo
2020-12-28 21:17:49 +00:00
{ " ST " , TRUE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , TRUE , TRUE } ,
{ " SV " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " SY " , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , TRUE , FALSE } ,
{ " TS " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " TX " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " UL " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " UP " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " VD " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " VF " , FALSE , TRUE , FALSE , FALSE , TRUE , TRUE , TRUE , TRUE , TRUE , FALSE , FALSE } ,
{ " VG " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " VM " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " VR " , TRUE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE } ,
{ " VS " , TRUE , TRUE , FALSE , FALSE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " VT " , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , TRUE , FALSE } ,
{ " VV " , TRUE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE , FALSE } ,
{ " VX " , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " XT " , FALSE , TRUE , FALSE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE , TRUE } ,
{ " ZI " , FALSE , FALSE , TRUE , TRUE , FALSE , FALSE , FALSE , FALSE , FALSE , TRUE , TRUE } ,
2008-09-22 21:34:45 +00:00
} ;
2020-12-28 21:17:49 +00:00
2021-01-04 18:09:28 +00:00
int valid_commands_count = sizeof ( valid_commands ) / sizeof (
2021-01-16 15:31:15 +00:00
yaesu_newcat_commands_t ) ;
2021-01-16 14:50:54 +00:00
2019-11-30 16:19:08 +00:00
/*
* configuration Tokens
*
*/
2016-06-05 21:46:55 +00:00
# define TOK_FAST_SET_CMD TOKEN_BACKEND(1)
2019-11-30 16:19:08 +00:00
const struct confparams newcat_cfg_params [ ] =
{
{
Fix spelling errors
Fixed using the following command:
codespell --write-changes --summary --skip=*.m4 --ignore-words-list="develope,get's,quitt,setts,som,ue,vektor"
codespell --write-changes --summary --skip=aclocal.m4,lib --ignore-words-list="develope,get's,quitt,setts,som,ue,vektor"
Codespell home page: https://github.com/codespell-project/codespell
2020-07-24 07:02:12 +00:00
TOK_FAST_SET_CMD , " fast_commands_token " , " High throughput of commands " , " Enabled high throughput of >200 messages/sec by not waiting for ACK/NAK of messages " , " 0 " , RIG_CONF_NUMERIC , { . n = { 0 , 1 , 1 } }
2019-11-30 16:19:08 +00:00
} ,
{ RIG_CONF_END , NULL , }
2016-06-05 21:46:55 +00:00
} ;
2008-12-06 02:37:45 +00:00
/* NewCAT Internal Functions */
2019-11-30 16:19:08 +00:00
static ncboolean newcat_is_rig ( RIG * rig , rig_model_t model ) ;
2010-01-04 23:52:43 +00:00
2019-11-30 16:19:08 +00:00
static int newcat_set_vfo_from_alias ( RIG * rig , vfo_t * vfo ) ;
2008-12-14 20:05:21 +00:00
static int newcat_scale_float ( int scale , float fval ) ;
2019-11-30 16:19:08 +00:00
static int newcat_get_rx_bandwidth ( RIG * rig , vfo_t vfo , rmode_t mode ,
pbwidth_t * width ) ;
static int newcat_set_rx_bandwidth ( RIG * rig , vfo_t vfo , rmode_t mode ,
pbwidth_t width ) ;
static int newcat_set_narrow ( RIG * rig , vfo_t vfo , ncboolean narrow ) ;
static int newcat_get_narrow ( RIG * rig , vfo_t vfo , ncboolean * narrow ) ;
static int newcat_set_faststep ( RIG * rig , ncboolean fast_step ) ;
static int newcat_get_faststep ( RIG * rig , ncboolean * fast_step ) ;
static int newcat_get_rigid ( RIG * rig ) ;
static int newcat_get_vfo_mode ( RIG * rig , vfo_t * vfo_mode ) ;
static int newcat_vfomem_toggle ( RIG * rig ) ;
2020-10-25 16:06:13 +00:00
static int set_roofing_filter ( RIG * rig , vfo_t vfo , int index ) ;
static int set_roofing_filter_for_width ( RIG * rig , vfo_t vfo , int width ) ;
2020-10-28 13:45:53 +00:00
static int get_roofing_filter ( RIG * rig , vfo_t vfo ,
struct newcat_roofing_filter * * roofing_filter ) ;
2019-11-30 16:19:08 +00:00
static ncboolean newcat_valid_command ( RIG * rig , char const * const command ) ;
2010-01-04 23:52:43 +00:00
2020-10-25 13:03:45 +00:00
/*
* The BS command needs to know what band we ' re on so we can restore band info
* So this converts freq to band index
*/
static int newcat_band_index ( freq_t freq )
{
int band = 11 ; // general
2020-11-03 17:10:40 +00:00
// restrict band memory recall to ITU 1,2,3 band ranges
// using < instead of <= for the moment
// does anybody work LSB or RTTYR at the upper band edge?
// what about band 13 -- what is it?
2020-10-29 15:24:25 +00:00
if ( freq > = MHz ( 420 ) & & freq < MHz ( 470 ) ) { band = 16 ; }
2020-12-19 05:57:38 +00:00
else if ( freq > = MHz ( 144 ) & & freq < MHz ( 148 ) ) { band = 15 ; }
2020-11-03 17:10:40 +00:00
// band 14 is RX only
2020-12-19 05:57:38 +00:00
// override band 15 with 14 if needed
2020-10-29 15:24:25 +00:00
else if ( freq > = MHz ( 118 ) & & freq < MHz ( 164 ) ) { band = 14 ; }
2020-11-03 17:10:40 +00:00
else if ( freq > = MHz ( 70 ) & & freq < MHz ( 70.5 ) ) { band = 17 ; }
else if ( freq > = MHz ( 50 ) & & freq < MHz ( 55 ) ) { band = 10 ; }
else if ( freq > = MHz ( 28 ) & & freq < MHz ( 29.7 ) ) { band = 9 ; }
else if ( freq > = MHz ( 24.890 ) & & freq < MHz ( 24.990 ) ) { band = 8 ; }
else if ( freq > = MHz ( 21 ) & & freq < MHz ( 21.45 ) ) { band = 7 ; }
else if ( freq > = MHz ( 18 ) & & freq < MHz ( 18.168 ) ) { band = 6 ; }
else if ( freq > = MHz ( 14 ) & & freq < MHz ( 14.35 ) ) { band = 5 ; }
else if ( freq > = MHz ( 10 ) & & freq < MHz ( 10.15 ) ) { band = 4 ; }
else if ( freq > = MHz ( 7 ) & & freq < MHz ( 7.3 ) ) { band = 3 ; }
else if ( freq > = MHz ( 5.3515 ) & & freq < MHz ( 5.3665 ) ) { band = 2 ; }
else if ( freq > = MHz ( 3.5 ) & & freq < MHz ( 4 ) ) { band = 1 ; }
else if ( freq > = MHz ( 1.8 ) & & freq < MHz ( 2 ) ) { band = 0 ; }
else if ( freq > = MHz ( 0.5 ) & & freq < MHz ( 1.705 ) ) { band = 12 ; } // MW Medium Wave
2020-10-29 15:24:25 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: freq=%g, band=%d \n " , __func__ , freq , band ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( band ) ;
2020-10-25 13:03:45 +00:00
}
2007-11-22 04:48:43 +00:00
/*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* Hamlib API functions
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
/*
* rig_init
*
*/
2019-11-30 16:19:08 +00:00
int newcat_init ( RIG * rig )
{
2007-11-22 04:48:43 +00:00
struct newcat_priv_data * priv ;
2008-12-10 23:53:56 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2007-11-22 04:48:43 +00:00
2020-02-23 17:26:09 +00:00
rig - > state . priv = ( struct newcat_priv_data * ) calloc ( 1 ,
sizeof ( struct newcat_priv_data ) ) ;
2019-11-30 16:19:08 +00:00
2020-01-13 18:48:30 +00:00
if ( ! rig - > state . priv ) /* whoops! memory shortage! */
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENOMEM ) ;
2019-11-30 16:19:08 +00:00
}
2008-12-10 23:53:56 +00:00
2020-01-13 18:48:30 +00:00
priv = rig - > state . priv ;
2007-11-22 04:48:43 +00:00
/* TODO: read pacing from preferences */
2009-01-07 00:50:53 +00:00
// priv->pacing = NEWCAT_PACING_DEFAULT_VALUE; /* set pacing to minimum for now */
2019-11-30 16:19:08 +00:00
priv - > read_update_delay =
NEWCAT_DEFAULT_READ_TIMEOUT ; /* set update timeout to safe value */
2008-12-10 23:53:56 +00:00
2009-01-07 00:50:53 +00:00
// priv->current_vfo = RIG_VFO_MAIN; /* default to whatever */
2011-07-09 03:27:06 +00:00
// priv->current_vfo = RIG_VFO_A;
2009-01-07 00:50:53 +00:00
2009-01-04 00:05:25 +00:00
priv - > rig_id = NC_RIGID_NONE ;
2009-01-05 23:03:15 +00:00
priv - > current_mem = NC_MEM_CHANNEL_NONE ;
2016-06-05 14:26:21 +00:00
priv - > fast_set_commands = FALSE ;
2008-12-10 23:53:56 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2007-11-22 04:48:43 +00:00
}
/*
* rig_cleanup
*
* the serial port is closed by the frontend
*
*/
2019-11-30 16:19:08 +00:00
int newcat_cleanup ( RIG * rig )
{
2007-11-22 04:48:43 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2007-11-22 04:48:43 +00:00
if ( rig - > state . priv )
2019-11-30 16:19:08 +00:00
{
2007-11-22 04:48:43 +00:00
free ( rig - > state . priv ) ;
2019-11-30 16:19:08 +00:00
}
2007-11-22 04:48:43 +00:00
rig - > state . priv = NULL ;
2009-01-07 00:50:53 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2007-11-22 04:48:43 +00:00
}
/*
* rig_open
*
* New CAT does not support pacing
*
*/
2019-11-30 16:19:08 +00:00
int newcat_open ( RIG * rig )
{
struct newcat_priv_data * priv = rig - > state . priv ;
struct rig_state * rig_s = & rig - > state ;
2007-11-22 04:48:43 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-12-09 23:12:13 +00:00
2007-11-22 04:48:43 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: write_delay = %i msec \n " ,
2019-11-30 16:19:08 +00:00
__func__ , rig_s - > rigport . write_delay ) ;
2007-11-22 04:48:43 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: post_write_delay = %i msec \n " ,
2019-11-30 16:19:08 +00:00
__func__ , rig_s - > rigport . post_write_delay ) ;
2007-11-22 04:48:43 +00:00
2019-12-23 04:23:57 +00:00
/* Ensure rig is powered on */
2020-07-04 22:23:39 +00:00
if ( priv - > poweron = = 0 & & rig_s - > auto_power_on )
2020-06-21 19:46:50 +00:00
{
2020-06-14 22:14:24 +00:00
rig_set_powerstat ( rig , 1 ) ;
2020-07-04 16:26:54 +00:00
priv - > poweron = 1 ;
2020-06-14 22:14:24 +00:00
}
2019-12-23 04:23:57 +00:00
2020-10-25 16:06:13 +00:00
priv - > question_mark_response_means_rejected = 0 ;
2015-11-29 18:26:39 +00:00
/* get current AI state so it can be restored */
priv - > trn_state = - 1 ;
2019-11-30 16:19:08 +00:00
newcat_get_trn ( rig , & priv - > trn_state ) ; /* ignore errors */
2014-10-13 01:03:53 +00:00
/* Currently we cannot cope with AI mode so turn it off in case
last client left it on */
2020-10-25 22:29:11 +00:00
if ( priv - > trn_state > 0 )
2020-10-25 21:23:30 +00:00
{
newcat_set_trn ( rig , RIG_TRN_OFF ) ;
} /* ignore status in case it's not supported */
2019-11-30 16:19:08 +00:00
2018-08-09 21:38:02 +00:00
/* Initialize rig_id in case any subsequent commands need it */
( void ) newcat_get_rigid ( rig ) ;
2021-01-04 16:44:25 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s: rig_id=%d \n " , __func__ , priv - > rig_id ) ;
2020-12-16 13:46:39 +00:00
2021-01-13 14:48:48 +00:00
#if 0 // possible future enhancement?
2021-01-15 22:48:32 +00:00
2021-01-13 14:48:48 +00:00
// some rigs have a CAT TOT timeout that defaults to 10ms
// so we'll increase CAT timeout to 100ms
2021-01-15 22:48:32 +00:00
if ( priv - > rig_id = = NC_RIGID_FT2000
2021-01-13 14:48:48 +00:00
| | priv - > rig_id = = NC_RIGID_FT2000D
| | priv - > rig_id = = NC_RIGID_FT891
| | priv - > rig_id = = NC_RIGID_FT991
| | priv - > rig_id = = NC_RIGID_FT950 )
{
int err ;
char * cmd = " EX0291%c " ;
2021-01-15 22:48:32 +00:00
if ( priv - > rig_id = = NC_RIGID_FT950 ) { cmd = " EX0271%c " ; }
else if ( priv - > rig_id = = NC_RIGID_FT891 ) { cmd = " EX05071c " ; }
else if ( priv - > rig_id = = NC_RIGID_FT991 ) { cmd = " EX0321c " ; }
2021-01-13 14:48:48 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , cmd , cat_term ) ;
if ( RIG_OK ! = ( err = newcat_set_cmd ( rig ) ) )
{
return err ;
}
}
2021-01-15 22:48:32 +00:00
2021-01-13 14:48:48 +00:00
# endif
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2007-11-22 04:48:43 +00:00
}
/*
* rig_close
2008-12-10 23:53:56 +00:00
*
2007-11-22 04:48:43 +00:00
*/
2019-11-30 16:19:08 +00:00
int newcat_close ( RIG * rig )
{
2007-11-22 04:48:43 +00:00
2019-11-30 16:19:08 +00:00
struct newcat_priv_data * priv = rig - > state . priv ;
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-12-09 23:12:13 +00:00
2015-12-04 00:04:51 +00:00
if ( ! no_restore_ai & & priv - > trn_state > = 0 )
2019-11-30 16:19:08 +00:00
{
2015-11-29 18:26:39 +00:00
/* restore AI state */
2019-11-30 16:19:08 +00:00
newcat_set_trn ( rig , priv - > trn_state ) ; /* ignore status in
2015-11-29 18:26:39 +00:00
case it ' s not
supported */
2019-11-30 16:19:08 +00:00
}
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2007-11-22 04:48:43 +00:00
}
2016-06-05 21:46:55 +00:00
/*
* rig_set_config
*
2016-06-10 20:58:14 +00:00
* Set Configuration Token for Yaesu Radios
2016-06-05 21:46:55 +00:00
*/
2019-11-30 16:19:08 +00:00
int newcat_set_conf ( RIG * rig , token_t token , const char * val )
{
2016-06-05 21:46:55 +00:00
int ret = RIG_OK ;
struct newcat_priv_data * priv ;
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2016-06-05 21:46:55 +00:00
2019-11-30 16:19:08 +00:00
if ( priv = = NULL )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINTERNAL ) ;
2016-06-05 21:46:55 +00:00
}
2019-11-30 16:19:08 +00:00
switch ( token )
{
char * end ;
long value ;
2019-12-20 22:49:17 +00:00
2019-12-09 23:12:13 +00:00
case TOK_FAST_SET_CMD : ;
2019-11-30 16:19:08 +00:00
//using strtol because atoi can lead to undefined behaviour
value = strtol ( val , & end , 10 ) ;
if ( end = = val )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2019-11-30 16:19:08 +00:00
}
if ( ( value = = 0 ) | | ( value = = 1 ) )
{
priv - > fast_set_commands = ( int ) value ;
}
else
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2019-11-30 16:19:08 +00:00
}
2016-06-05 21:46:55 +00:00
break ;
2016-06-05 14:26:21 +00:00
2016-06-05 21:46:55 +00:00
default :
2019-11-30 16:19:08 +00:00
ret = - RIG_EINVAL ;
2016-06-05 14:26:21 +00:00
}
2021-01-17 13:25:28 +00:00
RETURNFUNC ( ret ) ;
2016-06-05 14:26:21 +00:00
}
2016-06-05 21:46:55 +00:00
/*
* rig_get_config
*
2016-06-10 20:58:14 +00:00
* Get Configuration Token for Yaesu Radios
2016-06-05 21:46:55 +00:00
*/
2019-11-30 16:19:08 +00:00
int newcat_get_conf ( RIG * rig , token_t token , char * val )
{
2016-06-05 14:26:21 +00:00
int ret = RIG_OK ;
2016-06-05 21:46:55 +00:00
struct newcat_priv_data * priv ;
2016-06-05 14:26:21 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2016-06-05 21:46:55 +00:00
2019-11-30 16:19:08 +00:00
if ( priv = = NULL )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINTERNAL ) ;
2016-06-05 14:26:21 +00:00
}
2019-11-30 16:19:08 +00:00
switch ( token )
{
2016-06-05 14:26:21 +00:00
case TOK_FAST_SET_CMD :
2019-11-30 16:19:08 +00:00
if ( sizeof ( val ) < 2 )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENOMEM ) ;
2019-11-30 16:19:08 +00:00
}
2016-06-05 21:46:55 +00:00
sprintf ( val , " %d " , priv - > fast_set_commands ) ;
2016-06-05 14:26:21 +00:00
break ;
2019-11-30 16:19:08 +00:00
2016-06-05 14:26:21 +00:00
default :
ret = - RIG_EINVAL ;
}
2021-01-17 13:25:28 +00:00
RETURNFUNC ( ret ) ;
2016-06-05 14:26:21 +00:00
}
2007-11-22 04:48:43 +00:00
/*
* rig_set_freq
*
* Set frequency for a given VFO
2008-12-10 23:53:56 +00:00
* RIG_TARGETABLE_VFO
* Does not SET priv - > current_vfo
2007-11-22 04:48:43 +00:00
*
*/
2019-11-30 16:19:08 +00:00
int newcat_set_freq ( RIG * rig , vfo_t vfo , freq_t freq )
{
2007-11-22 04:48:43 +00:00
char c ;
2019-12-09 23:12:13 +00:00
char target_vfo ;
2008-10-25 14:37:19 +00:00
int err ;
2019-12-09 23:12:13 +00:00
const struct rig_caps * caps ;
struct newcat_priv_data * priv ;
int special_60m = 0 ;
2007-11-22 04:48:43 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2007-11-22 04:48:43 +00:00
2009-01-07 00:50:53 +00:00
if ( ! newcat_valid_command ( rig , " FA " ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 00:50:53 +00:00
2020-04-20 04:18:59 +00:00
if ( ! newcat_valid_command ( rig , " FB " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2020-04-20 04:18:59 +00:00
}
2007-11-22 04:48:43 +00:00
priv = ( struct newcat_priv_data * ) rig - > state . priv ;
caps = rig - > caps ;
2017-06-27 15:48:44 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: passed vfo = %s \n " , __func__ , rig_strvfo ( vfo ) ) ;
// rig_debug(RIG_DEBUG_TRACE, "%s: translated vfo = %s\n", __func__, rig_strvfo(tvfo));
2007-11-22 04:48:43 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: passed freq = % " PRIfreq " Hz \n " , __func__ , freq ) ;
2008-12-10 23:53:56 +00:00
err = newcat_set_vfo_from_alias ( rig , & vfo ) ;
2019-11-30 16:19:08 +00:00
2008-12-10 23:53:56 +00:00
if ( err < 0 )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
ERRMSG ( err , " newcat_set_vfo_from_alias " ) ;
2008-12-10 23:53:56 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2007-11-22 04:48:43 +00:00
2011-07-09 03:27:06 +00:00
/* vfo should now be modified to a valid VFO constant. */
2019-05-15 17:35:23 +00:00
/* DX3000/DX5000 can only do VFO_MEM on 60M */
/* So we will not change freq in that case */
special_60m = newcat_is_rig ( rig , RIG_MODEL_FTDX3000 ) ;
/* duplicate the following line to add more rigs */
special_60m | = newcat_is_rig ( rig , RIG_MODEL_FTDX5000 ) ;
2019-11-30 16:19:08 +00:00
switch ( vfo )
{
case RIG_VFO_A :
2020-10-06 20:50:37 +00:00
case RIG_VFO_MAIN :
2019-11-30 16:19:08 +00:00
c = ' A ' ;
break ;
case RIG_VFO_B :
2020-10-06 20:50:37 +00:00
case RIG_VFO_SUB :
2019-11-30 16:19:08 +00:00
c = ' B ' ;
break ;
case RIG_VFO_MEM :
if ( special_60m & & ( freq > = 5300000 & & freq < = 5410000 ) )
{
rig_debug ( RIG_DEBUG_TRACE , " %s: 60M VFO_MEM exception, no freq change done \n " ,
__func__ ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ; /* make it look like we changed */
2019-11-30 16:19:08 +00:00
}
c = ' A ' ;
break ;
default :
return - RIG_ENIMPL ; /* Only VFO_A or VFO_B are valid */
2007-11-22 04:48:43 +00:00
}
2019-12-09 23:12:13 +00:00
target_vfo = ' A ' = = c ? ' 0 ' : ' 1 ' ;
2019-11-30 16:19:08 +00:00
2015-03-15 15:33:47 +00:00
if ( RIG_MODEL_FT450 = = caps - > rig_model )
2019-11-30 16:19:08 +00:00
{
2015-03-15 15:33:47 +00:00
/* The FT450 only accepts F[A|B]nnnnnnnn; commands for the
current VFO so we must use the VS [ 0 | 1 ] ; command to check
and select the correct VFO before setting the frequency
*/
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " VS%c " , cat_term ) ;
2019-11-30 16:19:08 +00:00
if ( RIG_OK ! = ( err = newcat_get_cmd ( rig ) ) )
{
2021-01-17 13:25:28 +00:00
ERRMSG ( err , " newcat_get_cmd " ) ;
2015-03-15 15:33:47 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2015-03-15 15:33:47 +00:00
if ( priv - > ret_data [ 2 ] ! = target_vfo )
2019-11-30 16:19:08 +00:00
{
2015-03-15 15:33:47 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " VS%c%c " , target_vfo , cat_term ) ;
rig_debug ( RIG_DEBUG_TRACE , " %s: cmd_str = %s \n " , __func__ , priv - > cmd_str ) ;
2019-11-30 16:19:08 +00:00
if ( RIG_OK ! = ( err = newcat_set_cmd ( rig ) ) )
{
2021-01-17 13:25:28 +00:00
ERRMSG ( err , " newcat_set_cmd failed " ) ;
2015-03-15 15:33:47 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
}
}
2015-03-15 15:33:47 +00:00
2009-01-07 00:50:53 +00:00
// W1HKJ
// creation of the priv structure guarantees that the string can be NEWCAT_DATA_LEN
// bytes in length. the snprintf will only allow (NEWCAT_DATA_LEN - 1) chars
// followed by the NULL terminator.
// CAT command string for setting frequency requires that 8 digits be sent
// including leading fill zeros
2017-06-27 15:48:44 +00:00
// Call this after open to set width_frequency for later use
2019-11-30 16:19:08 +00:00
if ( priv - > width_frequency = = 0 )
{
2017-06-27 15:48:44 +00:00
vfo_t vfo_mode ;
newcat_get_vfo_mode ( rig , & vfo_mode ) ;
}
2007-11-22 04:48:43 +00:00
2020-10-28 13:45:53 +00:00
//
// Restore band memory if we can and band is changing -- we do it before we set the frequency
2021-01-13 21:38:20 +00:00
// And only when not in split mode (note this check has been removed for testing)
2021-01-15 23:29:02 +00:00
int changing ;
if ( vfo = = RIG_VFO_A | | vfo = = RIG_VFO_MAIN )
{
2021-01-16 15:31:15 +00:00
changing = newcat_band_index ( freq ) ! = newcat_band_index (
rig - > state . cache . freqMainA ) ;
2021-01-15 23:29:02 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: VFO_A freq changing=%d \n " , __func__ , changing ) ;
}
else
{
2021-01-16 15:31:15 +00:00
changing = newcat_band_index ( freq ) ! = newcat_band_index (
rig - > state . cache . freqMainB ) ;
2021-01-15 23:29:02 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: VFO_B freq changing=%d \n " , __func__ , changing ) ;
}
if ( newcat_valid_command ( rig , " BS " ) & & changing
2021-01-15 22:48:32 +00:00
// remove the split check here -- hopefully works OK
2021-01-13 21:38:20 +00:00
//&& !rig->state.cache.split
2021-01-16 13:38:22 +00:00
& & ! is_ft891 // 891 does not remember bandwidth so don't do this
2021-01-16 15:31:15 +00:00
& & rig - > caps - > get_vfo ! = NULL
& & rig - > caps - > set_vfo ! = NULL ) // gotta' have get_vfo too
2020-10-28 13:45:53 +00:00
{
2021-01-16 15:31:15 +00:00
if ( rig - > state . current_vfo ! = vfo )
{
// then we need to change vfos, BS, and change back
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " VS1;BS%02d%c;VS0; " ,
newcat_band_index ( freq ) , cat_term ) ;
if ( vfo = = RIG_VFO_A | | vfo = = RIG_VFO_MAIN )
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " VS0;BS%02d%c;VS1; " ,
newcat_band_index ( freq ) , cat_term ) ;
}
else
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " BS%02d%c " ,
newcat_band_index ( freq ) , cat_term ) ;
}
2020-10-28 13:45:53 +00:00
if ( RIG_OK ! = ( err = newcat_set_cmd ( rig ) ) )
{
2021-01-15 22:48:32 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: Unexpected error with BS command#1=%s \n " ,
__func__ ,
2020-10-28 13:45:53 +00:00
rigerror ( err ) ) ;
}
2021-01-13 21:38:20 +00:00
else
{
2021-01-15 22:36:07 +00:00
// Also need to do this for the other VFO on some Yaesu rigs
// is redundant for rigs where band stack includes both vfos
vfo_t vfotmp ;
2021-01-15 22:48:32 +00:00
err = rig_get_vfo ( rig , & vfotmp ) ;
if ( err ! = RIG_OK ) { return err ; }
2021-01-15 23:39:37 +00:00
if ( rig - > state . vfo_list & RIG_VFO_MAIN )
{
err = rig_set_vfo ( rig , vfotmp = = RIG_VFO_MAIN ? RIG_VFO_SUB : RIG_VFO_MAIN ) ;
}
else
{
err = rig_set_vfo ( rig , vfotmp = = RIG_VFO_A ? RIG_VFO_B : RIG_VFO_A ) ;
}
2021-01-15 22:48:32 +00:00
if ( err ! = RIG_OK ) { return err ; }
2021-01-16 04:29:46 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " BS%02d%c " ,
newcat_band_index ( freq ) , cat_term ) ;
2021-01-15 22:36:07 +00:00
if ( RIG_OK ! = ( err = newcat_set_cmd ( rig ) ) )
{
2021-01-15 22:48:32 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: Unexpected error with BS command#2=%s \n " ,
__func__ ,
rigerror ( err ) ) ;
2021-01-15 22:36:07 +00:00
}
2021-01-15 22:48:32 +00:00
2021-01-15 22:36:07 +00:00
// switch back to the starting vfo
2021-01-15 23:39:37 +00:00
if ( rig - > state . vfo_list & RIG_VFO_MAIN )
{
err = rig_set_vfo ( rig , vfotmp = = RIG_VFO_MAIN ? RIG_VFO_MAIN : RIG_VFO_SUB ) ;
}
else
{
err = rig_set_vfo ( rig , vfotmp = = RIG_VFO_A ? RIG_VFO_A : RIG_VFO_B ) ;
}
2021-01-15 22:48:32 +00:00
2021-01-16 15:31:15 +00:00
if ( err ! = RIG_OK )
{
rig_debug ( RIG_DEBUG_ERR , " %s: rig_set_vfo failed: %s \n " , __func__ ,
rigerror ( err ) ) ;
return err ;
2021-01-16 13:38:22 +00:00
}
2021-01-15 22:48:32 +00:00
2021-01-13 21:38:20 +00:00
// after band select re-read things -- may not have to change anything
freq_t tmp_freqA , tmp_freqB ;
rmode_t tmp_mode ;
pbwidth_t tmp_width ;
2021-01-15 22:36:07 +00:00
rig_get_freq ( rig , RIG_VFO_MAIN , & tmp_freqA ) ;
rig_get_freq ( rig , RIG_VFO_SUB , & tmp_freqB ) ;
rig_get_mode ( rig , RIG_VFO_MAIN , & tmp_mode , & tmp_width ) ;
rig_get_mode ( rig , RIG_VFO_SUB , & tmp_mode , & tmp_width ) ;
2021-01-15 22:48:32 +00:00
2021-01-13 21:38:20 +00:00
if ( ( target_vfo = = 0 & & tmp_freqA = = freq )
2021-01-15 22:48:32 +00:00
| | ( target_vfo = = 1 & & tmp_freqB = = freq ) )
2021-01-13 21:38:20 +00:00
{
2021-01-15 22:48:32 +00:00
rig_debug ( RIG_DEBUG_VERBOSE ,
" %s: freq after band select already set to % " PRIfreq " \n " , __func__ , freq ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ; // we're done then!!
2021-01-13 21:38:20 +00:00
}
}
2020-10-28 13:45:53 +00:00
// just drop through
}
2020-03-23 12:52:01 +00:00
// cppcheck-suppress *
2019-11-30 16:19:08 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " F%c%0* " PRIll " %c " , c ,
priv - > width_frequency , ( int64_t ) freq , cat_term ) ;
rig_debug ( RIG_DEBUG_TRACE , " %s:%d cmd_str = %s \n " , __func__ , __LINE__ ,
priv - > cmd_str ) ;
2015-09-29 20:06:12 +00:00
if ( RIG_OK ! = ( err = newcat_set_cmd ( rig ) ) )
2019-11-30 16:19:08 +00:00
{
rig_debug ( RIG_DEBUG_VERBOSE , " %s:%d command err = %d \n " , __func__ , __LINE__ ,
err ) ;
2015-03-15 15:33:47 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2015-03-15 15:33:47 +00:00
2020-10-25 13:03:45 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: band changing? old=%d, new=%d \n " , __func__ ,
newcat_band_index ( freq ) , newcat_band_index ( rig - > state . current_freq ) ) ;
2015-03-15 15:33:47 +00:00
if ( RIG_MODEL_FT450 = = caps - > rig_model & & priv - > ret_data [ 2 ] ! = target_vfo )
2019-11-30 16:19:08 +00:00
{
2015-03-15 15:33:47 +00:00
/* revert current VFO */
2019-11-30 16:19:08 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s:%d cmd_str = %s \n " , __func__ , __LINE__ ,
priv - > ret_data ) ;
2015-09-29 20:06:12 +00:00
if ( RIG_OK ! = ( err = newcat_set_cmd ( rig ) ) )
2019-11-30 16:19:08 +00:00
{
rig_debug ( RIG_DEBUG_VERBOSE , " %s:%d command err = %d \n " , __func__ , __LINE__ ,
err ) ;
2015-03-15 15:33:47 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
}
2015-03-15 15:33:47 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2007-11-22 04:48:43 +00:00
}
/*
* rig_get_freq
*
* Return Freq for a given VFO
2008-12-10 23:53:56 +00:00
* RIG_TARGETABLE_FREQ
* Does not SET priv - > current_vfo
2007-11-22 04:48:43 +00:00
*
*/
2019-11-30 16:19:08 +00:00
int newcat_get_freq ( RIG * rig , vfo_t vfo , freq_t * freq )
{
2008-09-22 21:34:45 +00:00
char command [ 3 ] ;
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2007-11-22 04:48:43 +00:00
char c ;
int err ;
2011-07-09 03:27:06 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2017-06-27 15:48:44 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: passed vfo = %s \n " , __func__ , rig_strvfo ( vfo ) ) ;
2007-11-22 04:48:43 +00:00
2009-01-07 00:50:53 +00:00
if ( ! newcat_valid_command ( rig , " FA " ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 00:50:53 +00:00
2020-04-20 04:18:59 +00:00
if ( ! newcat_valid_command ( rig , " FB " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2020-04-20 04:18:59 +00:00
}
2008-12-10 23:53:56 +00:00
err = newcat_set_vfo_from_alias ( rig , & vfo ) ;
2019-11-30 16:19:08 +00:00
2008-12-10 23:53:56 +00:00
if ( err < 0 )
2019-11-30 16:19:08 +00:00
{
2008-12-10 23:53:56 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2007-11-22 04:48:43 +00:00
2019-11-30 16:19:08 +00:00
switch ( vfo )
{
case RIG_VFO_A :
2020-10-06 20:50:37 +00:00
case RIG_VFO_MAIN : // what about MAIN_A/MAIN_B?
2019-11-30 16:19:08 +00:00
c = ' A ' ;
break ;
case RIG_VFO_B :
2020-10-06 20:50:37 +00:00
case RIG_VFO_SUB : // what about SUB_A/SUB_B?
2019-11-30 16:19:08 +00:00
c = ' B ' ;
break ;
case RIG_VFO_MEM :
c = ' A ' ;
break ;
default :
2021-01-13 14:48:48 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: unsupported vfo=%s \n " , __func__ , rig_strvfo ( vfo ) ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ; /* sorry, unsupported VFO */
2007-11-22 04:48:43 +00:00
}
/* Build the command string */
2008-11-16 14:49:12 +00:00
snprintf ( command , sizeof ( command ) , " F%c " , c ) ;
2019-11-30 16:19:08 +00:00
2008-09-22 21:34:45 +00:00
if ( ! newcat_valid_command ( rig , command ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2008-09-22 21:34:45 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%c " , command , cat_term ) ;
2007-11-23 03:31:26 +00:00
rig_debug ( RIG_DEBUG_TRACE , " cmd_str = %s \n " , priv - > cmd_str ) ;
2007-11-22 04:48:43 +00:00
/* get freq */
2019-11-30 16:19:08 +00:00
if ( RIG_OK ! = ( err = newcat_get_cmd ( rig ) ) )
{
2007-11-22 04:48:43 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 20:59:12 +00:00
2007-11-22 04:48:43 +00:00
/* convert the read frequency string into freq_t and store in *freq */
2019-11-30 16:19:08 +00:00
sscanf ( priv - > ret_data + 2 , " % " SCNfreq , freq ) ;
2007-11-22 04:48:43 +00:00
rig_debug ( RIG_DEBUG_TRACE ,
2019-11-30 16:19:08 +00:00
" %s: freq = % " PRIfreq " Hz for vfo %s \n " , __func__ , * freq , rig_strvfo ( vfo ) ) ;
2007-11-22 04:48:43 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2007-11-22 04:48:43 +00:00
}
2008-10-25 14:37:19 +00:00
int newcat_set_mode ( RIG * rig , vfo_t vfo , rmode_t mode , pbwidth_t width )
{
struct newcat_priv_data * priv ;
int err ;
2020-06-14 17:55:14 +00:00
split_t split_save = rig - > state . cache . split ;
2011-07-09 03:27:06 +00:00
2009-01-07 20:59:12 +00:00
priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2008-10-25 14:37:19 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-10-25 14:37:19 +00:00
2009-01-07 00:50:53 +00:00
if ( ! newcat_valid_command ( rig , " MD " ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2008-12-10 23:53:56 +00:00
2008-10-25 14:37:19 +00:00
2008-12-15 21:52:36 +00:00
err = newcat_set_vfo_from_alias ( rig , & vfo ) ;
2019-11-30 16:19:08 +00:00
2008-12-15 21:52:36 +00:00
if ( err < 0 )
2019-11-30 16:19:08 +00:00
{
2008-12-15 21:52:36 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2008-12-15 21:52:36 +00:00
2009-01-07 20:59:12 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " MD0x%c " , cat_term ) ;
2008-12-24 20:17:45 +00:00
/* FT9000 RIG_TARGETABLE_MODE (mode and width) */
/* FT2000 mode only */
2020-05-27 17:23:08 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
2019-11-30 16:19:08 +00:00
{
2020-10-06 20:50:37 +00:00
priv - > cmd_str [ 2 ] = ( RIG_VFO_B = = vfo | | RIG_VFO_SUB = = vfo ) ? ' 1 ' : ' 0 ' ;
2019-11-30 16:19:08 +00:00
}
2008-10-25 14:37:19 +00:00
2019-11-30 16:19:08 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s: generic mode = %s \n " ,
__func__ , rig_strrmode ( mode ) ) ;
2008-10-25 14:37:19 +00:00
2019-11-30 16:19:08 +00:00
2020-04-20 04:18:59 +00:00
priv - > cmd_str [ 3 ] = newcat_modechar ( mode ) ;
2020-04-27 03:30:09 +00:00
2020-04-20 04:18:59 +00:00
if ( priv - > cmd_str [ 3 ] = = ' 0 ' )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2008-12-24 20:17:45 +00:00
}
2008-10-25 14:37:19 +00:00
2015-09-29 20:06:12 +00:00
err = newcat_set_cmd ( rig ) ;
2019-11-30 16:19:08 +00:00
2014-10-18 19:31:47 +00:00
if ( err ! = RIG_OK )
2019-11-30 16:19:08 +00:00
{
2008-10-25 14:37:19 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
if ( RIG_PASSBAND_NOCHANGE = = width ) { return err ; }
2008-12-24 20:17:45 +00:00
2008-12-23 22:36:51 +00:00
if ( RIG_PASSBAND_NORMAL = = width )
2019-11-30 16:19:08 +00:00
{
2008-12-23 22:36:51 +00:00
width = rig_passband_normal ( rig , mode ) ;
2019-11-30 16:19:08 +00:00
}
2008-12-24 20:17:45 +00:00
2008-12-26 11:34:24 +00:00
/* Set width after mode has been set */
2009-01-07 20:59:12 +00:00
err = newcat_set_rx_bandwidth ( rig , vfo , mode , width ) ;
2008-10-25 14:37:19 +00:00
2020-06-14 17:55:14 +00:00
// some rigs if you set mode on VFOB it will turn off split
// so if we started in split we query split and turn it back on if needed
if ( split_save )
{
split_t split ;
vfo_t tx_vfo ;
err = rig_get_split_vfo ( rig , RIG_VFO_A , & split , & tx_vfo ) ;
// we'll just reset to split to what we want if we need to
if ( ! split )
{
rig_debug ( RIG_DEBUG_TRACE , " %s: turning split back on...buggy rig \n " , __func__ ) ;
err = rig_set_split_vfo ( rig , RIG_VFO_A , split_save , RIG_VFO_B ) ;
}
}
2009-01-12 00:51:26 +00:00
return err ;
2008-10-25 14:37:19 +00:00
}
2008-12-23 22:36:51 +00:00
2008-10-25 14:37:19 +00:00
int newcat_get_mode ( RIG * rig , vfo_t vfo , rmode_t * mode , pbwidth_t * width )
{
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2008-10-25 14:37:19 +00:00
char c ;
int err ;
2008-12-24 20:17:45 +00:00
char main_sub_vfo = ' 0 ' ;
2008-10-25 14:37:19 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-10-25 14:37:19 +00:00
2009-01-07 00:50:53 +00:00
if ( ! newcat_valid_command ( rig , " MD " ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2008-12-10 23:53:56 +00:00
2008-12-15 21:52:36 +00:00
err = newcat_set_vfo_from_alias ( rig , & vfo ) ;
2019-11-30 16:19:08 +00:00
2008-12-15 21:52:36 +00:00
if ( err < 0 )
2019-11-30 16:19:08 +00:00
{
2008-12-15 21:52:36 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2008-12-24 20:17:45 +00:00
2020-05-27 17:23:08 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
2019-11-30 16:19:08 +00:00
{
2020-10-06 20:50:37 +00:00
main_sub_vfo = ( RIG_VFO_B = = vfo | | RIG_VFO_SUB = = vfo ) ? ' 1 ' : ' 0 ' ;
2019-11-30 16:19:08 +00:00
}
2008-12-24 20:17:45 +00:00
/* Build the command string */
2019-11-30 16:19:08 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " MD%c%c " , main_sub_vfo ,
cat_term ) ;
2008-10-25 14:37:19 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: cmd_str = %s \n " , __func__ , priv - > cmd_str ) ;
2008-12-26 11:34:24 +00:00
/* Get MODE */
2019-11-30 16:19:08 +00:00
if ( RIG_OK ! = ( err = newcat_get_cmd ( rig ) ) )
{
2008-10-25 14:37:19 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 20:59:12 +00:00
2008-10-25 14:37:19 +00:00
/*
* The current mode value is a digit ' 0 ' . . . ' C '
* embedded at ret_data [ 3 ] in the read string .
*/
c = priv - > ret_data [ 3 ] ;
2008-12-16 22:38:57 +00:00
/* default, unless set otherwise */
* width = RIG_PASSBAND_NORMAL ;
2020-04-20 04:18:59 +00:00
* mode = newcat_rmode_width ( rig , vfo , c , width ) ;
2019-11-30 16:19:08 +00:00
2020-04-20 04:18:59 +00:00
if ( * mode = = ' 0 ' )
{
2020-12-15 21:25:28 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: *mode = '0'?? \n " , __func__ ) ;
2019-11-30 16:19:08 +00:00
return - RIG_EPROTO ;
}
if ( RIG_PASSBAND_NORMAL = = * width )
{
* width = rig_passband_normal ( rig , * mode ) ;
}
2020-10-06 20:50:37 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: returning newcat_get_rx_bandwidth \n " , __func__ ) ;
2019-11-30 16:19:08 +00:00
return newcat_get_rx_bandwidth ( rig , vfo , * mode , width ) ;
}
/*
2020-09-26 22:45:45 +00:00
* newcat_set_vfo
2019-11-30 16:19:08 +00:00
*
* set vfo and store requested vfo for later RIG_VFO_CURR
* requests .
*
*/
int newcat_set_vfo ( RIG * rig , vfo_t vfo )
{
struct newcat_priv_data * priv ;
struct rig_state * state ;
char c ;
int err , mem ;
vfo_t vfo_mode ;
2009-11-22 21:52:11 +00:00
char command [ ] = " VS " ;
2011-07-09 03:27:06 +00:00
2009-01-04 00:05:25 +00:00
priv = ( struct newcat_priv_data * ) rig - > state . priv ;
state = & rig - > state ;
2020-04-27 14:36:40 +00:00
priv - > cache_start . tv_sec = 0 ; // invalidate the cache
2009-01-07 00:50:53 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
rig_debug ( RIG_DEBUG_TRACE , " %s: passed vfo = %s \n " , __func__ ,
2019-11-30 16:19:08 +00:00
rig_strvfo ( vfo ) ) ;
2008-12-10 23:53:56 +00:00
2010-01-04 23:52:43 +00:00
if ( ! newcat_valid_command ( rig , command ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
err = newcat_set_vfo_from_alias ( rig ,
& vfo ) ; /* passes RIG_VFO_MEM, RIG_VFO_A, RIG_VFO_B */
2007-11-22 04:48:43 +00:00
2008-12-06 02:37:45 +00:00
if ( err < 0 )
2019-11-30 16:19:08 +00:00
{
2008-12-06 02:37:45 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2008-12-10 23:53:56 +00:00
2019-11-30 16:19:08 +00:00
switch ( vfo )
{
case RIG_VFO_A :
case RIG_VFO_B :
2020-10-10 15:47:51 +00:00
case RIG_VFO_MAIN :
case RIG_VFO_SUB :
2020-10-06 20:50:37 +00:00
if ( vfo = = RIG_VFO_B | | vfo = = RIG_VFO_SUB )
2019-11-30 16:19:08 +00:00
{
c = ' 1 ' ;
}
else
{
c = ' 0 ' ;
}
err = newcat_get_vfo_mode ( rig , & vfo_mode ) ;
2020-02-23 17:26:09 +00:00
if ( err ! = RIG_OK )
{
2020-01-14 18:50:48 +00:00
return err ;
}
2019-11-30 16:19:08 +00:00
if ( vfo_mode = = RIG_VFO_MEM )
{
priv - > current_mem = NC_MEM_CHANNEL_NONE ;
state - > current_vfo = RIG_VFO_A ;
err = newcat_vfomem_toggle ( rig ) ;
return err ;
}
break ;
case RIG_VFO_MEM :
if ( priv - > current_mem = = NC_MEM_CHANNEL_NONE )
{
/* Only works correctly for VFO A */
2020-10-10 16:44:40 +00:00
if ( state - > current_vfo ! = RIG_VFO_A & & state - > current_vfo ! = RIG_VFO_MAIN )
2019-11-30 16:19:08 +00:00
{
return - RIG_ENTARGET ;
}
/* get current memory channel */
err = newcat_get_mem ( rig , vfo , & mem ) ;
2009-01-07 00:50:53 +00:00
2019-11-30 16:19:08 +00:00
if ( err ! = RIG_OK )
{
2009-01-07 00:50:53 +00:00
return err ;
}
2019-11-30 16:19:08 +00:00
/* turn on memory channel */
err = newcat_set_mem ( rig , vfo , mem ) ;
if ( err ! = RIG_OK )
{
return err ;
2009-01-07 00:50:53 +00:00
}
2019-11-30 16:19:08 +00:00
/* Set current_mem now */
priv - > current_mem = mem ;
}
/* Set current_vfo now */
state - > current_vfo = vfo ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2019-11-30 16:19:08 +00:00
default :
return - RIG_ENIMPL ; /* sorry, VFO not implemented */
2007-11-22 04:48:43 +00:00
}
/* Build the command string */
2008-09-22 21:34:45 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%c%c " , command , c , cat_term ) ;
2007-11-23 03:31:26 +00:00
rig_debug ( RIG_DEBUG_TRACE , " cmd_str = %s \n " , priv - > cmd_str ) ;
2007-11-22 04:48:43 +00:00
2015-09-29 20:06:12 +00:00
err = newcat_set_cmd ( rig ) ;
2019-11-30 16:19:08 +00:00
2014-10-18 19:31:47 +00:00
if ( err ! = RIG_OK )
2019-11-30 16:19:08 +00:00
{
2007-11-22 04:48:43 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2007-11-22 04:48:43 +00:00
2011-07-09 03:27:06 +00:00
state - > current_vfo = vfo ; /* if set_vfo worked, set current_vfo */
2009-01-10 14:52:49 +00:00
2019-11-30 16:19:08 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: rig->state.current_vfo = %s \n " , __func__ ,
rig_strvfo ( vfo ) ) ;
2008-12-06 02:37:45 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2007-11-22 04:48:43 +00:00
}
2020-11-03 15:28:00 +00:00
// Either returns a valid RIG_VFO* or if < 0 an error code
static vfo_t newcat_set_vfo_if_needed ( RIG * rig , vfo_t vfo )
{
vfo_t oldvfo = rig - > state . current_vfo ;
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2020-11-03 15:28:00 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: vfo=%s, oldvfo=%s \n " , __func__ , rig_strvfo ( vfo ) ,
rig_strvfo ( oldvfo ) ) ;
if ( oldvfo ! = vfo )
{
int ret ;
ret = newcat_set_vfo ( rig , vfo ) ;
if ( ret ! = RIG_OK )
{
rig_debug ( RIG_DEBUG_ERR , " %s: error setting vfo=%s \n " , __func__ ,
rig_strvfo ( vfo ) ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( ret ) ;
2020-11-03 15:28:00 +00:00
}
}
return oldvfo ;
}
2007-11-22 04:48:43 +00:00
/*
* rig_get_vfo
*
* get current RX vfo / mem and store requested vfo for
* later RIG_VFO_CURR requests plus pass the tested vfo / mem
* back to the frontend .
*
*/
2019-11-30 16:19:08 +00:00
int newcat_get_vfo ( RIG * rig , vfo_t * vfo )
{
2014-10-12 16:02:24 +00:00
struct rig_state * state = & rig - > state ;
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2007-11-22 04:48:43 +00:00
int err ;
2009-01-10 14:52:49 +00:00
vfo_t vfo_mode ;
2019-11-30 16:19:08 +00:00
char const * command = " VS " ;
2011-07-09 03:27:06 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-12-09 23:12:13 +00:00
if ( ! vfo )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2019-11-30 16:19:08 +00:00
}
2011-07-09 03:27:06 +00:00
2009-01-10 14:52:49 +00:00
/* Build the command string */
2017-01-18 15:28:23 +00:00
if ( ! newcat_valid_command ( rig , command ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2008-09-22 21:34:45 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s; " , command ) ;
2007-11-23 03:31:26 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: cmd_str = %s \n " , __func__ , priv - > cmd_str ) ;
2007-11-22 04:48:43 +00:00
/* Get VFO */
2019-11-30 16:19:08 +00:00
if ( RIG_OK ! = ( err = newcat_get_cmd ( rig ) ) )
{
2007-11-22 04:48:43 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 20:59:12 +00:00
2007-11-22 04:48:43 +00:00
/*
2017-01-18 15:28:23 +00:00
* The current VFO value is a digit ( ' 0 ' or ' 1 ' ( ' A ' or ' B '
* respectively ) ) embedded at ret_data [ 2 ] in the read string .
2007-11-22 04:48:43 +00:00
*/
2017-01-18 15:28:23 +00:00
switch ( priv - > ret_data [ 2 ] )
2019-11-30 16:19:08 +00:00
{
case ' 0 ' :
2020-10-07 04:14:27 +00:00
if ( rig - > state . vfo_list & RIG_VFO_MAIN ) { * vfo = RIG_VFO_MAIN ; }
else { * vfo = RIG_VFO_A ; }
2017-01-18 15:28:23 +00:00
break ;
2019-11-30 16:19:08 +00:00
case ' 1 ' :
2020-10-07 04:14:27 +00:00
if ( rig - > state . vfo_list & RIG_VFO_SUB ) { * vfo = RIG_VFO_SUB ; }
2020-10-10 15:47:51 +00:00
else { * vfo = RIG_VFO_B ; }
2020-10-07 04:14:27 +00:00
2017-01-18 15:28:23 +00:00
break ;
2019-11-30 16:19:08 +00:00
default :
2017-01-18 15:28:23 +00:00
return - RIG_EPROTO ; /* sorry, wrong current VFO */
2019-11-30 16:19:08 +00:00
}
2009-01-07 00:50:53 +00:00
2009-01-10 14:52:49 +00:00
/* Check to see if RIG is in MEM mode */
err = newcat_get_vfo_mode ( rig , & vfo_mode ) ;
2020-02-23 17:26:09 +00:00
if ( err ! = RIG_OK )
{
2020-01-14 18:50:48 +00:00
return err ;
}
2019-11-30 16:19:08 +00:00
2009-01-10 14:52:49 +00:00
if ( vfo_mode = = RIG_VFO_MEM )
2019-11-30 16:19:08 +00:00
{
2009-01-10 14:52:49 +00:00
* vfo = RIG_VFO_MEM ;
2019-11-30 16:19:08 +00:00
}
2009-01-04 00:05:25 +00:00
2011-07-09 03:27:06 +00:00
state - > current_vfo = * vfo ; /* set now */
2007-11-22 04:48:43 +00:00
2019-11-30 16:19:08 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: rig->state.current_vfo = %s \n " , __func__ ,
rig_strvfo ( state - > current_vfo ) ) ;
2009-01-10 14:52:49 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2007-11-22 04:48:43 +00:00
}
2008-09-22 21:34:45 +00:00
2008-10-25 14:37:19 +00:00
int newcat_set_ptt ( RIG * rig , vfo_t vfo , ptt_t ptt )
2008-09-22 21:34:45 +00:00
{
2015-09-29 20:06:12 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2008-10-25 14:37:19 +00:00
int err ;
2009-01-07 00:50:53 +00:00
char txon [ ] = " TX1; " ;
char txoff [ ] = " TX0; " ;
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2020-04-27 14:36:40 +00:00
priv - > cache_start . tv_sec = 0 ; // invalidate the cache
2009-01-07 00:50:53 +00:00
if ( ! newcat_valid_command ( rig , " TX " ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 00:50:53 +00:00
2019-11-30 16:19:08 +00:00
switch ( ptt )
{
case RIG_PTT_ON :
/* Build the command string */
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s " , txon ) ;
rig_debug ( RIG_DEBUG_TRACE , " %s: cmd_str = %s \n " , __func__ , priv - > cmd_str ) ;
err = newcat_set_cmd ( rig ) ;
break ;
case RIG_PTT_OFF :
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s " , txoff ) ;
rig_debug ( RIG_DEBUG_TRACE , " %s: cmd_str = %s \n " , __func__ , priv - > cmd_str ) ;
err = newcat_set_cmd ( rig ) ;
2020-10-15 20:44:43 +00:00
// some rigs like the FT991 need time before doing anything else like set_freq
// We won't mess with CW mode -- no freq change expected hopefully
if ( rig - > state . current_mode ! = RIG_MODE_CW )
{
hl_usleep ( 100 * 1000 ) ;
}
2019-11-30 16:19:08 +00:00
break ;
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2009-01-07 00:50:53 +00:00
}
2019-11-30 16:19:08 +00:00
2008-10-25 14:37:19 +00:00
return err ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_get_ptt ( RIG * rig , vfo_t vfo , ptt_t * ptt )
2008-09-22 21:34:45 +00:00
{
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2008-11-16 14:49:12 +00:00
char c ;
int err ;
2011-07-09 03:27:06 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2009-01-07 00:50:53 +00:00
if ( ! newcat_valid_command ( rig , " TX " ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 00:50:53 +00:00
2008-11-30 12:42:42 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%c " , " TX " , cat_term ) ;
2008-11-16 14:49:12 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: cmd_str = %s \n " , __func__ , priv - > cmd_str ) ;
/* Get PTT */
2019-11-30 16:19:08 +00:00
if ( RIG_OK ! = ( err = newcat_get_cmd ( rig ) ) )
{
2008-11-16 14:49:12 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 20:59:12 +00:00
2008-11-16 14:49:12 +00:00
c = priv - > ret_data [ 2 ] ;
2019-11-30 16:19:08 +00:00
switch ( c )
{
case ' 0 ' : /* FT-950 "TX OFF", Original Release Firmware */
* ptt = RIG_PTT_OFF ;
break ;
2020-08-28 17:16:17 +00:00
case ' 1 ' : /* Just because, what the CAT Manual Shows */
case ' 2 ' : /* FT-950 Radio: Mic, Dataport, CW "TX ON" */
case ' 3 ' : /* FT-950 CAT port: Radio in "TX ON" mode [Not what the CAT Manual Shows] */
2019-11-30 16:19:08 +00:00
* ptt = RIG_PTT_ON ;
break ;
default :
return - RIG_EPROTO ;
2008-11-16 14:49:12 +00:00
}
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_get_dcd ( RIG * rig , vfo_t vfo , dcd_t * dcd )
2008-09-22 21:34:45 +00:00
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_set_rptr_shift ( RIG * rig , vfo_t vfo , rptr_shift_t rptr_shift )
2008-09-22 21:34:45 +00:00
{
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2008-12-25 14:45:00 +00:00
int err ;
2009-11-22 21:52:11 +00:00
char c ;
2008-12-25 14:45:00 +00:00
char command [ ] = " OS " ;
char main_sub_vfo = ' 0 ' ;
2011-07-09 03:27:06 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-12-25 14:45:00 +00:00
if ( ! newcat_valid_command ( rig , command ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2008-12-25 14:45:00 +00:00
/* Main or SUB vfo */
err = newcat_set_vfo_from_alias ( rig , & vfo ) ;
2019-11-30 16:19:08 +00:00
2008-12-25 14:45:00 +00:00
if ( err < 0 )
2019-11-30 16:19:08 +00:00
{
2008-12-25 14:45:00 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2008-12-25 14:45:00 +00:00
2020-05-27 17:23:08 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
2019-11-30 16:19:08 +00:00
{
2020-10-06 20:50:37 +00:00
main_sub_vfo = ( RIG_VFO_B = = vfo | | RIG_VFO_SUB = = vfo ) ? ' 1 ' : ' 0 ' ;
2019-11-30 16:19:08 +00:00
}
2008-12-25 14:45:00 +00:00
2019-11-30 16:19:08 +00:00
switch ( rptr_shift )
{
case RIG_RPT_SHIFT_NONE :
c = ' 0 ' ;
break ;
case RIG_RPT_SHIFT_PLUS :
c = ' 1 ' ;
break ;
case RIG_RPT_SHIFT_MINUS :
c = ' 2 ' ;
break ;
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2008-12-25 14:45:00 +00:00
}
2019-11-30 16:19:08 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%c%c%c " , command ,
main_sub_vfo , c , cat_term ) ;
2015-09-29 20:06:12 +00:00
return newcat_set_cmd ( rig ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_get_rptr_shift ( RIG * rig , vfo_t vfo , rptr_shift_t * rptr_shift )
2008-09-22 21:34:45 +00:00
{
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2008-12-25 14:45:00 +00:00
int err ;
char c ;
char command [ ] = " OS " ;
char main_sub_vfo = ' 0 ' ;
2011-07-09 03:27:06 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2008-12-25 14:45:00 +00:00
if ( ! newcat_valid_command ( rig , command ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2008-12-25 14:45:00 +00:00
/* Set Main or SUB vfo */
err = newcat_set_vfo_from_alias ( rig , & vfo ) ;
2019-11-30 16:19:08 +00:00
2008-12-25 14:45:00 +00:00
if ( err < 0 )
2019-11-30 16:19:08 +00:00
{
2008-12-25 14:45:00 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2008-12-25 14:45:00 +00:00
2020-05-27 17:23:08 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
2019-11-30 16:19:08 +00:00
{
2020-10-06 20:50:37 +00:00
main_sub_vfo = ( RIG_VFO_B = = vfo | | RIG_VFO_SUB = = vfo ) ? ' 1 ' : ' 0 ' ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%c%c " , command , main_sub_vfo ,
cat_term ) ;
2008-12-25 14:45:00 +00:00
/* Get Rptr Shift */
2019-11-30 16:19:08 +00:00
if ( RIG_OK ! = ( err = newcat_get_cmd ( rig ) ) )
{
2008-12-25 14:45:00 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2008-12-25 14:45:00 +00:00
c = priv - > ret_data [ 3 ] ;
2019-11-30 16:19:08 +00:00
switch ( c )
{
case ' 0 ' :
* rptr_shift = RIG_RPT_SHIFT_NONE ;
break ;
case ' 1 ' :
* rptr_shift = RIG_RPT_SHIFT_PLUS ;
break ;
case ' 2 ' :
* rptr_shift = RIG_RPT_SHIFT_MINUS ;
break ;
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2011-07-09 03:27:06 +00:00
}
2008-12-25 14:45:00 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_set_rptr_offs ( RIG * rig , vfo_t vfo , shortfreq_t offs )
2008-09-22 21:34:45 +00:00
{
2020-05-12 03:37:21 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
int err ;
2020-11-09 20:18:57 +00:00
char command [ 32 ] ;
freq_t freq = 0 ;
2020-05-12 03:37:21 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2020-05-12 03:39:10 +00:00
2020-11-09 20:18:57 +00:00
err = newcat_get_freq ( rig , vfo , & freq ) ; // Need to get freq to determine band
2020-11-30 20:53:55 +00:00
2020-11-09 20:18:57 +00:00
if ( err < 0 )
2020-05-12 03:37:21 +00:00
{
2020-11-09 20:18:57 +00:00
return err ;
}
2020-05-12 03:37:21 +00:00
2020-11-09 20:18:57 +00:00
if ( is_ft450 )
{
strcpy ( command , " EX050 " ) ;
// Step size is 100 kHz
offs / = 100000 ;
2020-11-30 20:53:55 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%03li%c " , command , offs ,
cat_term ) ;
2020-11-09 20:18:57 +00:00
}
else if ( is_ft2000 )
{
if ( freq > = 28000000 & & freq < = 29700000 )
2020-05-12 03:37:21 +00:00
{
2020-11-09 20:18:57 +00:00
strcpy ( command , " EX076 " ) ;
}
else if ( freq > = 50000000 & & freq < = 54000000 )
{
strcpy ( command , " EX077 " ) ;
}
else
{
// only valid on 10m and 6m bands
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-05-12 03:37:21 +00:00
}
2008-09-22 21:34:45 +00:00
2020-11-09 20:18:57 +00:00
// Step size is 1 kHz
offs / = 1000 ;
2020-11-30 20:53:55 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%04li%c " , command , offs ,
cat_term ) ;
2020-11-09 20:18:57 +00:00
}
else if ( is_ft950 )
{
if ( freq > = 28000000 & & freq < = 29700000 )
{
strcpy ( command , " EX057 " ) ;
}
else if ( freq > = 50000000 & & freq < = 54000000 )
{
strcpy ( command , " EX058 " ) ;
}
else
{
// only valid on 10m and 6m bands
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-11-09 20:18:57 +00:00
}
// Step size is 1 kHz
offs / = 1000 ;
2020-11-30 20:53:55 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%04li%c " , command , offs ,
cat_term ) ;
2020-11-09 20:18:57 +00:00
}
else if ( is_ft891 )
{
if ( freq > = 28000000 & & freq < = 29700000 )
{
strcpy ( command , " EX0904 " ) ;
}
else if ( freq > = 50000000 & & freq < = 54000000 )
{
strcpy ( command , " EX0905 " ) ;
}
else
{
// only valid on 10m and 6m bands
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-11-09 20:18:57 +00:00
}
// Step size is 1 kHz
offs / = 1000 ;
2020-11-30 20:53:55 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%04li%c " , command , offs ,
cat_term ) ;
2020-11-09 20:18:57 +00:00
}
else if ( is_ft991 )
{
2020-05-12 03:37:21 +00:00
if ( freq > = 28000000 & & freq < = 29700000 )
{
strcpy ( command , " EX080 " ) ;
}
else if ( freq > = 50000000 & & freq < = 54000000 )
{
strcpy ( command , " EX081 " ) ;
}
else if ( freq > = 144000000 & & freq < = 148000000 )
{
strcpy ( command , " EX082 " ) ;
}
else if ( freq > = 430000000 & & freq < = 450000000 )
{
strcpy ( command , " EX083 " ) ;
}
else
{
// only valid on 10m to 70cm bands
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-11-09 20:18:57 +00:00
}
// Step size is 1 kHz
offs / = 1000 ;
2020-11-30 20:53:55 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%04li%c " , command , offs ,
cat_term ) ;
2020-11-09 20:18:57 +00:00
}
else if ( is_ftdx1200 )
{
if ( freq > = 28000000 & & freq < = 29700000 )
{
strcpy ( command , " EX087 " ) ;
}
else if ( freq > = 50000000 & & freq < = 54000000 )
{
strcpy ( command , " EX088 " ) ;
}
else
{
// only valid on 10m and 6m bands
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-05-12 03:37:21 +00:00
}
2020-11-09 20:18:57 +00:00
// Step size is 1 kHz
offs / = 1000 ;
2020-11-30 20:53:55 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%04li%c " , command , offs ,
cat_term ) ;
2020-05-12 03:37:21 +00:00
}
2020-11-09 20:18:57 +00:00
else if ( is_ftdx3000 )
{
if ( freq > = 28000000 & & freq < = 29700000 )
{
strcpy ( command , " EX086 " ) ;
}
else if ( freq > = 50000000 & & freq < = 54000000 )
{
strcpy ( command , " EX087 " ) ;
}
else
{
// only valid on 10m and 6m bands
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-11-09 20:18:57 +00:00
}
2020-05-12 03:39:10 +00:00
2020-11-10 08:20:51 +00:00
// Step size is 1 kHz
2020-11-09 20:18:57 +00:00
offs / = 1000 ;
2020-11-30 20:53:55 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%04li%c " , command , offs ,
cat_term ) ;
2020-11-09 20:18:57 +00:00
}
else if ( is_ftdx5000 )
{
if ( freq > = 28000000 & & freq < = 29700000 )
{
strcpy ( command , " EX081 " ) ;
}
else if ( freq > = 50000000 & & freq < = 54000000 )
{
strcpy ( command , " EX082 " ) ;
}
else
{
// only valid on 10m and 6m bands
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-11-09 20:18:57 +00:00
}
2020-11-10 08:20:51 +00:00
// Step size is 1 kHz
2020-11-09 20:18:57 +00:00
offs / = 1000 ;
2020-11-30 20:53:55 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%04li%c " , command , offs ,
cat_term ) ;
2020-11-09 20:18:57 +00:00
}
2020-12-28 21:17:49 +00:00
else if ( is_ftdx101 | | is_ftdx10 )
2020-11-09 20:18:57 +00:00
{
if ( freq > = 28000000 & & freq < = 29700000 )
{
strcpy ( command , " EX010315 " ) ;
2021-01-04 18:09:28 +00:00
if ( is_ftdx10 ) { strcpy ( command , " EX010317 " ) ; }
2020-11-09 20:18:57 +00:00
}
else if ( freq > = 50000000 & & freq < = 54000000 )
{
strcpy ( command , " EX010316 " ) ;
2021-01-04 18:09:28 +00:00
if ( is_ftdx10 ) { strcpy ( command , " EX010318 " ) ; }
2020-11-09 20:18:57 +00:00
}
else
{
// only valid on 10m and 6m bands
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-11-09 20:18:57 +00:00
}
// Step size is 1 kHz
offs / = 1000 ;
2020-11-30 20:53:55 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%04li%c " , command , offs ,
cat_term ) ;
2020-11-09 20:18:57 +00:00
}
else
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2020-11-09 20:18:57 +00:00
}
return newcat_set_cmd ( rig ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_get_rptr_offs ( RIG * rig , vfo_t vfo , shortfreq_t * offs )
2008-09-22 21:34:45 +00:00
{
2020-05-12 03:37:21 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
int err ;
int ret_data_len ;
char * retoffs ;
2020-11-09 20:18:57 +00:00
freq_t freq = 0 ;
int step ;
2020-05-12 03:37:21 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2020-11-09 20:18:57 +00:00
err = newcat_get_freq ( rig , vfo , & freq ) ; // Need to get freq to determine band
2020-11-30 20:53:55 +00:00
2020-11-09 20:18:57 +00:00
if ( err < 0 )
{
return err ;
}
if ( is_ft450 )
2020-05-12 03:37:21 +00:00
{
2020-11-09 20:18:57 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX050%c " , cat_term ) ;
2020-05-12 03:37:21 +00:00
2020-11-09 20:18:57 +00:00
// Step size is 100 kHz
step = 100000 ;
}
else if ( is_ft2000 )
{
if ( freq > = 28000000 & & freq < = 29700000 )
2020-05-12 03:37:21 +00:00
{
2020-11-09 20:18:57 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX076%c " , cat_term ) ;
}
else if ( freq > = 50000000 & & freq < = 54000000 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX077%c " , cat_term ) ;
}
else
{
// only valid on 10m and 6m bands
* offs = 0 ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2020-05-12 03:37:21 +00:00
}
2020-11-09 20:18:57 +00:00
// Step size is 1 kHz
step = 1000 ;
}
else if ( is_ft950 )
{
if ( freq > = 28000000 & & freq < = 29700000 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX057%c " , cat_term ) ;
}
else if ( freq > = 50000000 & & freq < = 54000000 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX058%c " , cat_term ) ;
}
else
{
// only valid on 10m and 6m bands
* offs = 0 ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2020-11-09 20:18:57 +00:00
}
// Step size is 1 kHz
step = 1000 ;
}
else if ( is_ft891 )
{
if ( freq > = 28000000 & & freq < = 29700000 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX0904%c " , cat_term ) ;
}
else if ( freq > = 50000000 & & freq < = 54000000 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX0905%c " , cat_term ) ;
}
else
{
// only valid on 10m and 6m bands
* offs = 0 ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2020-11-09 20:18:57 +00:00
}
// Step size is 1 kHz
step = 1000 ;
}
else if ( is_ft991 )
{
2020-05-12 03:37:21 +00:00
if ( freq > = 28000000 & & freq < = 29700000 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX080%c " , cat_term ) ;
}
else if ( freq > = 50000000 & & freq < = 54000000 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX081%c " , cat_term ) ;
}
else if ( freq > = 144000000 & & freq < = 148000000 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX082%c " , cat_term ) ;
}
else if ( freq > = 430000000 & & freq < = 450000000 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX083%c " , cat_term ) ;
}
else
{
2020-11-09 20:18:57 +00:00
// only valid on 10m to 70cm bands
* offs = 0 ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2020-05-12 03:37:21 +00:00
}
2020-11-09 20:18:57 +00:00
// Step size is 1 kHz
step = 1000 ;
}
else if ( is_ftdx1200 )
{
if ( freq > = 28000000 & & freq < = 29700000 )
2020-05-12 03:37:21 +00:00
{
2020-11-09 20:18:57 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX087%c " , cat_term ) ;
}
else if ( freq > = 50000000 & & freq < = 54000000 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX088%c " , cat_term ) ;
}
else
{
// only valid on 10m and 6m bands
* offs = 0 ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2020-05-12 03:37:21 +00:00
}
2020-11-09 20:18:57 +00:00
// Step size is 1 kHz
step = 1000 ;
}
else if ( is_ftdx3000 )
{
if ( freq > = 28000000 & & freq < = 29700000 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX086%c " , cat_term ) ;
}
else if ( freq > = 50000000 & & freq < = 54000000 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX087%c " , cat_term ) ;
}
else
{
// only valid on 10m and 6m bands
* offs = 0 ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2020-11-09 20:18:57 +00:00
}
2020-05-12 03:37:21 +00:00
2020-11-10 08:20:51 +00:00
// Step size is 1 kHz
2020-11-09 20:18:57 +00:00
step = 1000 ;
}
else if ( is_ftdx5000 )
{
if ( freq > = 28000000 & & freq < = 29700000 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX081%c " , cat_term ) ;
}
else if ( freq > = 50000000 & & freq < = 54000000 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX082%c " , cat_term ) ;
}
else
{
// only valid on 10m and 6m bands
* offs = 0 ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2020-11-09 20:18:57 +00:00
}
2020-11-10 08:20:51 +00:00
// Step size is 1 kHz
2020-11-09 20:18:57 +00:00
step = 1000 ;
}
2020-12-28 21:17:49 +00:00
else if ( is_ftdx101 | | is_ftdx10 )
2020-11-09 20:18:57 +00:00
{
if ( freq > = 28000000 & & freq < = 29700000 )
{
2020-12-28 21:17:49 +00:00
char * cmd = " EX010315%c " ;
2021-01-04 18:09:28 +00:00
if ( is_ftdx10 ) { cmd = " EX010317%c " ; }
2020-12-28 21:17:49 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , cmd , cat_term ) ;
2020-11-09 20:18:57 +00:00
}
else if ( freq > = 50000000 & & freq < = 54000000 )
{
2020-12-28 21:17:49 +00:00
char * cmd = " EX010316%c " ;
2021-01-04 18:09:28 +00:00
if ( is_ftdx10 ) { cmd = " EX010318%c " ; }
2020-12-28 21:17:49 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , cmd , cat_term ) ;
2020-11-09 20:18:57 +00:00
}
else
{
// only valid on 10m and 6m bands
* offs = 0 ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2020-11-09 20:18:57 +00:00
}
// Step size is 1 kHz
step = 1000 ;
2020-05-12 03:37:21 +00:00
}
else
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2020-05-12 03:37:21 +00:00
}
2020-05-12 03:39:10 +00:00
2020-11-09 20:18:57 +00:00
err = newcat_get_cmd ( rig ) ;
2020-11-30 20:53:55 +00:00
2020-11-09 20:18:57 +00:00
if ( err ! = RIG_OK )
{
return err ;
}
ret_data_len = strlen ( priv - > ret_data ) ;
/* skip command */
retoffs = priv - > ret_data + strlen ( priv - > cmd_str ) - 1 ;
/* chop term */
priv - > ret_data [ ret_data_len - 1 ] = ' \0 ' ;
* offs = atoi ( retoffs ) * step ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_set_split_freq ( RIG * rig , vfo_t vfo , freq_t tx_freq )
2008-09-22 21:34:45 +00:00
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_get_split_freq ( RIG * rig , vfo_t vfo , freq_t * tx_freq )
2008-09-22 21:34:45 +00:00
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_set_split_mode ( RIG * rig , vfo_t vfo , rmode_t tx_mode ,
pbwidth_t tx_width )
2008-09-22 21:34:45 +00:00
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_get_split_mode ( RIG * rig , vfo_t vfo , rmode_t * tx_mode ,
pbwidth_t * tx_width )
2008-09-22 21:34:45 +00:00
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_set_split_vfo ( RIG * rig , vfo_t vfo , split_t split , vfo_t tx_vfo )
2008-09-22 21:34:45 +00:00
{
2008-12-06 02:37:45 +00:00
int err ;
2009-01-07 20:59:12 +00:00
vfo_t rx_vfo ;
2008-12-06 02:37:45 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2008-12-06 02:37:45 +00:00
err = newcat_set_vfo_from_alias ( rig , & vfo ) ;
2019-11-30 16:19:08 +00:00
2008-12-06 02:37:45 +00:00
if ( err < 0 )
2019-11-30 16:19:08 +00:00
{
2008-12-06 02:37:45 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2008-12-06 02:37:45 +00:00
2020-10-06 20:50:37 +00:00
if ( is_ft991 )
2019-11-30 16:19:08 +00:00
{
2017-01-18 15:28:23 +00:00
vfo = RIG_VFO_A ;
tx_vfo = RIG_SPLIT_ON = = split ? RIG_VFO_B : RIG_VFO_A ;
2019-11-30 16:19:08 +00:00
}
2020-10-26 08:06:38 +00:00
else if ( is_ftdx101 )
2020-10-06 20:50:37 +00:00
{
vfo = RIG_VFO_MAIN ;
tx_vfo = RIG_SPLIT_ON = = split ? RIG_VFO_SUB : RIG_VFO_MAIN ;
}
2017-01-18 15:28:23 +00:00
else
2019-11-30 16:19:08 +00:00
{
2017-01-18 15:28:23 +00:00
err = newcat_get_vfo ( rig , & rx_vfo ) ; /* sync to rig current vfo */
2019-11-30 16:19:08 +00:00
2017-01-18 15:28:23 +00:00
if ( err ! = RIG_OK )
2019-11-30 16:19:08 +00:00
{
return err ;
}
}
2009-01-07 23:09:12 +00:00
2019-11-30 16:19:08 +00:00
switch ( split )
{
case RIG_SPLIT_OFF :
err = newcat_set_tx_vfo ( rig , vfo ) ;
if ( err ! = RIG_OK )
{
return err ;
}
if ( rx_vfo ! = vfo & & newcat_valid_command ( rig , " VS " ) )
{
err = newcat_set_vfo ( rig , vfo ) ;
2008-12-10 23:53:56 +00:00
2014-10-18 19:31:47 +00:00
if ( err ! = RIG_OK )
2019-11-30 16:19:08 +00:00
{
2008-12-06 02:37:45 +00:00
return err ;
}
2019-11-30 16:19:08 +00:00
}
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
break ;
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
case RIG_SPLIT_ON :
err = newcat_set_tx_vfo ( rig , tx_vfo ) ;
2008-12-06 02:37:45 +00:00
2019-11-30 16:19:08 +00:00
if ( err ! = RIG_OK )
{
return err ;
}
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
if ( rx_vfo ! = vfo )
{
err = newcat_set_vfo ( rig , vfo ) ;
if ( err ! = RIG_OK & & err ! = - RIG_ENAVAIL )
{
return err ;
}
}
break ;
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2019-11-30 16:19:08 +00:00
}
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2019-11-30 16:19:08 +00:00
}
int newcat_get_split_vfo ( RIG * rig , vfo_t vfo , split_t * split , vfo_t * tx_vfo )
{
int err ;
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
err = newcat_set_vfo_from_alias ( rig , & vfo ) ;
if ( err ! = RIG_OK )
{
return err ;
}
2008-12-06 02:37:45 +00:00
2009-01-07 20:59:12 +00:00
err = newcat_get_tx_vfo ( rig , tx_vfo ) ;
2019-11-30 16:19:08 +00:00
2014-10-18 19:31:47 +00:00
if ( err ! = RIG_OK )
2019-11-30 16:19:08 +00:00
{
2008-12-06 02:37:45 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2008-12-06 02:37:45 +00:00
2020-06-14 20:28:52 +00:00
// we assume split is always on VFO_B
2020-10-06 20:50:37 +00:00
if ( * tx_vfo = = RIG_VFO_B | | * tx_vfo = = RIG_VFO_SUB )
2019-11-30 16:19:08 +00:00
{
2008-12-06 02:37:45 +00:00
* split = RIG_SPLIT_ON ;
2019-11-30 16:19:08 +00:00
}
2009-01-08 12:57:31 +00:00
else
2019-11-30 16:19:08 +00:00
{
2009-01-07 00:50:53 +00:00
* split = RIG_SPLIT_OFF ;
2019-11-30 16:19:08 +00:00
}
2008-12-06 02:37:45 +00:00
2020-03-26 16:11:46 +00:00
rig_debug ( RIG_DEBUG_TRACE , " SPLIT = %d, vfo = %s, TX_vfo = %s \n " , * split ,
rig_strvfo ( vfo ) ,
2020-03-20 12:51:32 +00:00
rig_strvfo ( * tx_vfo ) ) ;
2009-01-07 20:59:12 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_set_rit ( RIG * rig , vfo_t vfo , shortfreq_t rit )
2008-09-22 21:34:45 +00:00
{
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2020-11-02 23:21:20 +00:00
vfo_t oldvfo ;
int ret ;
2008-09-22 21:34:45 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2009-01-07 00:50:53 +00:00
if ( ! newcat_valid_command ( rig , " RT " ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 00:50:53 +00:00
2020-11-03 15:28:00 +00:00
oldvfo = newcat_set_vfo_if_needed ( rig , vfo ) ;
2020-11-02 23:21:20 +00:00
2020-11-03 15:28:00 +00:00
if ( oldvfo < 0 ) { return oldvfo ; }
2020-11-02 23:21:20 +00:00
2009-01-07 00:50:53 +00:00
if ( rit > rig - > caps - > max_rit )
2019-11-30 16:19:08 +00:00
{
rit = rig - > caps - > max_rit ; /* + */
}
2016-02-06 06:48:54 +00:00
else if ( labs ( rit ) > rig - > caps - > max_rit )
2019-11-30 16:19:08 +00:00
{
rit = - rig - > caps - > max_rit ; /* - */
}
2008-12-06 02:37:45 +00:00
2020-08-28 17:16:17 +00:00
if ( rit = = 0 ) // don't turn it off just because it is zero
2019-11-30 16:19:08 +00:00
{
2020-08-28 17:16:17 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " RC%c " ,
2019-11-30 16:19:08 +00:00
cat_term ) ;
}
2008-12-10 23:53:56 +00:00
else if ( rit < 0 )
2019-11-30 16:19:08 +00:00
{
2020-10-24 07:55:11 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " RC%cRD%04ld%c " , cat_term ,
labs ( rit ) , cat_term ) ;
2019-11-30 16:19:08 +00:00
}
2008-12-06 02:37:45 +00:00
else
2019-11-30 16:19:08 +00:00
{
2020-10-24 07:55:11 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " RC%cRU%04ld%c " , cat_term ,
labs ( rit ) , cat_term ) ;
2019-11-30 16:19:08 +00:00
}
2008-11-29 19:26:09 +00:00
2020-11-02 23:21:20 +00:00
ret = newcat_set_cmd ( rig ) ;
2020-11-03 15:28:00 +00:00
oldvfo = newcat_set_vfo_if_needed ( rig , oldvfo ) ;
2020-11-02 23:21:20 +00:00
2020-11-03 15:28:00 +00:00
if ( oldvfo < 0 ) { return oldvfo ; }
2020-11-02 23:21:20 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( ret ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_get_rit ( RIG * rig , vfo_t vfo , shortfreq_t * rit )
2008-09-22 21:34:45 +00:00
{
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2008-11-29 19:26:09 +00:00
char * retval ;
int err ;
2019-12-09 23:12:13 +00:00
int offset = 0 ;
2020-11-02 23:21:20 +00:00
char * cmd = " IF " ;
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2020-11-02 23:21:20 +00:00
if ( vfo = = RIG_VFO_B | | vfo = = RIG_VFO_SUB )
{
cmd = " OI " ;
}
2011-07-09 03:27:06 +00:00
2020-11-02 23:21:20 +00:00
if ( ! newcat_valid_command ( rig , cmd ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 00:50:53 +00:00
2008-11-29 19:26:09 +00:00
* rit = 0 ;
2020-11-02 23:21:20 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%c " , cmd , cat_term ) ;
2008-11-29 19:26:09 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: cmd_str = %s \n " , __func__ , priv - > cmd_str ) ;
/* Get RIT */
2019-11-30 16:19:08 +00:00
if ( RIG_OK ! = ( err = newcat_get_cmd ( rig ) ) )
{
2008-11-29 19:26:09 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2008-11-29 19:26:09 +00:00
2017-06-27 15:48:44 +00:00
// e.g. FT450 has 27 byte IF response, FT991 has 28 byte if response (one more byte for P2 VFO A Freq)
// so we now check to ensure we know the length of the response
2019-11-30 16:19:08 +00:00
switch ( strlen ( priv - > ret_data ) )
{
case 27 : offset = 13 ; break ;
case 28 : offset = 14 ; break ;
default : offset = 0 ;
2017-06-27 15:48:44 +00:00
}
2019-11-30 16:19:08 +00:00
if ( offset = = 0 )
{
rig_debug ( RIG_DEBUG_ERR ,
2019-11-30 19:05:21 +00:00
" %s: incorrect length of IF response, expected 27 or 28, got %du " , __func__ ,
( int ) strlen ( priv - > ret_data ) ) ;
2017-06-27 15:48:44 +00:00
return - RIG_EPROTO ;
}
2015-04-13 03:56:36 +00:00
2017-06-27 15:48:44 +00:00
retval = priv - > ret_data + offset ;
2008-11-29 19:26:09 +00:00
retval [ 5 ] = ' \0 ' ;
2020-10-23 08:24:09 +00:00
// return the current offset even if turned off
* rit = ( shortfreq_t ) atoi ( retval ) ;
2008-12-06 02:37:45 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_set_xit ( RIG * rig , vfo_t vfo , shortfreq_t xit )
2008-09-22 21:34:45 +00:00
{
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2020-11-03 15:28:00 +00:00
vfo_t oldvfo ;
int ret ;
2008-09-22 21:34:45 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-12-06 13:29:37 +00:00
if ( ! newcat_valid_command ( rig , " XT " ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2008-12-06 13:29:37 +00:00
2020-11-03 15:28:00 +00:00
oldvfo = newcat_set_vfo_if_needed ( rig , vfo ) ;
if ( oldvfo < 0 ) { return oldvfo ; }
2009-01-07 00:50:53 +00:00
if ( xit > rig - > caps - > max_xit )
2019-11-30 16:19:08 +00:00
{
xit = rig - > caps - > max_xit ; /* + */
}
2016-02-06 06:48:54 +00:00
else if ( labs ( xit ) > rig - > caps - > max_xit )
2019-11-30 16:19:08 +00:00
{
xit = - rig - > caps - > max_xit ; /* - */
}
2008-12-06 02:37:45 +00:00
2008-12-10 23:53:56 +00:00
if ( xit = = 0 )
2019-11-30 16:19:08 +00:00
{
2020-08-28 17:16:17 +00:00
// don't turn it off just because the offset is zero
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " RC%c " ,
2019-11-30 16:19:08 +00:00
cat_term ) ;
}
2008-12-10 23:53:56 +00:00
else if ( xit < 0 )
2019-11-30 16:19:08 +00:00
{
2020-10-24 07:55:11 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " RC%cRD%04ld%c " , cat_term ,
labs ( xit ) , cat_term ) ;
2019-11-30 16:19:08 +00:00
}
2008-12-06 02:37:45 +00:00
else
2019-11-30 16:19:08 +00:00
{
2020-10-24 07:55:11 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " RC%cRU%04ld%c " , cat_term ,
labs ( xit ) , cat_term ) ;
2019-11-30 16:19:08 +00:00
}
2008-11-29 19:26:09 +00:00
2020-11-03 15:28:00 +00:00
ret = newcat_set_cmd ( rig ) ;
oldvfo = newcat_set_vfo_if_needed ( rig , vfo ) ;
if ( oldvfo < 0 ) { return oldvfo ; }
2021-01-17 13:25:28 +00:00
RETURNFUNC ( ret ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_get_xit ( RIG * rig , vfo_t vfo , shortfreq_t * xit )
2008-09-22 21:34:45 +00:00
{
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2008-11-29 19:26:09 +00:00
char * retval ;
int err ;
2019-12-09 23:12:13 +00:00
int offset = 0 ;
2020-11-03 15:28:00 +00:00
char * cmd = " IF " ;
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2020-11-03 15:28:00 +00:00
if ( vfo = = RIG_VFO_B | | vfo = = RIG_VFO_SUB )
{
cmd = " OI " ;
}
2011-07-09 03:27:06 +00:00
2020-11-03 15:28:00 +00:00
if ( ! newcat_valid_command ( rig , cmd ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2008-12-06 13:29:37 +00:00
2008-11-29 19:26:09 +00:00
* xit = 0 ;
2020-11-03 15:28:00 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%c " , cmd , cat_term ) ;
2008-11-29 19:26:09 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: cmd_str = %s \n " , __func__ , priv - > cmd_str ) ;
/* Get XIT */
2019-11-30 16:19:08 +00:00
if ( RIG_OK ! = ( err = newcat_get_cmd ( rig ) ) )
{
2008-11-29 19:26:09 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2008-11-29 19:26:09 +00:00
2017-06-27 15:48:44 +00:00
// e.g. FT450 has 27 byte IF response, FT991 has 28 byte if response (one more byte for P2 VFO A Freq)
// so we now check to ensure we know the length of the response
2019-11-30 16:19:08 +00:00
switch ( strlen ( priv - > ret_data ) )
{
case 27 : offset = 13 ; break ;
case 28 : offset = 14 ; break ;
default : offset = 0 ;
2017-06-27 15:48:44 +00:00
}
2019-11-30 16:19:08 +00:00
if ( offset = = 0 )
{
rig_debug ( RIG_DEBUG_ERR ,
2019-11-30 19:05:21 +00:00
" %s: incorrect length of IF response, expected 27 or 28, got %du " , __func__ ,
( int ) strlen ( priv - > ret_data ) ) ;
2017-06-27 15:48:44 +00:00
return - RIG_EPROTO ;
}
2009-01-07 20:59:12 +00:00
2017-06-27 15:48:44 +00:00
retval = priv - > ret_data + offset ;
2008-11-29 19:26:09 +00:00
retval [ 5 ] = ' \0 ' ;
2020-10-23 08:24:09 +00:00
// return the offset even when turned off
* xit = ( shortfreq_t ) atoi ( retval ) ;
2008-12-06 02:37:45 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_set_ts ( RIG * rig , vfo_t vfo , shortfreq_t ts )
2008-09-22 21:34:45 +00:00
{
2008-12-28 00:25:31 +00:00
int err , i ;
pbwidth_t width ;
rmode_t mode ;
ncboolean ts_match ;
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2008-12-28 00:25:31 +00:00
err = newcat_get_mode ( rig , vfo , & mode , & width ) ;
2019-11-30 16:19:08 +00:00
2008-12-28 00:25:31 +00:00
if ( err < 0 )
2019-11-30 16:19:08 +00:00
{
2008-12-28 00:25:31 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2008-12-28 00:25:31 +00:00
/* assume 2 tuning steps per mode */
2019-11-30 16:19:08 +00:00
for ( i = 0 , ts_match = FALSE ; i < TSLSTSIZ
& & rig - > caps - > tuning_steps [ i ] . ts ; i + + )
if ( rig - > caps - > tuning_steps [ i ] . modes & mode )
{
2008-12-28 04:06:14 +00:00
if ( ts < = rig - > caps - > tuning_steps [ i ] . ts )
2019-11-30 16:19:08 +00:00
{
2008-12-28 00:25:31 +00:00
err = newcat_set_faststep ( rig , FALSE ) ;
2019-11-30 16:19:08 +00:00
}
2011-07-09 03:27:06 +00:00
else
2019-11-30 16:19:08 +00:00
{
2020-12-28 21:17:49 +00:00
err = newcat_set_faststep ( rig , TRUE ) ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 00:50:53 +00:00
2014-10-18 19:31:47 +00:00
if ( err ! = RIG_OK )
2019-11-30 16:19:08 +00:00
{
2008-12-28 04:06:14 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2008-12-28 00:25:31 +00:00
ts_match = TRUE ;
break ;
} /* if mode */
2019-11-30 16:19:08 +00:00
rig_debug ( RIG_DEBUG_TRACE , " ts_match = %d, i = %d, ts = %d \n " , ts_match , i ,
( int ) ts ) ;
2008-12-28 00:25:31 +00:00
if ( ts_match )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2019-11-30 16:19:08 +00:00
}
2008-12-28 00:25:31 +00:00
else
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_get_ts ( RIG * rig , vfo_t vfo , shortfreq_t * ts )
2008-09-22 21:34:45 +00:00
{
2008-12-28 00:25:31 +00:00
pbwidth_t width ;
rmode_t mode ;
int err , i ;
2009-11-22 21:52:11 +00:00
ncboolean ts_match ;
ncboolean fast_step = FALSE ;
2008-12-28 00:25:31 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2008-12-28 00:25:31 +00:00
err = newcat_get_mode ( rig , vfo , & mode , & width ) ;
2019-11-30 16:19:08 +00:00
2008-12-28 00:25:31 +00:00
if ( err < 0 )
2019-11-30 16:19:08 +00:00
{
2008-12-28 00:25:31 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2008-12-28 00:25:31 +00:00
err = newcat_get_faststep ( rig , & fast_step ) ;
2019-11-30 16:19:08 +00:00
2008-12-28 00:25:31 +00:00
if ( err < 0 )
2019-11-30 16:19:08 +00:00
{
2008-12-28 00:25:31 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2008-12-28 00:25:31 +00:00
/* assume 2 tuning steps per mode */
2019-11-30 16:19:08 +00:00
for ( i = 0 , ts_match = FALSE ; i < TSLSTSIZ
& & rig - > caps - > tuning_steps [ i ] . ts ; i + + )
if ( rig - > caps - > tuning_steps [ i ] . modes & mode )
{
2008-12-28 00:25:31 +00:00
if ( fast_step = = FALSE )
2019-11-30 16:19:08 +00:00
{
2008-12-28 00:25:31 +00:00
* ts = rig - > caps - > tuning_steps [ i ] . ts ;
2019-11-30 16:19:08 +00:00
}
2008-12-28 00:25:31 +00:00
else
2019-11-30 16:19:08 +00:00
{
* ts = rig - > caps - > tuning_steps [ i + 1 ] . ts ;
}
2008-12-28 00:25:31 +00:00
2011-07-09 03:27:06 +00:00
ts_match = TRUE ;
2008-12-28 00:25:31 +00:00
break ;
}
2019-11-30 16:19:08 +00:00
rig_debug ( RIG_DEBUG_TRACE , " ts_match = %d, i = %d, i+1 = %d, *ts = %d \n " ,
ts_match , i , i + 1 , ( int ) * ts ) ;
2008-12-28 00:25:31 +00:00
if ( ts_match )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2019-11-30 16:19:08 +00:00
}
2008-12-28 00:25:31 +00:00
else
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_set_dcs_code ( RIG * rig , vfo_t vfo , tone_t code )
2008-09-22 21:34:45 +00:00
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_get_dcs_code ( RIG * rig , vfo_t vfo , tone_t * code )
2008-09-22 21:34:45 +00:00
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_set_tone ( RIG * rig , vfo_t vfo , tone_t tone )
2008-09-22 21:34:45 +00:00
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_get_tone ( RIG * rig , vfo_t vfo , tone_t * tone )
2008-09-22 21:34:45 +00:00
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_set_ctcss_tone ( RIG * rig , vfo_t vfo , tone_t tone )
2008-09-22 21:34:45 +00:00
{
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2008-12-26 00:05:02 +00:00
int err ;
2008-12-26 11:34:24 +00:00
int i ;
2008-12-28 00:25:31 +00:00
ncboolean tone_match ;
2009-11-22 21:52:11 +00:00
char main_sub_vfo = ' 0 ' ;
2011-07-09 03:27:06 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2008-12-26 00:05:02 +00:00
if ( ! newcat_valid_command ( rig , " CN " ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2008-12-26 00:05:02 +00:00
2009-01-07 00:50:53 +00:00
if ( ! newcat_valid_command ( rig , " CT " ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 00:50:53 +00:00
2008-12-26 00:05:02 +00:00
err = newcat_set_vfo_from_alias ( rig , & vfo ) ;
2019-11-30 16:19:08 +00:00
2008-12-26 00:05:02 +00:00
if ( err < 0 )
2019-11-30 16:19:08 +00:00
{
2008-12-26 00:05:02 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2008-12-26 00:05:02 +00:00
2020-05-27 17:23:08 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
2019-11-30 16:19:08 +00:00
{
2020-10-07 04:14:27 +00:00
main_sub_vfo = ( RIG_VFO_B = = vfo | | RIG_VFO_SUB = = vfo ) ? ' 1 ' : ' 0 ' ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 00:50:53 +00:00
2008-12-28 00:25:31 +00:00
for ( i = 0 , tone_match = FALSE ; rig - > caps - > ctcss_list [ i ] ! = 0 ; i + + )
2019-11-30 16:19:08 +00:00
if ( tone = = rig - > caps - > ctcss_list [ i ] )
{
2008-12-26 11:34:24 +00:00
tone_match = TRUE ;
2008-12-26 00:05:02 +00:00
break ;
}
2020-03-20 12:51:32 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: tone = %u, tone_match = %d, i = %d " , __func__ ,
2019-11-30 16:19:08 +00:00
tone , tone_match , i ) ;
2009-01-07 00:50:53 +00:00
2008-12-26 11:34:24 +00:00
if ( tone_match = = FALSE & & tone ! = 0 )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 00:50:53 +00:00
2020-10-23 07:35:14 +00:00
if ( tone = = 0 ) /* turn off ctcss */
2019-11-30 16:19:08 +00:00
{
2021-01-12 21:01:54 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " CT%c0%c " , main_sub_vfo ,
2021-01-15 22:48:32 +00:00
cat_term ) ;
2019-11-30 16:19:08 +00:00
}
else
{
2020-12-28 21:17:49 +00:00
if ( is_ft891 | | is_ft991 | | is_ftdx101 | | is_ftdx10 )
2020-10-23 07:35:14 +00:00
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " CN%c0%03d%cCT%c2%c " ,
2020-10-28 13:45:53 +00:00
main_sub_vfo , i , cat_term , main_sub_vfo , cat_term ) ;
2020-10-23 07:35:14 +00:00
}
else
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " CN%c%02d%cCT%c2%c " ,
2020-10-28 13:45:53 +00:00
main_sub_vfo , i , cat_term , main_sub_vfo , cat_term ) ;
2020-10-23 07:35:14 +00:00
}
2008-12-26 00:05:02 +00:00
}
2011-07-09 03:27:06 +00:00
2015-09-29 20:06:12 +00:00
return newcat_set_cmd ( rig ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_get_ctcss_tone ( RIG * rig , vfo_t vfo , tone_t * tone )
2008-09-22 21:34:45 +00:00
{
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2008-12-26 00:05:02 +00:00
int err ;
2009-11-22 21:52:11 +00:00
int t ;
2008-12-26 00:05:02 +00:00
int ret_data_len ;
char * retlvl ;
char cmd [ ] = " CN " ;
char main_sub_vfo = ' 0 ' ;
2011-07-09 03:27:06 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2008-12-26 00:05:02 +00:00
if ( ! newcat_valid_command ( rig , cmd ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2008-12-26 00:05:02 +00:00
err = newcat_set_vfo_from_alias ( rig , & vfo ) ;
2019-11-30 16:19:08 +00:00
2008-12-26 00:05:02 +00:00
if ( err < 0 )
2019-11-30 16:19:08 +00:00
{
2008-12-26 00:05:02 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2008-12-26 00:05:02 +00:00
2020-05-27 17:23:08 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
2019-11-30 16:19:08 +00:00
{
2020-10-06 20:50:37 +00:00
main_sub_vfo = ( RIG_VFO_B = = vfo | | RIG_VFO_SUB = = vfo ) ? ' 1 ' : ' 0 ' ;
2019-11-30 16:19:08 +00:00
}
2008-12-26 00:05:02 +00:00
2020-12-28 21:17:49 +00:00
if ( is_ft891 | | is_ft991 | | is_ftdx101 | | is_ftdx10 )
2020-10-23 07:35:14 +00:00
{
2020-10-28 13:45:53 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%c0%c " , cmd , main_sub_vfo ,
cat_term ) ;
2020-10-23 07:35:14 +00:00
}
else
{
2020-10-28 13:45:53 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%c%c " , cmd , main_sub_vfo ,
cat_term ) ;
2020-10-23 07:35:14 +00:00
}
2008-12-26 00:05:02 +00:00
2008-12-26 11:34:24 +00:00
/* Get CTCSS TONE */
2019-11-30 16:19:08 +00:00
if ( RIG_OK ! = ( err = newcat_get_cmd ( rig ) ) )
{
2008-12-26 00:05:02 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 20:59:12 +00:00
2008-12-26 00:05:02 +00:00
ret_data_len = strlen ( priv - > ret_data ) ;
/* skip command */
2019-11-30 16:19:08 +00:00
retlvl = priv - > ret_data + strlen ( priv - > cmd_str ) - 1 ;
2008-12-26 00:05:02 +00:00
/* chop term */
2019-11-30 16:19:08 +00:00
priv - > ret_data [ ret_data_len - 1 ] = ' \0 ' ;
2008-12-26 00:05:02 +00:00
t = atoi ( retlvl ) ; /* tone index */
if ( t < 0 | | t > 49 )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2008-12-26 00:05:02 +00:00
* tone = rig - > caps - > ctcss_list [ t ] ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_set_dcs_sql ( RIG * rig , vfo_t vfo , tone_t code )
2008-09-22 21:34:45 +00:00
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_get_dcs_sql ( RIG * rig , vfo_t vfo , tone_t * code )
2008-09-22 21:34:45 +00:00
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_set_tone_sql ( RIG * rig , vfo_t vfo , tone_t tone )
2008-09-22 21:34:45 +00:00
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_get_tone_sql ( RIG * rig , vfo_t vfo , tone_t * tone )
2008-09-22 21:34:45 +00:00
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_set_ctcss_sql ( RIG * rig , vfo_t vfo , tone_t tone )
2008-09-22 21:34:45 +00:00
{
2008-12-26 00:05:02 +00:00
int err ;
2009-01-07 00:50:53 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2009-01-07 00:50:53 +00:00
2008-12-26 00:05:02 +00:00
err = newcat_set_ctcss_tone ( rig , vfo , tone ) ;
2019-11-30 16:19:08 +00:00
2014-10-18 19:31:47 +00:00
if ( err ! = RIG_OK )
2019-11-30 16:19:08 +00:00
{
2008-12-26 00:05:02 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2008-09-22 21:34:45 +00:00
2008-12-26 00:05:02 +00:00
/* Change to sql */
2019-11-30 16:19:08 +00:00
if ( tone )
{
2020-12-28 21:17:49 +00:00
err = newcat_set_func ( rig , vfo , RIG_FUNC_TSQL , TRUE ) ;
2019-11-30 16:19:08 +00:00
2014-10-18 19:31:47 +00:00
if ( err ! = RIG_OK )
2019-11-30 16:19:08 +00:00
{
2008-12-26 00:05:02 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2008-12-26 00:05:02 +00:00
}
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_get_ctcss_sql ( RIG * rig , vfo_t vfo , tone_t * tone )
2008-09-22 21:34:45 +00:00
{
2008-12-26 00:05:02 +00:00
int err ;
2009-01-07 00:50:53 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2009-01-07 00:50:53 +00:00
2008-12-26 00:05:02 +00:00
err = newcat_get_ctcss_tone ( rig , vfo , tone ) ;
2009-01-07 00:50:53 +00:00
2008-12-26 00:05:02 +00:00
return err ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_power2mW ( RIG * rig , unsigned int * mwpower , float power , freq_t freq ,
rmode_t mode )
2008-09-22 21:34:45 +00:00
{
2008-12-31 18:17:56 +00:00
int rig_id ;
2011-07-09 03:27:06 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-12-30 18:52:32 +00:00
2021-01-17 13:25:28 +00:00
rig_id = newcat_get_rigid ( rig ) ;
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
switch ( rig_id )
{
case NC_RIGID_FT450 :
/* 100 Watts */
* mwpower = power * 100000 ;
2020-03-20 12:51:32 +00:00
rig_debug ( RIG_DEBUG_TRACE , " case FT450 - rig_id = %d, *mwpower = %u \n " , rig_id ,
2019-11-30 16:19:08 +00:00
* mwpower ) ;
break ;
case NC_RIGID_FT950 :
/* 100 Watts */
* mwpower = power * 100000 ; /* 0..100 Linear scale */
rig_debug ( RIG_DEBUG_TRACE ,
2020-03-20 12:51:32 +00:00
" case FT950 - rig_id = %d, power = %f, *mwpower = %u \n " , rig_id , power ,
2019-11-30 16:19:08 +00:00
* mwpower ) ;
break ;
case NC_RIGID_FT2000 :
/* 100 Watts */
* mwpower = power * 100000 ;
2020-03-20 12:51:32 +00:00
rig_debug ( RIG_DEBUG_TRACE , " case FT2000 - rig_id = %d, *mwpower = %u \n " , rig_id ,
2019-11-30 16:19:08 +00:00
* mwpower ) ;
break ;
case NC_RIGID_FT2000D :
/* 200 Watts */
* mwpower = power * 200000 ;
2020-03-20 12:51:32 +00:00
rig_debug ( RIG_DEBUG_TRACE , " case FT2000D - rig_id = %d, *mwpower = %u \n " ,
2019-11-30 16:19:08 +00:00
rig_id , * mwpower ) ;
break ;
case NC_RIGID_FTDX5000 :
/* 200 Watts */
* mwpower = power * 200000 ;
2020-03-20 12:51:32 +00:00
rig_debug ( RIG_DEBUG_TRACE , " case FTDX5000 - rig_id = %d, *mwpower = %u \n " ,
2019-11-30 16:19:08 +00:00
rig_id , * mwpower ) ;
break ;
case NC_RIGID_FTDX9000D :
/* 200 Watts */
* mwpower = power * 200000 ;
2020-03-20 12:51:32 +00:00
rig_debug ( RIG_DEBUG_TRACE , " case FTDX9000D - rig_id = %d, *mwpower = %u \n " ,
2019-11-30 16:19:08 +00:00
rig_id , * mwpower ) ;
break ;
case NC_RIGID_FTDX9000Contest :
/* 200 Watts */
* mwpower = power * 200000 ;
rig_debug ( RIG_DEBUG_TRACE ,
2020-03-20 12:51:32 +00:00
" case FTDX9000Contest - rig_id = %d, *mwpower = %u \n " , rig_id , * mwpower ) ;
2019-11-30 16:19:08 +00:00
break ;
case NC_RIGID_FTDX9000MP :
/* 400 Watts */
* mwpower = power * 400000 ;
2020-03-20 12:51:32 +00:00
rig_debug ( RIG_DEBUG_TRACE , " case FTDX9000MP - rig_id = %d, *mwpower = %u \n " ,
2019-11-30 16:19:08 +00:00
rig_id , * mwpower ) ;
break ;
2020-10-26 08:06:38 +00:00
case NC_RIGID_FTDX1200 :
2019-11-30 16:19:08 +00:00
/* 100 Watts */
* mwpower = power * 100000 ;
2020-10-28 13:45:53 +00:00
rig_debug ( RIG_DEBUG_TRACE , " case FTDX1200 - rig_id = %d, *mwpower = %d \n " ,
rig_id ,
2019-11-30 16:19:08 +00:00
* mwpower ) ;
break ;
default :
/* 100 Watts */
* mwpower = power * 100000 ;
2020-03-20 12:51:32 +00:00
rig_debug ( RIG_DEBUG_TRACE , " default - rig_id = %d, *mwpower = %u \n " , rig_id ,
2019-11-30 16:19:08 +00:00
* mwpower ) ;
2008-12-28 00:25:31 +00:00
}
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_mW2power ( RIG * rig , float * power , unsigned int mwpower , freq_t freq ,
rmode_t mode )
2008-09-22 21:34:45 +00:00
{
2008-12-31 18:17:56 +00:00
int rig_id ;
2011-07-09 03:27:06 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-12-30 18:52:32 +00:00
2021-01-17 13:25:28 +00:00
rig_id = newcat_get_rigid ( rig ) ;
2008-12-28 00:25:31 +00:00
2019-11-30 16:19:08 +00:00
switch ( rig_id )
{
case NC_RIGID_FT450 :
/* 100 Watts */
* power = mwpower / 100000.0 ;
rig_debug ( RIG_DEBUG_TRACE , " case FT450 - rig_id = %d, *power = %f \n " , rig_id ,
* power ) ;
break ;
case NC_RIGID_FT950 :
/* 100 Watts */
* power = mwpower / 100000.0 ; /* 0..100 Linear scale */
rig_debug ( RIG_DEBUG_TRACE ,
2020-03-20 12:51:32 +00:00
" case FT950 - rig_id = %d, mwpower = %u, *power = %f \n " , rig_id , mwpower ,
2019-11-30 16:19:08 +00:00
* power ) ;
break ;
case NC_RIGID_FT2000 :
/* 100 Watts */
* power = mwpower / 100000.0 ;
rig_debug ( RIG_DEBUG_TRACE , " case FT2000 - rig_id = %d, *power = %f \n " , rig_id ,
* power ) ;
break ;
case NC_RIGID_FT2000D :
/* 200 Watts */
* power = mwpower / 200000.0 ;
rig_debug ( RIG_DEBUG_TRACE , " case FT2000D - rig_id = %d, *power = %f \n " , rig_id ,
* power ) ;
break ;
case NC_RIGID_FTDX5000 :
/* 200 Watts */
* power = mwpower / 200000.0 ;
rig_debug ( RIG_DEBUG_TRACE , " case FTDX5000 - rig_id = %d, *power = %f \n " , rig_id ,
* power ) ;
break ;
case NC_RIGID_FTDX9000D :
/* 200 Watts */
* power = mwpower / 200000.0 ;
rig_debug ( RIG_DEBUG_TRACE , " case FTDX9000D - rig_id = %d, *power = %f \n " ,
rig_id , * power ) ;
break ;
case NC_RIGID_FTDX9000Contest :
/* 200 Watts */
* power = mwpower / 200000.0 ;
rig_debug ( RIG_DEBUG_TRACE , " case FTDX9000Contest - rig_id = %d, *power = %f \n " ,
rig_id , * power ) ;
break ;
case NC_RIGID_FTDX9000MP :
/* 400 Watts */
* power = mwpower / 400000.0 ;
rig_debug ( RIG_DEBUG_TRACE , " case FTDX9000MP - rig_id = %d, *power = %f \n " ,
rig_id , * power ) ;
break ;
2020-10-26 08:06:38 +00:00
case NC_RIGID_FTDX1200 :
2019-11-30 16:19:08 +00:00
/* 100 Watts */
* power = mwpower / 100000.0 ;
2020-10-26 08:06:38 +00:00
rig_debug ( RIG_DEBUG_TRACE , " case FTDX1200 - rig_id = %d, *power = %f \n " , rig_id ,
2019-11-30 16:19:08 +00:00
* power ) ;
break ;
default :
/* 100 Watts */
* power = mwpower / 100000.0 ;
rig_debug ( RIG_DEBUG_TRACE , " default - rig_id = %d, *power = %f \n " , rig_id ,
* power ) ;
2008-12-28 00:25:31 +00:00
}
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_set_powerstat ( RIG * rig , powerstat_t status )
2008-09-22 21:34:45 +00:00
{
2014-10-12 16:02:24 +00:00
struct rig_state * state = & rig - > state ;
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2020-12-09 22:58:16 +00:00
int retval ;
2020-12-22 14:34:04 +00:00
int i = 0 ;
2020-12-09 22:58:16 +00:00
int retry_save ;
2008-12-27 08:08:47 +00:00
char ps ;
2011-07-09 03:27:06 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2008-12-27 08:08:47 +00:00
if ( ! newcat_valid_command ( rig , " PS " ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2008-12-27 08:08:47 +00:00
2019-11-30 16:19:08 +00:00
switch ( status )
{
case RIG_POWER_ON :
ps = ' 1 ' ;
2019-12-24 21:01:08 +00:00
// when powering on need a dummy byte to wake it up
// then sleep from 1 to 2 seconds so we'll do 1.5 secs
write_block ( & state - > rigport , " \n " , 1 ) ;
2020-01-08 05:18:56 +00:00
hl_usleep ( 1500000 ) ;
2019-11-30 16:19:08 +00:00
break ;
case RIG_POWER_OFF :
case RIG_POWER_STANDBY :
ps = ' 0 ' ;
break ;
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2008-12-27 08:08:47 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " PS%c%c " , ps , cat_term ) ;
2019-11-30 16:19:08 +00:00
2020-12-09 22:58:16 +00:00
retval = write_block ( & state - > rigport , priv - > cmd_str , strlen ( priv - > cmd_str ) ) ;
2020-12-17 21:07:04 +00:00
2020-12-09 22:58:16 +00:00
retry_save = rig - > state . rigport . retry ;
rig - > state . rigport . retry = 0 ;
2014-10-12 16:02:24 +00:00
2020-12-09 22:58:16 +00:00
if ( status = = RIG_POWER_ON ) // wait for wakeup only
{
for ( i = 0 ; i < 8 ; + + i ) // up to ~10 seconds including the timeouts
{
freq_t freq ;
hl_usleep ( 1000000 ) ;
retval = rig_get_freq ( rig , RIG_VFO_A , & freq ) ;
2020-12-17 21:07:04 +00:00
if ( retval = = RIG_OK )
{
2020-12-10 00:09:49 +00:00
rig - > state . rigport . retry = retry_save ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( retval ) ;
2020-12-17 21:07:04 +00:00
}
2020-12-09 22:58:16 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: Wait #%d for power up \n " , __func__ , i + 1 ) ;
}
}
rig - > state . rigport . retry = retry_save ;
if ( i = = 9 )
{
rig_debug ( RIG_DEBUG_TRACE , " %s: timeout waiting for powerup, try %d \n " ,
__func__ ,
i + 1 ) ;
retval = - RIG_ETIMEOUT ;
}
2021-01-17 13:25:28 +00:00
RETURNFUNC ( retval ) ;
2008-09-22 21:34:45 +00:00
}
2008-12-28 00:25:31 +00:00
/*
* This functions returns an error if the rig is off , dah
*/
2019-11-30 16:19:08 +00:00
int newcat_get_powerstat ( RIG * rig , powerstat_t * status )
2008-09-22 21:34:45 +00:00
{
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2008-12-27 08:08:47 +00:00
int err ;
char ps ;
char command [ ] = " PS " ;
2011-07-09 03:27:06 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2008-12-28 00:25:31 +00:00
* status = RIG_POWER_OFF ;
2008-12-27 08:08:47 +00:00
if ( ! newcat_valid_command ( rig , command ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2008-12-27 08:08:47 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%c " , command , cat_term ) ;
2019-11-30 16:19:08 +00:00
2008-12-27 08:08:47 +00:00
/* Get Power status */
2019-11-30 16:19:08 +00:00
if ( RIG_OK ! = ( err = newcat_get_cmd ( rig ) ) )
{
2008-12-27 08:08:47 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2008-12-27 08:08:47 +00:00
ps = priv - > ret_data [ 2 ] ;
2019-11-30 16:19:08 +00:00
switch ( ps )
{
case ' 1 ' :
* status = RIG_POWER_ON ;
break ;
case ' 0 ' :
* status = RIG_POWER_OFF ;
break ;
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2008-12-27 08:08:47 +00:00
}
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_reset ( RIG * rig , reset_t reset )
2008-09-22 21:34:45 +00:00
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2008-09-22 21:34:45 +00:00
}
2020-01-21 23:53:12 +00:00
int newcat_set_ant ( RIG * rig , vfo_t vfo , ant_t ant , value_t option )
2008-09-22 21:34:45 +00:00
{
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2008-11-27 07:45:23 +00:00
int err ;
2008-11-28 22:59:08 +00:00
char which_ant ;
2009-11-22 21:52:11 +00:00
char command [ ] = " AN " ;
2009-01-07 00:50:53 +00:00
char main_sub_vfo = ' 0 ' ;
2011-07-09 03:27:06 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-11-28 22:59:08 +00:00
if ( ! newcat_valid_command ( rig , command ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2008-11-28 22:59:08 +00:00
2009-01-07 00:50:53 +00:00
/* Main or SUB vfo */
2008-12-15 21:52:36 +00:00
err = newcat_set_vfo_from_alias ( rig , & vfo ) ;
2019-11-30 16:19:08 +00:00
2008-12-15 21:52:36 +00:00
if ( err < 0 )
2019-11-30 16:19:08 +00:00
{
2008-12-15 21:52:36 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 00:50:53 +00:00
2021-01-08 13:16:45 +00:00
if ( ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_ANT ) )
2019-11-30 16:19:08 +00:00
{
2020-10-06 20:50:37 +00:00
main_sub_vfo = ( RIG_VFO_B = = vfo | | RIG_VFO_SUB = = vfo ) ? ' 1 ' : ' 0 ' ;
2008-11-27 07:45:23 +00:00
}
2008-11-28 22:59:08 +00:00
2019-11-30 16:19:08 +00:00
switch ( ant )
{
case RIG_ANT_1 :
which_ant = ' 1 ' ;
break ;
case RIG_ANT_2 :
which_ant = ' 2 ' ;
break ;
case RIG_ANT_3 :
2020-10-26 08:06:38 +00:00
if ( newcat_is_rig ( rig , RIG_MODEL_FT950 ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2019-11-30 16:19:08 +00:00
}
2020-10-26 08:06:38 +00:00
if ( newcat_is_rig ( rig , RIG_MODEL_FTDX1200 ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2019-11-30 16:19:08 +00:00
}
which_ant = ' 3 ' ;
break ;
case RIG_ANT_4 :
if ( newcat_is_rig ( rig , RIG_MODEL_FT950 ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2019-11-30 16:19:08 +00:00
}
2020-10-26 08:06:38 +00:00
if ( newcat_is_rig ( rig , RIG_MODEL_FTDX1200 ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2019-11-30 16:19:08 +00:00
}
which_ant = ' 4 ' ;
break ;
case RIG_ANT_5 :
if ( newcat_is_rig ( rig , RIG_MODEL_FT950 ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2019-11-30 16:19:08 +00:00
}
2020-10-26 08:06:38 +00:00
if ( newcat_is_rig ( rig , RIG_MODEL_FTDX1200 ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2019-11-30 16:19:08 +00:00
}
/* RX only, on FT-2000/FT-5000/FT-9000 */
which_ant = ' 5 ' ;
break ;
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%c%c%c " , command ,
main_sub_vfo , which_ant , cat_term ) ;
return newcat_set_cmd ( rig ) ;
2008-09-22 21:34:45 +00:00
}
2020-02-23 17:26:09 +00:00
int newcat_get_ant ( RIG * rig , vfo_t vfo , ant_t dummy , value_t * option ,
ant_t * ant_curr , ant_t * ant_tx , ant_t * ant_rx )
2008-09-22 21:34:45 +00:00
{
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2008-11-27 07:45:23 +00:00
int err ;
char c ;
2008-11-28 22:59:08 +00:00
char command [ ] = " AN " ;
2008-12-15 21:52:36 +00:00
char main_sub_vfo = ' 0 ' ;
2011-07-09 03:27:06 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2008-11-28 22:59:08 +00:00
if ( ! newcat_valid_command ( rig , command ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2008-11-28 22:59:08 +00:00
2009-01-07 00:50:53 +00:00
/* Set Main or SUB vfo */
2008-12-15 21:52:36 +00:00
err = newcat_set_vfo_from_alias ( rig , & vfo ) ;
2019-11-30 16:19:08 +00:00
2008-12-15 21:52:36 +00:00
if ( err < 0 )
2019-11-30 16:19:08 +00:00
{
2008-12-15 21:52:36 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 00:50:53 +00:00
2021-01-08 07:12:29 +00:00
if ( ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE ) & & ! is_ft2000 )
2019-11-30 16:19:08 +00:00
{
2020-10-06 20:50:37 +00:00
main_sub_vfo = ( RIG_VFO_B = = vfo | | RIG_VFO_SUB = = vfo ) ? ' 1 ' : ' 0 ' ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%c%c " , command , main_sub_vfo ,
cat_term ) ;
2009-01-07 00:50:53 +00:00
2008-11-27 07:45:23 +00:00
/* Get ANT */
2019-11-30 16:19:08 +00:00
if ( RIG_OK ! = ( err = newcat_get_cmd ( rig ) ) )
{
2008-11-27 07:45:23 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 20:59:12 +00:00
2008-11-27 07:45:23 +00:00
c = priv - > ret_data [ 3 ] ;
2019-11-30 16:19:08 +00:00
switch ( c )
{
case ' 1 ' :
2020-02-19 05:10:14 +00:00
* ant_curr = RIG_ANT_1 ;
2019-11-30 16:19:08 +00:00
break ;
case ' 2 ' :
2020-02-19 05:10:14 +00:00
* ant_curr = RIG_ANT_2 ;
2019-11-30 16:19:08 +00:00
break ;
case ' 3 ' :
2020-02-19 05:10:14 +00:00
* ant_curr = RIG_ANT_3 ;
2019-11-30 16:19:08 +00:00
break ;
case ' 4 ' :
2020-02-19 05:10:14 +00:00
* ant_curr = RIG_ANT_4 ;
2019-11-30 16:19:08 +00:00
break ;
case ' 5 ' :
2020-02-19 05:10:14 +00:00
* ant_curr = RIG_ANT_5 ;
2019-11-30 16:19:08 +00:00
break ;
default :
2020-02-19 05:10:14 +00:00
* ant_curr = RIG_ANT_UNKNOWN ;
2019-11-30 16:19:08 +00:00
return - RIG_EPROTO ;
2008-11-27 07:45:23 +00:00
}
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_set_level ( RIG * rig , vfo_t vfo , setting_t level , value_t val )
2008-09-22 21:34:45 +00:00
{
2014-10-12 16:02:24 +00:00
struct rig_state * state = & rig - > state ;
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2009-01-07 00:50:53 +00:00
int err ;
int i ;
int scale ;
int fpf ;
char main_sub_vfo = ' 0 ' ;
2020-09-28 14:11:14 +00:00
char * format ;
2009-01-07 00:50:53 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2009-01-07 00:50:53 +00:00
/* Set Main or SUB vfo */
2008-12-15 21:52:36 +00:00
err = newcat_set_vfo_from_alias ( rig , & vfo ) ;
2019-11-30 16:19:08 +00:00
2008-12-15 21:52:36 +00:00
if ( err < 0 )
2019-11-30 16:19:08 +00:00
{
2008-12-15 21:52:36 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2008-12-19 19:30:54 +00:00
2020-10-12 14:35:57 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_LEVEL )
2019-11-30 16:19:08 +00:00
{
2020-10-06 20:50:37 +00:00
main_sub_vfo = ( RIG_VFO_B = = vfo | | RIG_VFO_SUB = = vfo ) ? ' 1 ' : ' 0 ' ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 00:50:53 +00:00
2019-11-30 16:19:08 +00:00
switch ( level )
{
case RIG_LEVEL_RFPOWER :
if ( ! newcat_valid_command ( rig , " PC " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2020-10-28 13:45:53 +00:00
if ( is_ft950 | | is_ftdx1200 | | is_ftdx3000 | | is_ft891 | | is_ft991
2020-12-28 21:17:49 +00:00
| | is_ftdx101 | | is_ftdx10 )
2020-10-23 08:56:14 +00:00
{
scale = 100. ;
}
else if ( is_ft450 & & newcat_get_rigid ( rig ) = = NC_RIGID_FT450D )
{
scale = 100. ;
}
else
{
scale = 255. ;
}
2019-11-30 16:19:08 +00:00
fpf = newcat_scale_float ( scale , val . f ) ;
2020-10-07 04:14:27 +00:00
2020-12-28 21:17:49 +00:00
if ( is_ft950 | | is_ft891 | | is_ft991 | | is_ftdx3000 | | is_ftdx101 | | is_ftdx10 )
2020-10-23 08:56:14 +00:00
{
// Minimum is 5 watts on these rigs
if ( fpf < 5 )
{
fpf = 5 ;
}
}
2020-10-07 04:14:27 +00:00
2019-11-30 16:19:08 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " PC%03d%c " , fpf , cat_term ) ;
break ;
case RIG_LEVEL_AF :
if ( ! newcat_valid_command ( rig , " AG " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
fpf = newcat_scale_float ( 255 , val . f ) ;
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " AG%c%03d%c " , main_sub_vfo , fpf ,
cat_term ) ;
break ;
case RIG_LEVEL_AGC :
if ( ! newcat_valid_command ( rig , " GT " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
switch ( val . i )
{
2020-11-05 09:05:37 +00:00
case RIG_AGC_OFF :
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " GT00; " ) ;
2009-01-07 00:50:53 +00:00
break ;
2019-11-30 16:19:08 +00:00
2020-11-05 09:05:37 +00:00
case RIG_AGC_FAST :
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " GT01; " ) ;
2009-01-07 00:50:53 +00:00
break ;
2019-11-30 16:19:08 +00:00
2020-11-05 09:05:37 +00:00
case RIG_AGC_MEDIUM :
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " GT02; " ) ;
2009-01-07 00:50:53 +00:00
break ;
2019-11-30 16:19:08 +00:00
2020-11-05 09:05:37 +00:00
case RIG_AGC_SLOW :
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " GT03; " ) ;
2009-01-07 00:50:53 +00:00
break ;
2019-11-30 16:19:08 +00:00
2020-11-05 09:05:37 +00:00
case RIG_AGC_AUTO :
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " GT04; " ) ;
2009-01-07 00:50:53 +00:00
break ;
2020-11-05 09:05:37 +00:00
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2019-11-30 16:19:08 +00:00
}
2020-11-05 09:05:37 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
{
priv - > cmd_str [ 2 ] = main_sub_vfo ;
}
2020-11-30 20:53:55 +00:00
2019-11-30 16:19:08 +00:00
break ;
2021-01-15 22:48:32 +00:00
case RIG_LEVEL_IF :
{
2021-01-12 21:57:49 +00:00
pbwidth_t width ;
rmode_t mode = 0 ;
2019-11-30 16:19:08 +00:00
if ( ! newcat_valid_command ( rig , " IS " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2020-10-07 04:14:27 +00:00
2021-01-12 21:57:49 +00:00
if ( is_ft991 | | is_ftdx5000 | | is_ftdx101 )
{
newcat_get_mode ( rig , vfo , & mode , & width ) ;
}
2020-10-07 04:14:27 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: LEVEL_IF val.i=%d \n " , __func__ , val . i ) ;
2019-11-30 16:19:08 +00:00
if ( abs ( val . i ) > rig - > caps - > max_ifshift )
{
if ( val . i > 0 )
{
val . i = rig - > caps - > max_ifshift ;
2009-01-07 00:50:53 +00:00
}
2019-11-30 16:19:08 +00:00
else
{
val . i = rig - > caps - > max_ifshift * - 1 ;
2009-01-07 00:50:53 +00:00
}
2019-11-30 16:19:08 +00:00
}
2009-01-07 00:50:53 +00:00
2020-12-28 21:17:49 +00:00
if ( is_ftdx101 | | is_ftdx10 )
2020-10-07 04:14:27 +00:00
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " IS%c0%+.4d%c " , main_sub_vfo ,
val . i , cat_term ) ;
}
2020-11-05 09:05:37 +00:00
else if ( is_ft891 )
{
2020-11-30 20:53:55 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " IS0%d%+.4d%c " ,
val . i = = 0 ? 0 : 1 ,
2020-11-05 09:05:37 +00:00
val . i , cat_term ) ;
}
2020-10-07 04:14:27 +00:00
else
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " IS%c%+.4d%c " , main_sub_vfo ,
val . i , cat_term ) ;
}
2019-11-30 16:19:08 +00:00
2020-05-27 17:23:08 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE & & ! is_ft2000 )
2019-11-30 16:19:08 +00:00
{
priv - > cmd_str [ 2 ] = main_sub_vfo ;
}
2020-11-08 11:03:48 +00:00
// Some Yaesu rigs reject this command in AM/FM modes
2021-01-12 21:42:49 +00:00
if ( is_ft991 | | is_ftdx5000 | | is_ftdx101 )
{
2021-01-15 22:48:32 +00:00
if ( mode & RIG_MODE_AM | | mode & RIG_MODE_FM | | mode & RIG_MODE_AMN
| | mode & RIG_MODE_FMN )
2021-01-12 21:42:49 +00:00
{
priv - > question_mark_response_means_rejected = 1 ;
}
}
2021-01-15 22:48:32 +00:00
2019-11-30 16:19:08 +00:00
break ;
2021-01-12 21:57:49 +00:00
}
2019-11-30 16:19:08 +00:00
2020-11-30 20:53:55 +00:00
case RIG_LEVEL_CWPITCH :
{
2020-11-04 22:07:53 +00:00
int kp ;
2020-11-30 20:53:55 +00:00
2019-11-30 16:19:08 +00:00
if ( ! newcat_valid_command ( rig , " KP " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
if ( val . i < 300 )
{
i = 300 ;
}
else if ( val . i > 1050 )
{
i = 1050 ;
}
else
{
i = val . i ;
}
2020-11-04 22:07:53 +00:00
if ( is_ft950 | | is_ft2000 )
{
kp = ( i - 300 ) / 50 ;
}
else
{
// Most Yaesu rigs seem to use range of 0-75 to represent pitch of 300..1050 Hz in 10 Hz steps
kp = ( i - 300 ) / 10 ;
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " KP%02d%c " , kp , cat_term ) ;
2019-11-30 16:19:08 +00:00
break ;
2020-11-04 22:07:53 +00:00
}
2019-11-30 16:19:08 +00:00
case RIG_LEVEL_KEYSPD :
if ( ! newcat_valid_command ( rig , " KS " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " KS%03d%c " , val . i , cat_term ) ;
break ;
2021-01-15 22:48:32 +00:00
case RIG_LEVEL_MICGAIN :
{
2021-01-12 21:57:49 +00:00
pbwidth_t width ;
rmode_t mode = 0 ;
2019-11-30 16:19:08 +00:00
if ( ! newcat_valid_command ( rig , " MG " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2021-01-12 21:57:49 +00:00
if ( is_ft991 | | is_ftdx5000 | | is_ftdx101 )
{
newcat_get_mode ( rig , vfo , & mode , & width ) ;
}
2021-01-04 18:09:28 +00:00
if ( is_ftdx1200 | | is_ftdx3000 | | is_ft891 | | is_ft991 | | is_ftdx101
| | is_ftdx10 )
2019-11-30 16:19:08 +00:00
{
fpf = newcat_scale_float ( 100 , val . f ) ;
}
else
{
2009-01-07 00:50:53 +00:00
fpf = newcat_scale_float ( 255 , val . f ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " MG%03d%c " , fpf , cat_term ) ;
2020-11-08 11:03:48 +00:00
// Some Yaesu rigs reject this command in RTTY modes
2021-01-12 21:42:49 +00:00
if ( is_ft991 | | is_ftdx5000 | | is_ftdx101 )
{
if ( mode & RIG_MODE_RTTY | | mode & RIG_MODE_RTTYR )
{
priv - > question_mark_response_means_rejected = 1 ;
}
}
2021-01-15 22:48:32 +00:00
2019-11-30 16:19:08 +00:00
break ;
2021-01-12 21:57:49 +00:00
}
2019-11-30 16:19:08 +00:00
case RIG_LEVEL_METER :
if ( ! newcat_valid_command ( rig , " MS " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2020-10-02 03:51:31 +00:00
2020-10-26 08:06:38 +00:00
if ( is_ftdx101 ) // new format for the command with VFO selection
2020-09-28 14:11:14 +00:00
{
format = " MS0%d; " ;
2020-10-02 03:51:31 +00:00
2020-09-28 14:11:14 +00:00
if ( vfo = = RIG_VFO_SUB )
{
format = " MS1%d " ;
}
}
else
{
format = " MS%d " ;
}
2020-10-05 16:11:43 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: format=%s \n " , __func__ , format ) ;
2019-11-30 16:19:08 +00:00
switch ( val . i )
{
2020-09-28 14:11:14 +00:00
case RIG_METER_ALC : snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , format , 1 ) ;
2009-01-07 00:50:53 +00:00
break ;
2019-11-30 16:19:08 +00:00
case RIG_METER_PO :
if ( newcat_is_rig ( rig , RIG_MODEL_FT950 ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2009-01-07 00:50:53 +00:00
}
2019-11-30 16:19:08 +00:00
else
{
2020-09-28 14:11:14 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , format , 2 ) ;
2009-01-07 00:50:53 +00:00
}
2019-11-30 16:19:08 +00:00
2009-01-07 00:50:53 +00:00
break ;
2019-11-30 16:19:08 +00:00
2020-09-28 14:11:14 +00:00
case RIG_METER_SWR : snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , format , 3 ) ;
2009-01-07 00:50:53 +00:00
break ;
2019-11-30 16:19:08 +00:00
2020-09-28 14:11:14 +00:00
case RIG_METER_COMP : snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , format , 0 ) ;
2009-01-07 00:50:53 +00:00
break ;
2019-11-30 16:19:08 +00:00
2020-09-28 14:11:14 +00:00
case RIG_METER_IC : snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , format , 4 ) ;
2009-01-07 00:50:53 +00:00
break ;
2019-11-30 16:19:08 +00:00
2020-09-28 14:11:14 +00:00
case RIG_METER_VDD : snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , format , 5 ) ;
2009-01-07 00:50:53 +00:00
break ;
2019-11-30 16:19:08 +00:00
2020-10-05 16:11:43 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: unknown val.i=%d \n " , __func__ , val . i ) ;
2021-01-17 13:25:28 +00:00
default : RETURNFUNC ( - RIG_EINVAL ) ;
2019-11-30 16:19:08 +00:00
}
break ;
case RIG_LEVEL_PREAMP :
if ( ! newcat_valid_command ( rig , " PA " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
if ( val . i = = 0 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " PA00%c " , cat_term ) ;
2020-05-27 17:23:08 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE & & ! is_ft2000 )
2019-11-30 16:19:08 +00:00
{
2009-01-07 20:59:12 +00:00
priv - > cmd_str [ 2 ] = main_sub_vfo ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 00:50:53 +00:00
break ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 00:50:53 +00:00
2019-11-30 16:19:08 +00:00
priv - > cmd_str [ 0 ] = ' \0 ' ;
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
for ( i = 0 ; state - > preamp [ i ] ! = RIG_DBLST_END ; i + + )
2020-11-05 09:05:37 +00:00
{
2019-11-30 16:19:08 +00:00
if ( state - > preamp [ i ] = = val . i )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " PA0%d%c " , i + 1 , cat_term ) ;
break ;
}
2020-11-05 09:05:37 +00:00
}
2008-09-22 21:34:45 +00:00
2020-11-05 09:05:37 +00:00
if ( strlen ( priv - > cmd_str ) = = 0 )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-11-05 09:05:37 +00:00
}
2008-11-01 22:39:07 +00:00
2020-11-05 09:05:37 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
{
priv - > cmd_str [ 2 ] = main_sub_vfo ;
2019-11-30 16:19:08 +00:00
}
2008-09-22 21:34:45 +00:00
2020-11-05 09:05:37 +00:00
break ;
2008-11-01 22:39:07 +00:00
2019-11-30 16:19:08 +00:00
case RIG_LEVEL_ATT :
if ( ! newcat_valid_command ( rig , " RA " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 00:50:53 +00:00
2019-11-30 16:19:08 +00:00
if ( val . i = = 0 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " RA00%c " , cat_term ) ;
2009-01-07 00:50:53 +00:00
2020-05-27 17:23:08 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE & & ! is_ft2000 )
2019-11-30 16:19:08 +00:00
{
2009-01-07 20:59:12 +00:00
priv - > cmd_str [ 2 ] = main_sub_vfo ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 00:50:53 +00:00
break ;
2019-11-30 16:19:08 +00:00
}
priv - > cmd_str [ 0 ] = ' \0 ' ;
for ( i = 0 ; state - > attenuator [ i ] ! = RIG_DBLST_END ; i + + )
2020-11-05 09:05:37 +00:00
{
2019-11-30 16:19:08 +00:00
if ( state - > attenuator [ i ] = = val . i )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " RA0%d%c " , i + 1 , cat_term ) ;
2020-11-05 09:05:37 +00:00
break ;
2019-11-30 16:19:08 +00:00
}
2020-11-05 09:05:37 +00:00
}
2019-11-30 16:19:08 +00:00
2020-11-05 09:05:37 +00:00
if ( strlen ( priv - > cmd_str ) = = 0 )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-11-05 09:05:37 +00:00
}
2019-11-30 16:19:08 +00:00
2020-11-05 09:05:37 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
{
priv - > cmd_str [ 2 ] = main_sub_vfo ;
2019-11-30 16:19:08 +00:00
}
2020-11-05 09:05:37 +00:00
break ;
2019-11-30 16:19:08 +00:00
case RIG_LEVEL_RF :
if ( ! newcat_valid_command ( rig , " RG " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2020-11-05 09:05:37 +00:00
if ( is_ft891 )
{
scale = 30 ;
}
else
{
scale = 255 ;
}
fpf = newcat_scale_float ( scale , val . f ) ;
2019-11-30 16:19:08 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " RG%c%03d%c " , main_sub_vfo , fpf ,
cat_term ) ;
break ;
case RIG_LEVEL_NR :
if ( ! newcat_valid_command ( rig , " RL " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
if ( newcat_is_rig ( rig , RIG_MODEL_FT450 ) )
{
fpf = newcat_scale_float ( 11 , val . f ) ;
if ( fpf < 1 )
{
fpf = 1 ;
}
if ( fpf > 11 )
{
fpf = 11 ;
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " RL0%02d%c " , fpf , cat_term ) ;
}
else
{
fpf = newcat_scale_float ( 15 , val . f ) ;
if ( fpf < 1 )
{
fpf = 1 ;
}
if ( fpf > 15 )
{
fpf = 15 ;
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " RL0%02d%c " , fpf , cat_term ) ;
2020-05-27 17:23:08 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE & & ! is_ft2000 )
2019-11-30 16:19:08 +00:00
{
2009-01-07 20:59:12 +00:00
priv - > cmd_str [ 2 ] = main_sub_vfo ;
2019-11-30 16:19:08 +00:00
}
}
2021-01-15 22:48:32 +00:00
2019-11-30 16:19:08 +00:00
break ;
2009-01-07 00:50:53 +00:00
2019-11-30 16:19:08 +00:00
case RIG_LEVEL_COMP :
if ( ! newcat_valid_command ( rig , " PL " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 20:59:12 +00:00
2020-11-05 09:05:37 +00:00
if ( is_ft2000 | | is_ftdx9000 | | is_ftdx5000 )
2020-11-04 22:07:53 +00:00
{
scale = 255 ;
}
else
{
scale = 100 ;
}
2019-11-30 16:19:08 +00:00
fpf = newcat_scale_float ( scale , val . f ) ;
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " PL%03d%c " , fpf , cat_term ) ;
break ;
2020-11-30 20:53:55 +00:00
case RIG_LEVEL_BKINDL :
{
2020-11-07 13:03:54 +00:00
int millis ;
value_t keyspd ;
2019-11-30 16:19:08 +00:00
if ( ! newcat_valid_command ( rig , " SD " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2020-10-03 21:54:13 +00:00
2020-11-07 13:03:54 +00:00
// Convert 10/ths of dots to milliseconds using the current key speed
err = newcat_get_level ( rig , vfo , RIG_LEVEL_KEYSPD , & keyspd ) ;
2020-11-30 20:53:55 +00:00
2020-11-07 13:03:54 +00:00
if ( err ! = RIG_OK )
2020-10-03 20:45:21 +00:00
{
2020-11-07 13:03:54 +00:00
return err ;
}
2020-10-03 20:45:21 +00:00
2020-11-07 13:03:54 +00:00
millis = dot10ths_to_millis ( val . i , keyspd . i ) ;
2020-10-03 20:45:21 +00:00
2020-12-28 21:17:49 +00:00
if ( is_ftdx101 | | is_ftdx10 )
2020-11-07 13:03:54 +00:00
{
if ( millis < = 30 ) { snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " SD00; " ) ; }
else if ( millis < = 50 ) { snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " SD01; " ) ; }
else if ( millis < = 100 ) { snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " SD02; " ) ; }
else if ( millis < = 150 ) { snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " SD03; " ) ; }
else if ( millis < = 200 ) { snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " SD04; " ) ; }
else if ( millis < = 250 ) { snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " SD05; " ) ; }
else if ( millis > 2900 ) { snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " SD33; " ) ; }
else
{
// This covers 300-2900 06-32
2020-11-30 20:53:55 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " SD%02d; " ,
6 + ( ( millis - 300 ) / 100 ) ) ;
2020-11-07 13:03:54 +00:00
}
2020-10-03 20:45:21 +00:00
}
2020-11-04 22:07:53 +00:00
else if ( is_ftdx5000 )
{
2020-11-07 13:03:54 +00:00
if ( millis < 20 )
2020-11-04 22:07:53 +00:00
{
2020-11-07 13:03:54 +00:00
millis = 20 ;
2020-11-04 22:07:53 +00:00
}
2020-11-30 20:53:55 +00:00
2020-11-07 13:03:54 +00:00
if ( millis > 5000 )
2020-11-04 22:07:53 +00:00
{
2020-11-07 13:03:54 +00:00
millis = 5000 ;
2020-11-04 22:07:53 +00:00
}
2020-11-07 13:03:54 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " SD%04d%c " , millis , cat_term ) ;
2020-11-04 22:07:53 +00:00
}
2020-11-30 20:53:55 +00:00
else if ( is_ft950 | | is_ft450 | | is_ft891 | | is_ft991 | | is_ftdx1200
| | is_ftdx3000 )
2019-11-30 16:19:08 +00:00
{
2020-11-07 13:03:54 +00:00
if ( millis < 30 )
2019-11-30 16:19:08 +00:00
{
2020-11-07 13:03:54 +00:00
millis = 30 ;
2009-01-07 00:50:53 +00:00
}
2020-11-30 20:53:55 +00:00
2020-11-07 13:03:54 +00:00
if ( millis > 3000 )
2019-11-30 16:19:08 +00:00
{
2020-11-07 13:03:54 +00:00
millis = 3000 ;
2009-01-07 00:50:53 +00:00
}
2020-10-03 22:06:09 +00:00
2020-11-07 13:03:54 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " SD%04d%c " , millis , cat_term ) ;
2019-11-30 16:19:08 +00:00
}
2020-11-05 09:05:37 +00:00
else if ( is_ft2000 | | is_ftdx9000 )
2020-11-04 22:07:53 +00:00
{
2020-11-07 13:03:54 +00:00
if ( millis < 0 )
2020-11-04 22:07:53 +00:00
{
2020-11-07 13:03:54 +00:00
millis = 0 ;
2020-11-04 22:07:53 +00:00
}
2020-11-30 20:53:55 +00:00
2020-11-07 13:03:54 +00:00
if ( millis > 5000 )
2020-11-04 22:07:53 +00:00
{
2020-11-07 13:03:54 +00:00
millis = 5000 ;
2020-11-04 22:07:53 +00:00
}
2020-11-07 13:03:54 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " SD%04d%c " , millis , cat_term ) ;
2020-11-04 22:07:53 +00:00
}
2020-10-03 21:54:13 +00:00
else // default
2019-11-30 16:19:08 +00:00
{
2020-11-07 13:03:54 +00:00
if ( millis < 1 )
2019-11-30 16:19:08 +00:00
{
2020-11-07 13:03:54 +00:00
millis = 1 ;
2019-11-30 16:19:08 +00:00
}
2020-11-30 20:53:55 +00:00
2020-11-07 13:03:54 +00:00
if ( millis > 5000 )
2019-11-30 16:19:08 +00:00
{
2020-11-07 13:03:54 +00:00
millis = 5000 ;
2019-11-30 16:19:08 +00:00
}
2020-10-03 22:06:09 +00:00
2020-11-07 13:03:54 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " SD%04d%c " , millis , cat_term ) ;
2019-11-30 16:19:08 +00:00
}
break ;
2020-11-07 13:03:54 +00:00
}
2019-11-30 16:19:08 +00:00
case RIG_LEVEL_SQL :
if ( ! newcat_valid_command ( rig , " SQ " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2020-12-28 21:17:49 +00:00
if ( is_ft891 | | is_ft991 | | is_ftdx101 | | is_ftdx10 )
2020-11-05 09:05:37 +00:00
{
scale = 100 ;
}
else
{
scale = 255 ;
}
fpf = newcat_scale_float ( scale , val . f ) ;
2019-11-30 16:19:08 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " SQ%c%03d%c " , main_sub_vfo , fpf ,
cat_term ) ;
break ;
2020-03-24 15:02:17 +00:00
case RIG_LEVEL_VOXDELAY :
2019-11-30 16:19:08 +00:00
if ( ! newcat_valid_command ( rig , " VD " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2020-10-03 21:54:13 +00:00
/* VOX delay, api int (tenth of seconds), ms for rig */
2020-10-06 13:10:31 +00:00
val . i = val . i * 100 ;
2020-10-07 04:14:27 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: vali=%d \n " , __func__ , val . i ) ;
2020-10-26 08:06:38 +00:00
if ( is_ft950 | | is_ft450 | | is_ftdx1200 )
2019-11-30 16:19:08 +00:00
{
if ( val . i < 100 ) /* min is 30ms but spec is 100ms Unit Intervals */
{
val . i = 30 ;
}
if ( val . i > 3000 )
{
val . i = 3000 ;
}
2020-10-03 21:54:13 +00:00
2020-10-03 21:50:35 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " VD%04d%c " , val . i , cat_term ) ;
}
2020-12-28 21:17:49 +00:00
else if ( is_ftdx101 | | is_ftdx10 ) // new lookup table argument
2020-10-03 21:50:35 +00:00
{
2020-10-07 04:14:27 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: ft101 #1 val.i=%d \n " , __func__ , val . i ) ;
2020-10-03 21:54:13 +00:00
2020-10-06 13:10:31 +00:00
if ( val . i = = 0 ) { val . i = 0 ; }
2020-10-03 21:50:35 +00:00
else if ( val . i < = 100 ) { val . i = 2 ; }
else if ( val . i < = 200 ) { val . i = 4 ; }
else if ( val . i > 3000 ) { val . i = 33 ; }
else { val . i = ( val . i - 300 ) / 100 + 6 ; }
2020-10-07 04:14:27 +00:00
2020-12-28 21:17:49 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: ftdx101/ftdx10 #1 val.i=%d \n " , __func__ , val . i ) ;
2020-10-03 21:50:35 +00:00
2020-10-05 22:03:57 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " VD%02d%c " , val . i , cat_term ) ;
2019-11-30 16:19:08 +00:00
}
2020-05-27 17:23:08 +00:00
else if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
2019-11-30 16:19:08 +00:00
{
if ( val . i < 0 )
{
val . i = 0 ;
}
if ( val . i > 5000 )
{
val . i = 5000 ;
}
2020-10-03 21:54:13 +00:00
2020-10-03 21:50:35 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " VD%04d%c " , val . i , cat_term ) ;
}
else
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " VD%04d%c " , val . i , cat_term ) ;
2019-11-30 16:19:08 +00:00
}
break ;
case RIG_LEVEL_VOXGAIN :
if ( ! newcat_valid_command ( rig , " VG " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2020-11-05 09:05:37 +00:00
if ( is_ft2000 | | is_ftdx9000 | | is_ftdx5000 )
2020-11-04 22:07:53 +00:00
{
scale = 255 ;
}
else
{
scale = 100 ;
}
2019-11-30 16:19:08 +00:00
fpf = newcat_scale_float ( scale , val . f ) ;
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " VG%03d%c " , fpf , cat_term ) ;
break ;
case RIG_LEVEL_ANTIVOX :
2020-12-28 21:17:49 +00:00
if ( is_ftdx101 | | is_ftdx10 )
2019-11-30 16:19:08 +00:00
{
fpf = newcat_scale_float ( 100 , val . f ) ;
2020-11-04 22:07:53 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " AV%03d%c " , fpf , cat_term ) ;
2019-11-30 16:19:08 +00:00
}
2020-11-04 22:07:53 +00:00
else if ( is_ftdx5000 )
2020-10-07 13:17:43 +00:00
{
fpf = newcat_scale_float ( 100 , val . f ) ;
2020-11-04 22:07:53 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX176%03d%c " , fpf , cat_term ) ;
2020-10-07 13:17:43 +00:00
}
2020-11-04 22:07:53 +00:00
else if ( is_ftdx3000 | | is_ftdx1200 )
2019-11-30 16:19:08 +00:00
{
fpf = newcat_scale_float ( 100 , val . f ) ;
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX183%03d%c " , fpf , cat_term ) ;
}
2020-11-04 22:07:53 +00:00
else if ( is_ft991 )
{
fpf = newcat_scale_float ( 100 , val . f ) ;
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX147%03d%c " , fpf , cat_term ) ;
}
else if ( is_ft891 )
{
fpf = newcat_scale_float ( 100 , val . f ) ;
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX1619%03d%c " , fpf , cat_term ) ;
}
else if ( is_ft950 )
{
fpf = newcat_scale_float ( 100 , val . f ) ;
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX117%03d%c " , fpf , cat_term ) ;
}
else if ( is_ft2000 )
{
fpf = newcat_scale_float ( 100 , val . f ) ;
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX042%03d%c " , fpf , cat_term ) ;
}
2019-11-30 16:19:08 +00:00
else
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2019-11-30 16:19:08 +00:00
}
break ;
case RIG_LEVEL_NOTCHF :
if ( ! newcat_valid_command ( rig , " BP " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
val . i = val . i / 10 ;
2020-11-05 09:05:37 +00:00
if ( is_ftdx9000 )
2019-11-30 16:19:08 +00:00
{
2020-11-05 09:05:37 +00:00
if ( val . i < 0 )
{
val . i = 0 ;
}
}
else
{
if ( val . i < 1 )
{
val . i = 1 ;
}
2019-11-30 16:19:08 +00:00
}
2020-12-28 21:17:49 +00:00
if ( is_ft891 | | is_ft991 | | is_ftdx101 | | is_ftdx10 )
2020-11-05 09:05:37 +00:00
{
if ( val . i > 320 )
{
val . i = 320 ;
}
}
2020-11-30 20:53:55 +00:00
2020-11-05 09:05:37 +00:00
if ( is_ft950 | | is_ftdx9000 )
2019-11-30 16:19:08 +00:00
{
if ( val . i > 300 )
{
val . i = 300 ;
}
}
else
{
if ( val . i > 400 )
{
val . i = 400 ;
}
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " BP01%03d%c " , val . i , cat_term ) ;
2020-11-05 09:05:37 +00:00
if ( is_ftdx9000 )
2019-11-30 16:19:08 +00:00
{
2020-11-05 09:05:37 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " BP%03d%c " , val . i , cat_term ) ;
2019-11-30 16:19:08 +00:00
}
2020-11-05 09:05:37 +00:00
else if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
2020-05-26 16:53:47 +00:00
{
2020-11-05 09:05:37 +00:00
priv - > cmd_str [ 2 ] = main_sub_vfo ;
2020-05-26 16:53:47 +00:00
}
2019-11-30 16:19:08 +00:00
break ;
2020-10-22 21:04:43 +00:00
case RIG_LEVEL_MONITOR_GAIN :
if ( ! newcat_valid_command ( rig , " ML " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2020-10-22 21:04:43 +00:00
}
2021-01-04 18:09:28 +00:00
if ( is_ftdx1200 | | is_ftdx3000 | | is_ft891 | | is_ft991 | | is_ftdx101
| | is_ftdx10 )
2020-10-22 21:04:43 +00:00
{
fpf = newcat_scale_float ( 100 , val . f ) ;
}
else
{
fpf = newcat_scale_float ( 255 , val . f ) ;
}
2020-11-05 09:05:37 +00:00
if ( is_ftdx9000 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " ML%03d%c " , fpf , cat_term ) ;
}
else
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " ML1%03d%c " , fpf , cat_term ) ;
}
2020-11-30 20:53:55 +00:00
2020-10-22 21:04:43 +00:00
break ;
2019-11-30 16:19:08 +00:00
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2008-11-01 22:39:07 +00:00
}
2020-11-07 17:47:08 +00:00
err = newcat_set_cmd ( rig ) ;
// Clear flag after executing command
priv - > question_mark_response_means_rejected = 0 ;
return err ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_get_level ( RIG * rig , vfo_t vfo , setting_t level , value_t * val )
2008-09-22 21:34:45 +00:00
{
2019-11-30 16:19:08 +00:00
struct rig_state * state = & rig - > state ;
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2009-01-07 00:50:53 +00:00
int err ;
2019-11-30 16:19:08 +00:00
int ret_data_len ;
char * retlvl ;
2020-10-23 08:47:32 +00:00
int retlvl_len ;
2019-11-30 16:19:08 +00:00
float scale ;
2009-01-07 00:50:53 +00:00
char main_sub_vfo = ' 0 ' ;
2020-11-05 09:05:37 +00:00
int i ;
2008-09-22 21:34:45 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2009-01-07 00:50:53 +00:00
/* Set Main or SUB vfo */
2008-12-15 21:52:36 +00:00
err = newcat_set_vfo_from_alias ( rig , & vfo ) ;
2019-11-30 16:19:08 +00:00
2008-12-15 21:52:36 +00:00
if ( err < 0 )
2019-11-30 16:19:08 +00:00
{
2008-12-15 21:52:36 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 00:50:53 +00:00
2020-10-12 14:35:57 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_LEVEL )
2019-11-30 16:19:08 +00:00
{
2020-10-06 20:50:37 +00:00
main_sub_vfo = ( RIG_VFO_B = = vfo | | RIG_VFO_SUB = = vfo ) ? ' 1 ' : ' 0 ' ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 00:50:53 +00:00
2019-11-30 16:19:08 +00:00
switch ( level )
{
case RIG_LEVEL_RFPOWER :
if ( ! newcat_valid_command ( rig , " PC " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " PC%c " , cat_term ) ;
break ;
case RIG_LEVEL_PREAMP :
if ( ! newcat_valid_command ( rig , " PA " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " PA0%c " , cat_term ) ;
2020-05-27 17:23:08 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
2019-11-30 16:19:08 +00:00
{
2009-01-07 20:59:12 +00:00
priv - > cmd_str [ 2 ] = main_sub_vfo ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 00:50:53 +00:00
2019-11-30 16:19:08 +00:00
break ;
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
case RIG_LEVEL_AF :
if ( ! newcat_valid_command ( rig , " AG " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " AG%c%c " , main_sub_vfo ,
cat_term ) ;
break ;
2009-01-07 00:50:53 +00:00
2019-11-30 16:19:08 +00:00
case RIG_LEVEL_AGC :
if ( ! newcat_valid_command ( rig , " GT " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 00:50:53 +00:00
2019-11-30 16:19:08 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " GT%c%c " , main_sub_vfo ,
cat_term ) ;
break ;
2009-01-07 00:50:53 +00:00
2021-01-15 22:48:32 +00:00
case RIG_LEVEL_IF :
{
2021-01-12 21:57:49 +00:00
pbwidth_t width ;
rmode_t mode = 0 ;
2019-11-30 16:19:08 +00:00
if ( ! newcat_valid_command ( rig , " IS " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2021-01-12 21:57:49 +00:00
if ( is_ft991 | | is_ftdx5000 | | is_ftdx101 )
{
newcat_get_mode ( rig , vfo , & mode , & width ) ;
}
2020-10-07 04:14:27 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " IS%c%c " , main_sub_vfo ,
cat_term ) ;
2019-11-30 16:19:08 +00:00
2020-05-27 17:23:08 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
2019-11-30 16:19:08 +00:00
{
2009-01-07 20:59:12 +00:00
priv - > cmd_str [ 2 ] = main_sub_vfo ;
2019-11-30 16:19:08 +00:00
}
2020-11-30 20:53:55 +00:00
2021-01-12 22:01:10 +00:00
// Some Yaesu rigs reject this command in AM/FM modes
2021-01-12 21:42:49 +00:00
if ( is_ft991 | | is_ftdx5000 | | is_ftdx101 )
{
2021-01-15 22:48:32 +00:00
if ( mode & RIG_MODE_AM | | mode & RIG_MODE_FM | | mode & RIG_MODE_AMN
| | mode & RIG_MODE_FMN )
2021-01-12 21:42:49 +00:00
{
priv - > question_mark_response_means_rejected = 1 ;
}
}
2021-01-15 22:48:32 +00:00
2019-11-30 16:19:08 +00:00
break ;
2021-01-12 21:57:49 +00:00
}
2019-11-30 16:19:08 +00:00
case RIG_LEVEL_CWPITCH :
if ( ! newcat_valid_command ( rig , " KP " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " KP%c " , cat_term ) ;
break ;
case RIG_LEVEL_KEYSPD :
if ( ! newcat_valid_command ( rig , " KS " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " KS%c " , cat_term ) ;
break ;
2021-01-15 22:48:32 +00:00
case RIG_LEVEL_MICGAIN :
{
2021-01-12 22:10:52 +00:00
pbwidth_t width ;
rmode_t mode = 0 ;
2019-11-30 16:19:08 +00:00
if ( ! newcat_valid_command ( rig , " MG " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2021-01-12 22:10:52 +00:00
if ( is_ft991 | | is_ftdx5000 | | is_ftdx101 )
{
newcat_get_mode ( rig , vfo , & mode , & width ) ;
}
2019-11-30 16:19:08 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " MG%c " , cat_term ) ;
2021-01-12 22:10:52 +00:00
// Some Yaesu rigs reject this command in RTTY modes
if ( is_ft991 | | is_ftdx5000 | | is_ftdx101 )
{
if ( mode & RIG_MODE_RTTY | | mode & RIG_MODE_RTTYR )
{
priv - > question_mark_response_means_rejected = 1 ;
}
}
2021-01-15 22:48:32 +00:00
2019-11-30 16:19:08 +00:00
break ;
2021-01-12 22:10:52 +00:00
}
2019-11-30 16:19:08 +00:00
case RIG_LEVEL_METER :
if ( ! newcat_valid_command ( rig , " MS " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " MS%c " , cat_term ) ;
break ;
case RIG_LEVEL_ATT :
if ( ! newcat_valid_command ( rig , " RA " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " RA0%c " , cat_term ) ;
2020-05-27 17:23:08 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
2019-11-30 16:19:08 +00:00
{
2009-01-07 20:59:12 +00:00
priv - > cmd_str [ 2 ] = main_sub_vfo ;
2019-11-30 16:19:08 +00:00
}
break ;
case RIG_LEVEL_RF :
if ( ! newcat_valid_command ( rig , " RG " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " RG%c%c " , main_sub_vfo ,
cat_term ) ;
break ;
case RIG_LEVEL_COMP :
if ( ! newcat_valid_command ( rig , " PL " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " PL%c " , cat_term ) ;
break ;
case RIG_LEVEL_NR :
if ( ! newcat_valid_command ( rig , " RL " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " RL0%c " , cat_term ) ;
2020-05-27 17:23:08 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
2019-11-30 16:19:08 +00:00
{
2009-01-07 20:59:12 +00:00
priv - > cmd_str [ 2 ] = main_sub_vfo ;
2019-11-30 16:19:08 +00:00
}
break ;
case RIG_LEVEL_BKINDL :
if ( ! newcat_valid_command ( rig , " SD " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " SD%c " , cat_term ) ;
break ;
case RIG_LEVEL_SQL :
if ( ! newcat_valid_command ( rig , " SQ " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " SQ%c%c " , main_sub_vfo ,
cat_term ) ;
break ;
2020-03-24 15:02:17 +00:00
case RIG_LEVEL_VOXDELAY :
2019-11-30 16:19:08 +00:00
/* VOX delay, arg int (tenth of seconds) */
if ( ! newcat_valid_command ( rig , " VD " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " VD%c " , cat_term ) ;
break ;
case RIG_LEVEL_VOXGAIN :
if ( ! newcat_valid_command ( rig , " VG " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " VG%c " , cat_term ) ;
break ;
/*
* Read only levels
*/
case RIG_LEVEL_STRENGTH :
case RIG_LEVEL_RAWSTR :
if ( ! newcat_valid_command ( rig , " SM " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " SM%c%c " , main_sub_vfo ,
cat_term ) ;
break ;
case RIG_LEVEL_SWR :
if ( ! newcat_valid_command ( rig , " RM " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2020-10-05 16:11:43 +00:00
2020-10-04 22:14:29 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " RM6%c " , cat_term ) ;
2019-11-30 16:19:08 +00:00
break ;
case RIG_LEVEL_ALC :
if ( ! newcat_valid_command ( rig , " RM " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2020-10-04 22:14:29 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " RM4%c " , cat_term ) ;
2019-11-30 16:19:08 +00:00
break ;
2020-10-23 08:24:09 +00:00
case RIG_LEVEL_RFPOWER_METER :
2020-12-16 23:47:49 +00:00
case RIG_LEVEL_RFPOWER_METER_WATTS :
2020-10-23 08:24:09 +00:00
if ( ! newcat_valid_command ( rig , " RM " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2020-10-23 08:24:09 +00:00
}
2020-12-11 22:12:11 +00:00
if ( is_ftdx9000 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " RM08%c " , cat_term ) ;
}
else
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " RM5%c " , cat_term ) ;
}
2020-12-17 21:07:04 +00:00
2020-10-23 08:24:09 +00:00
break ;
case RIG_LEVEL_COMP_METER :
if ( ! newcat_valid_command ( rig , " RM " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2020-10-23 08:24:09 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " RM3%c " , cat_term ) ;
break ;
case RIG_LEVEL_VD_METER :
if ( ! newcat_valid_command ( rig , " RM " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2020-10-23 08:24:09 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " RM8%c " , cat_term ) ;
break ;
case RIG_LEVEL_ID_METER :
if ( ! newcat_valid_command ( rig , " RM " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2020-10-23 08:24:09 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " RM7%c " , cat_term ) ;
break ;
2019-11-30 16:19:08 +00:00
case RIG_LEVEL_ANTIVOX :
2020-12-28 21:17:49 +00:00
if ( is_ftdx101 | | is_ftdx10 )
2019-11-30 16:19:08 +00:00
{
2020-11-04 22:07:53 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " AV%c " , cat_term ) ;
2019-11-30 16:19:08 +00:00
}
2020-11-04 22:07:53 +00:00
else if ( is_ftdx5000 )
2020-10-07 13:17:43 +00:00
{
2020-11-04 22:07:53 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX176%c " , cat_term ) ;
}
else if ( is_ftdx3000 | | is_ftdx1200 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX183%c " , cat_term ) ;
2020-10-07 13:17:43 +00:00
}
2020-10-26 08:06:38 +00:00
else if ( is_ftdx1200 )
2019-11-30 16:19:08 +00:00
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX183%c " , cat_term ) ;
}
2020-11-04 22:07:53 +00:00
else if ( is_ft991 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX147%c " , cat_term ) ;
}
else if ( is_ft891 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX1619%c " , cat_term ) ;
}
else if ( is_ft950 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX117%c " , cat_term ) ;
}
else if ( is_ft2000 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " EX042%c " , cat_term ) ;
}
2019-11-30 16:19:08 +00:00
else
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2019-11-30 16:19:08 +00:00
}
break ;
case RIG_LEVEL_NOTCHF :
if ( ! newcat_valid_command ( rig , " BP " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " BP01%c " , cat_term ) ;
2020-11-05 09:05:37 +00:00
if ( is_ftdx9000 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " BP%c " , cat_term ) ;
}
else if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
2019-11-30 16:19:08 +00:00
{
priv - > cmd_str [ 2 ] = main_sub_vfo ;
}
break ;
2020-10-22 21:04:43 +00:00
case RIG_LEVEL_MONITOR_GAIN :
if ( ! newcat_valid_command ( rig , " ML " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2020-10-22 21:04:43 +00:00
}
2020-11-05 09:05:37 +00:00
if ( is_ftdx9000 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " ML%c " , cat_term ) ;
}
else
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " ML1%c " , cat_term ) ;
}
2020-11-30 20:53:55 +00:00
2020-10-22 21:04:43 +00:00
break ;
2019-11-30 16:19:08 +00:00
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2009-01-07 00:50:53 +00:00
}
2020-11-07 17:47:08 +00:00
err = newcat_get_cmd ( rig ) ;
2021-01-12 21:42:49 +00:00
// Clear flag after executing command
priv - > question_mark_response_means_rejected = 0 ;
2020-11-07 17:47:08 +00:00
if ( err ! = RIG_OK )
2019-11-30 16:19:08 +00:00
{
2009-01-07 00:50:53 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2009-01-07 00:50:53 +00:00
ret_data_len = strlen ( priv - > ret_data ) ;
/* skip command */
2019-11-30 16:19:08 +00:00
retlvl = priv - > ret_data + strlen ( priv - > cmd_str ) - 1 ;
2020-10-23 08:47:32 +00:00
retlvl_len = strlen ( retlvl ) ;
2009-01-07 00:50:53 +00:00
/* chop term */
2019-11-30 16:19:08 +00:00
priv - > ret_data [ ret_data_len - 1 ] = ' \0 ' ;
2009-01-07 00:50:53 +00:00
2019-11-30 16:19:08 +00:00
switch ( level )
{
case RIG_LEVEL_RFPOWER :
2020-10-28 13:45:53 +00:00
if ( is_ft950 | | is_ftdx1200 | | is_ftdx3000 | | is_ft891 | | is_ft991
2020-12-28 21:17:49 +00:00
| | is_ftdx101 | | is_ftdx10 )
2020-10-23 08:56:14 +00:00
{
scale = 100. ;
}
else if ( is_ft450 & & newcat_get_rigid ( rig ) = = NC_RIGID_FT450D )
{
scale = 100. ;
}
else
{
scale = 255. ;
}
2019-11-30 16:19:08 +00:00
val - > f = ( float ) atoi ( retlvl ) / scale ;
break ;
case RIG_LEVEL_VOXGAIN :
case RIG_LEVEL_COMP :
2020-11-05 09:05:37 +00:00
if ( is_ft2000 | | is_ftdx9000 | | is_ftdx5000 )
2020-11-04 22:07:53 +00:00
{
scale = 255 ;
}
else
{
scale = 100 ;
}
val - > f = ( float ) atoi ( retlvl ) / scale ;
break ;
2019-11-30 16:19:08 +00:00
case RIG_LEVEL_ANTIVOX :
2020-11-04 22:07:53 +00:00
val - > f = ( float ) atoi ( retlvl ) / 100. ;
2019-11-30 16:19:08 +00:00
break ;
2020-07-29 21:03:54 +00:00
case RIG_LEVEL_SWR :
2020-10-28 13:45:53 +00:00
if ( retlvl_len > 3 )
{
2020-10-23 08:47:32 +00:00
// Some rigs like FTDX101 have 6-byte return so we just truncate
retlvl [ 3 ] = 0 ;
}
2020-10-05 16:11:43 +00:00
2020-10-05 15:11:32 +00:00
if ( rig - > caps - > swr_cal . size = = 0 )
2020-07-29 21:03:54 +00:00
{
val - > f = rig_raw2val_float ( atoi ( retlvl ) , & yaesu_default_swr_cal ) ;
}
else
{
val - > f = rig_raw2val_float ( atoi ( retlvl ) , & rig - > caps - > swr_cal ) ;
}
2020-08-28 17:16:17 +00:00
2020-07-29 21:03:54 +00:00
break ;
2020-08-28 17:16:17 +00:00
2020-10-23 08:24:09 +00:00
case RIG_LEVEL_ALC :
2020-10-28 13:45:53 +00:00
if ( retlvl_len > 3 )
{
2020-10-23 08:47:32 +00:00
// Some rigs like FTDX101 have 6-byte return so we just truncate
retlvl [ 3 ] = 0 ;
}
2020-10-23 08:24:09 +00:00
if ( rig - > caps - > alc_cal . size = = 0 )
{
val - > f = rig_raw2val_float ( atoi ( retlvl ) , & yaesu_default_alc_cal ) ;
}
else
{
val - > f = rig_raw2val_float ( atoi ( retlvl ) , & rig - > caps - > alc_cal ) ;
}
2020-10-28 13:45:53 +00:00
2020-10-23 08:24:09 +00:00
break ;
case RIG_LEVEL_RFPOWER_METER :
2020-12-16 23:47:49 +00:00
case RIG_LEVEL_RFPOWER_METER_WATTS :
2020-12-12 14:34:32 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s: RFPOWER_METER retlvl=%s \n " , __func__ , retlvl ) ;
2020-12-17 21:07:04 +00:00
2020-10-28 13:45:53 +00:00
if ( retlvl_len > 3 )
{
2020-10-23 08:47:32 +00:00
// Some rigs like FTDX101 have 6-byte return so we just truncate
2020-12-17 21:07:04 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s: retlvl of %s getting truncated \n " , __func__ ,
retlvl ) ;
2020-10-23 08:47:32 +00:00
retlvl [ 3 ] = 0 ;
2020-12-12 14:24:33 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s: retlvl truncated to %s \n " , __func__ , retlvl ) ;
2020-10-23 08:47:32 +00:00
}
2020-10-23 08:24:09 +00:00
if ( rig - > caps - > rfpower_meter_cal . size = = 0 )
{
2020-12-17 21:07:04 +00:00
val - > f = rig_raw2val_float ( atoi ( retlvl ) ,
& yaesu_default_rfpower_meter_cal ) / ( level = = RIG_LEVEL_RFPOWER_METER_WATTS ?
1.0 : 100.0 ) ;
2020-10-23 08:24:09 +00:00
}
else
{
2020-12-17 21:07:04 +00:00
val - > f = rig_raw2val_float ( atoi ( retlvl ) ,
& rig - > caps - > rfpower_meter_cal ) / ( level = = RIG_LEVEL_RFPOWER_METER_WATTS ? 1.0 :
100.0 ) ;
2021-01-04 18:09:28 +00:00
2021-01-04 20:43:03 +00:00
if ( priv - > rig_id = = NC_RIGID_FT2000 )
2021-01-04 18:09:28 +00:00
{
// we reuse the FT2000D table for the FT2000 so need to divide by 2
// hopefully this works well otherwise we need a separate table
val - > f / = 2 ;
}
2020-10-23 08:24:09 +00:00
}
2020-12-17 21:07:04 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s: RFPOWER_METER=%s, converted to %f \n " ,
__func__ , retlvl , val - > f ) ;
if ( level = = RIG_LEVEL_RFPOWER_METER & & val - > f > 1.0 )
2020-12-12 14:24:33 +00:00
{
2020-12-17 21:07:04 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s: val->f(%f) clipped at 1.0 \n " , __func__ ,
val - > f ) ;
2020-12-12 14:24:33 +00:00
val - > f = 1.0 ;
}
2020-10-28 13:45:53 +00:00
2020-10-23 08:24:09 +00:00
break ;
case RIG_LEVEL_COMP_METER :
2020-10-28 13:45:53 +00:00
if ( retlvl_len > 3 )
{
2020-10-23 08:47:32 +00:00
// Some rigs like FTDX101 have 6-byte return so we just truncate
retlvl [ 3 ] = 0 ;
}
2020-10-23 08:24:09 +00:00
if ( rig - > caps - > comp_meter_cal . size = = 0 )
{
2020-12-17 21:07:04 +00:00
val - > f = rig_raw2val_float ( atoi ( retlvl ) , & yaesu_default_comp_meter_cal ) / 100 ;
2020-10-23 08:24:09 +00:00
}
else
{
2020-12-17 21:07:04 +00:00
val - > f = rig_raw2val_float ( atoi ( retlvl ) , & rig - > caps - > comp_meter_cal ) / 100 ;
2020-10-23 08:24:09 +00:00
}
2020-10-28 13:45:53 +00:00
2020-10-23 08:24:09 +00:00
break ;
case RIG_LEVEL_VD_METER :
2020-10-28 13:45:53 +00:00
if ( retlvl_len > 3 )
{
2020-10-23 08:47:32 +00:00
// Some rigs like FTDX101 have 6-byte return so we just truncate
retlvl [ 3 ] = 0 ;
}
2020-10-23 08:24:09 +00:00
if ( rig - > caps - > vd_meter_cal . size = = 0 )
{
val - > f = rig_raw2val_float ( atoi ( retlvl ) , & yaesu_default_vd_meter_cal ) ;
}
else
{
val - > f = rig_raw2val_float ( atoi ( retlvl ) , & rig - > caps - > vd_meter_cal ) ;
}
2020-10-28 13:45:53 +00:00
2020-10-23 08:24:09 +00:00
break ;
case RIG_LEVEL_ID_METER :
2020-10-28 13:45:53 +00:00
if ( retlvl_len > 3 )
{
2020-10-23 08:47:32 +00:00
// Some rigs like FTDX101 have 6-byte return so we just truncate
retlvl [ 3 ] = 0 ;
}
2020-10-23 08:24:09 +00:00
if ( rig - > caps - > id_meter_cal . size = = 0 )
{
val - > f = rig_raw2val_float ( atoi ( retlvl ) , & yaesu_default_id_meter_cal ) ;
}
else
{
val - > f = rig_raw2val_float ( atoi ( retlvl ) , & rig - > caps - > id_meter_cal ) ;
}
2020-10-28 13:45:53 +00:00
2020-10-23 08:24:09 +00:00
break ;
2019-11-30 16:19:08 +00:00
case RIG_LEVEL_MICGAIN :
2021-01-04 18:09:28 +00:00
if ( is_ftdx1200 | | is_ftdx3000 | | is_ft891 | | is_ft991 | | is_ftdx101
| | is_ftdx10 )
2020-10-22 21:04:43 +00:00
{
scale = 100. ;
}
else
{
scale = 255. ;
}
2020-10-28 13:45:53 +00:00
2020-10-22 21:04:43 +00:00
val - > f = ( float ) atoi ( retlvl ) / scale ;
break ;
case RIG_LEVEL_AF :
2020-11-05 09:05:37 +00:00
val - > f = ( float ) atoi ( retlvl ) / 255 ;
break ;
2019-11-30 16:19:08 +00:00
case RIG_LEVEL_RF :
2020-11-05 09:05:37 +00:00
if ( is_ft891 )
{
scale = 30. ;
}
else
{
scale = 255. ;
}
val - > f = ( float ) atoi ( retlvl ) / scale ;
break ;
2019-11-30 16:19:08 +00:00
case RIG_LEVEL_SQL :
2020-12-28 21:17:49 +00:00
if ( is_ft891 | | is_ft991 | | is_ftdx101 | | is_ftdx10 )
2020-11-05 09:05:37 +00:00
{
scale = 100. ;
}
else
{
scale = 255. ;
}
val - > f = ( float ) atoi ( retlvl ) / scale ;
2019-11-30 16:19:08 +00:00
break ;
2020-11-30 20:53:55 +00:00
case RIG_LEVEL_BKINDL :
{
2020-11-07 13:03:54 +00:00
int raw_value = atoi ( retlvl ) ;
int millis ;
value_t keyspd ;
2019-11-30 16:19:08 +00:00
2020-12-28 21:17:49 +00:00
if ( is_ftdx101 | | is_ftdx10 )
2020-10-03 20:45:21 +00:00
{
2020-11-07 13:03:54 +00:00
switch ( raw_value )
2020-10-03 20:45:21 +00:00
{
2020-11-07 13:03:54 +00:00
case 0 : millis = 30 ; break ;
2020-11-30 20:53:55 +00:00
2020-11-07 13:03:54 +00:00
case 1 : millis = 50 ; break ;
2020-11-30 20:53:55 +00:00
2020-11-07 13:03:54 +00:00
case 2 : millis = 100 ; break ;
2020-11-30 20:53:55 +00:00
2020-11-07 13:03:54 +00:00
case 3 : millis = 150 ; break ;
2020-11-30 20:53:55 +00:00
2020-11-07 13:03:54 +00:00
case 4 : millis = 200 ; break ;
2020-11-30 20:53:55 +00:00
2020-11-07 13:03:54 +00:00
case 5 : millis = 250 ; break ;
2020-11-30 20:53:55 +00:00
2020-11-07 13:03:54 +00:00
case 6 : millis = 300 ; break ;
2020-11-30 20:53:55 +00:00
2020-11-07 13:03:54 +00:00
default :
millis = ( raw_value - 6 ) * 100 + 300 ;
2020-10-03 20:45:21 +00:00
}
}
2020-11-07 13:03:54 +00:00
else
2019-11-30 16:19:08 +00:00
{
2020-11-07 13:03:54 +00:00
// The rest of Yaesu rigs indicate break-in delay directly as milliseconds
millis = raw_value ;
2019-11-30 16:19:08 +00:00
}
2020-11-07 13:03:54 +00:00
// Convert milliseconds to 10/ths of dots using the current key speed
err = newcat_get_level ( rig , vfo , RIG_LEVEL_KEYSPD , & keyspd ) ;
2020-11-30 20:53:55 +00:00
2020-11-07 13:03:54 +00:00
if ( err ! = RIG_OK )
2019-11-30 16:19:08 +00:00
{
2020-11-07 13:03:54 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2020-11-07 13:03:54 +00:00
val - > i = millis_to_dot10ths ( millis , keyspd . i ) ;
2019-11-30 16:19:08 +00:00
break ;
2020-11-07 13:03:54 +00:00
}
2020-11-30 20:53:55 +00:00
2020-10-23 09:32:10 +00:00
case RIG_LEVEL_STRENGTH :
if ( rig - > caps - > str_cal . size > 0 )
{
val - > i = round ( rig_raw2val ( atoi ( retlvl ) , & rig - > caps - > str_cal ) ) ;
break ;
}
2020-02-23 17:26:09 +00:00
2020-10-28 13:45:53 +00:00
if ( is_ftdx1200 | | is_ftdx3000 | | is_ftdx5000 | | is_ft891 | | is_ft991
2020-12-28 21:17:49 +00:00
| | is_ftdx101 | | is_ftdx10 )
2020-02-09 04:54:36 +00:00
{
2020-10-23 09:32:10 +00:00
val - > i = round ( rig_raw2val ( atoi ( retlvl ) , & yaesu_default_str_cal ) ) ;
2020-02-09 04:54:36 +00:00
}
2020-11-07 13:03:54 +00:00
else
2020-02-23 17:26:09 +00:00
{
2020-11-07 13:03:54 +00:00
// Some Yaesu rigs return straight S-meter answers
2020-02-09 04:54:36 +00:00
// Return dbS9 -- does >S9 mean 10dB increments? If not, add to rig driver
2020-11-07 13:03:54 +00:00
if ( val - > i > 0 )
{
val - > i = ( atoi ( retlvl ) - 9 ) * 10 ;
}
else
{
val - > i = ( atoi ( retlvl ) - 9 ) * 6 ;
}
2020-02-09 04:54:36 +00:00
}
2020-10-28 13:45:53 +00:00
2019-11-30 16:19:08 +00:00
break ;
case RIG_LEVEL_RAWSTR :
case RIG_LEVEL_KEYSPD :
2020-11-07 13:03:54 +00:00
val - > i = atoi ( retlvl ) ;
break ;
2019-11-30 16:19:08 +00:00
case RIG_LEVEL_IF :
2020-10-07 04:14:27 +00:00
// IS00+0400
rig_debug ( RIG_DEBUG_TRACE , " %s: ret_data=%s(%d), retlvl=%s \n " , __func__ ,
priv - > ret_data , ( int ) strlen ( priv - > ret_data ) , retlvl ) ;
if ( strlen ( priv - > ret_data ) = = 9 )
{
int n = sscanf ( priv - > ret_data , " IS%*c0%d \n " , & val - > i ) ;
if ( n ! = 1 )
{
rig_debug ( RIG_DEBUG_ERR , " %s: unable to parse level from %s \n " , __func__ ,
priv - > ret_data ) ;
}
}
else
{
val - > i = atoi ( retlvl ) ;
}
2019-11-30 16:19:08 +00:00
break ;
case RIG_LEVEL_NR :
2020-11-07 13:03:54 +00:00
if ( is_ft450 )
2019-11-30 16:19:08 +00:00
{
val - > f = ( float ) ( atoi ( retlvl ) / 11. ) ;
}
else
{
val - > f = ( float ) ( atoi ( retlvl ) / 15. ) ;
}
break ;
2020-03-24 15:02:17 +00:00
case RIG_LEVEL_VOXDELAY :
2020-10-04 13:56:49 +00:00
val - > i = atoi ( retlvl ) ;
2020-10-26 08:06:38 +00:00
if ( is_ftdx101 )
2020-10-04 13:56:49 +00:00
{
switch ( val - > i )
{
2020-10-06 13:10:31 +00:00
case 0 : val - > i = 0 ; break ; // 30ms=0 we only do tenths
2020-10-04 13:56:49 +00:00
2020-10-06 13:10:31 +00:00
case 1 : val - > i = 0 ; break ; // 50ms=0
2020-10-04 13:56:49 +00:00
2020-10-06 13:10:31 +00:00
case 2 : val - > i = 1 ; break ; // 100ms=1
2020-10-04 13:56:49 +00:00
2020-10-06 13:10:31 +00:00
case 3 : val - > i = 1 ; break ; // 150ms=1
2020-10-04 13:56:49 +00:00
2020-10-06 13:10:31 +00:00
case 4 : val - > i = 2 ; break ; // 200ms=2
2020-10-04 13:56:49 +00:00
2020-10-06 13:10:31 +00:00
case 5 : val - > i = 2 ; break ; // 250ms=2
2020-10-04 13:56:49 +00:00
default :
2020-10-06 13:10:31 +00:00
val - > i = ( val - > i - 6 ) + 3 ;
2020-10-04 13:56:49 +00:00
break ;
}
}
else
{
/* VOX delay, arg int (tenth of seconds), rig in ms */
val - > i / = 10 ; // Convert from ms to tenths
}
2019-11-30 16:19:08 +00:00
break ;
2020-11-30 20:53:55 +00:00
case RIG_LEVEL_PREAMP :
{
2020-11-05 09:05:37 +00:00
int preamp ;
2019-11-30 16:19:08 +00:00
if ( retlvl [ 0 ] < ' 0 ' | | retlvl [ 0 ] > ' 9 ' )
{
return - RIG_EPROTO ;
}
2020-11-05 09:05:37 +00:00
preamp = retlvl [ 0 ] - ' 0 ' ;
val - > i = 0 ;
if ( preamp > 0 )
{
for ( i = 0 ; state - > preamp [ i ] ! = RIG_DBLST_END ; i + + )
{
if ( i = = preamp - 1 )
{
val - > i = state - > preamp [ i ] ;
break ;
}
}
}
2020-11-30 20:53:55 +00:00
2019-11-30 16:19:08 +00:00
break ;
2020-11-05 09:05:37 +00:00
}
2020-11-30 20:53:55 +00:00
case RIG_LEVEL_ATT :
{
2020-11-05 09:05:37 +00:00
int att ;
2019-11-30 16:19:08 +00:00
if ( retlvl [ 0 ] < ' 0 ' | | retlvl [ 0 ] > ' 9 ' )
{
return - RIG_EPROTO ;
}
2020-11-05 09:05:37 +00:00
att = retlvl [ 0 ] - ' 0 ' ;
val - > i = 0 ;
if ( att > 0 )
{
for ( i = 0 ; state - > attenuator [ i ] ! = RIG_DBLST_END ; i + + )
{
if ( i = = att - 1 )
{
val - > i = state - > attenuator [ i ] ;
break ;
}
}
}
2020-11-30 20:53:55 +00:00
2019-11-30 16:19:08 +00:00
break ;
2020-11-05 09:05:37 +00:00
}
2019-11-30 16:19:08 +00:00
case RIG_LEVEL_AGC :
switch ( retlvl [ 0 ] )
{
2020-11-05 09:05:37 +00:00
case ' 0 ' :
val - > i = RIG_AGC_OFF ;
break ;
2020-11-30 20:53:55 +00:00
2020-11-05 09:05:37 +00:00
case ' 1 ' :
val - > i = RIG_AGC_FAST ;
break ;
2020-11-30 20:53:55 +00:00
2020-11-05 09:05:37 +00:00
case ' 2 ' :
val - > i = RIG_AGC_MEDIUM ;
break ;
2020-11-30 20:53:55 +00:00
2020-11-05 09:05:37 +00:00
case ' 3 ' :
val - > i = RIG_AGC_SLOW ;
break ;
2020-11-30 20:53:55 +00:00
2019-11-30 16:19:08 +00:00
case ' 4 ' :
case ' 5 ' :
case ' 6 ' :
val - > i = RIG_AGC_AUTO ; break ;
2020-11-05 09:05:37 +00:00
default :
return - RIG_EPROTO ;
2019-11-30 16:19:08 +00:00
}
break ;
case RIG_LEVEL_CWPITCH :
2020-11-04 22:07:53 +00:00
if ( is_ft950 | | is_ft2000 )
{
val - > i = ( atoi ( retlvl ) * 50 ) + 300 ;
}
else
{
// Most Yaesu rigs seem to use range of 0-75 to represent pitch of 300..1050 Hz in 10 Hz steps
val - > i = ( atoi ( retlvl ) * 10 ) + 300 ;
}
2020-11-30 20:53:55 +00:00
2019-11-30 16:19:08 +00:00
break ;
case RIG_LEVEL_METER :
switch ( retlvl [ 0 ] )
{
case ' 0 ' : val - > i = RIG_METER_COMP ; break ;
case ' 1 ' : val - > i = RIG_METER_ALC ; break ;
case ' 2 ' : val - > i = RIG_METER_PO ; break ;
case ' 3 ' : val - > i = RIG_METER_SWR ; break ;
case ' 4 ' : val - > i = RIG_METER_IC ; break ; /* ID CURRENT */
case ' 5 ' : val - > i = RIG_METER_VDD ; break ; /* Final Amp Voltage */
default : return - RIG_EPROTO ;
}
break ;
case RIG_LEVEL_NOTCHF :
val - > i = atoi ( retlvl ) * 10 ;
break ;
2020-10-22 21:04:43 +00:00
case RIG_LEVEL_MONITOR_GAIN :
2020-10-26 08:06:38 +00:00
if ( is_ftdx1200 | | is_ftdx3000 | | is_ft891 | | is_ft991 | | is_ftdx101 )
2020-10-22 21:04:43 +00:00
{
scale = 100. ;
}
else
{
scale = 255. ;
}
2020-10-28 13:45:53 +00:00
2020-10-22 21:04:43 +00:00
val - > f = ( float ) atoi ( retlvl ) / scale ;
break ;
2019-11-30 16:19:08 +00:00
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2019-11-30 16:19:08 +00:00
}
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2019-11-30 16:19:08 +00:00
}
int newcat_set_func ( RIG * rig , vfo_t vfo , setting_t func , int status )
{
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
int err ;
char main_sub_vfo = ' 0 ' ;
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
/* Set Main or SUB vfo */
err = newcat_set_vfo_from_alias ( rig , & vfo ) ;
if ( err < 0 )
{
return err ;
}
2020-09-27 21:01:48 +00:00
if ( rig - > caps - > targetable_vfo & ( RIG_TARGETABLE_MODE | RIG_TARGETABLE_TONE ) )
2019-11-30 16:19:08 +00:00
{
2020-10-06 20:50:37 +00:00
main_sub_vfo = ( RIG_VFO_B = = vfo | | RIG_VFO_SUB = = vfo ) ? ' 1 ' : ' 0 ' ;
2019-11-30 16:19:08 +00:00
}
switch ( func )
{
2021-01-15 22:48:32 +00:00
case RIG_FUNC_ANF :
{
2021-01-12 21:57:49 +00:00
pbwidth_t width ;
rmode_t mode = 0 ;
2019-11-30 16:19:08 +00:00
if ( ! newcat_valid_command ( rig , " BC " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2021-01-12 21:57:49 +00:00
if ( is_ft991 | | is_ftdx5000 | | is_ftdx101 )
{
err = newcat_get_mode ( rig , vfo , & mode , & width ) ;
}
2019-11-30 16:19:08 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " BC0%d%c " , status ? 1 : 0 ,
cat_term ) ;
2020-05-27 17:23:08 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE & & ! is_ft2000 )
2019-11-30 16:19:08 +00:00
{
priv - > cmd_str [ 2 ] = main_sub_vfo ;
}
2021-01-12 21:42:49 +00:00
// Some Yaesu rigs reject this command in FM mode
if ( is_ft991 | | is_ftdx5000 | | is_ftdx101 )
{
if ( mode & RIG_MODE_FM | | mode & RIG_MODE_FMN )
{
priv - > question_mark_response_means_rejected = 1 ;
}
}
2021-01-15 22:48:32 +00:00
2019-11-30 16:19:08 +00:00
break ;
2021-01-15 22:48:32 +00:00
}
2021-01-12 21:57:49 +00:00
2021-01-15 22:48:32 +00:00
case RIG_FUNC_MN :
{
2021-01-12 21:57:49 +00:00
pbwidth_t width ;
rmode_t mode = 0 ;
2019-11-30 16:19:08 +00:00
if ( ! newcat_valid_command ( rig , " BP " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2021-01-12 21:57:49 +00:00
if ( is_ft991 | | is_ftdx5000 | | is_ftdx101 )
{
newcat_get_mode ( rig , vfo , & mode , & width ) ;
}
2019-11-30 16:19:08 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " BP00%03d%c " , status ? 1 : 0 ,
cat_term ) ;
2020-05-27 17:23:08 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE & & ! is_ft2000 )
2019-11-30 16:19:08 +00:00
{
priv - > cmd_str [ 2 ] = main_sub_vfo ;
}
2021-01-12 21:42:49 +00:00
// Some Yaesu rigs reject this command in FM mode
if ( is_ft991 | | is_ftdx5000 | | is_ftdx101 )
{
if ( mode & RIG_MODE_FM | | mode & RIG_MODE_FMN )
{
priv - > question_mark_response_means_rejected = 1 ;
}
}
2021-01-15 22:48:32 +00:00
2019-11-30 16:19:08 +00:00
break ;
2021-01-12 21:57:49 +00:00
}
2019-11-30 16:19:08 +00:00
case RIG_FUNC_FBKIN :
if ( ! newcat_valid_command ( rig , " BI " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " BI%d%c " , status ? 1 : 0 ,
cat_term ) ;
break ;
case RIG_FUNC_TONE :
if ( ! newcat_valid_command ( rig , " CT " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " CT0%d%c " , status ? 2 : 0 ,
cat_term ) ;
2020-09-27 21:01:48 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_TONE )
{
priv - > cmd_str [ 2 ] = main_sub_vfo ;
}
2019-11-30 16:19:08 +00:00
break ;
case RIG_FUNC_TSQL :
if ( ! newcat_valid_command ( rig , " CT " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2020-11-30 20:53:55 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " CT0%d%c " , status ? 1 : 0 ,
cat_term ) ;
2020-09-27 21:01:48 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_TONE )
{
priv - > cmd_str [ 2 ] = main_sub_vfo ;
}
2019-11-30 16:19:08 +00:00
break ;
case RIG_FUNC_LOCK :
if ( ! newcat_valid_command ( rig , " LK " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2020-10-26 08:06:38 +00:00
if ( is_ftdx1200 | | is_ftdx3000 | | is_ftdx5000 | | is_ftdx101 )
2020-10-23 07:13:08 +00:00
{
// These rigs can lock Main/Sub VFO dials individually
2020-10-28 13:45:53 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " LK%d%c " , status ? 7 : 4 ,
cat_term ) ;
2020-10-23 07:13:08 +00:00
}
else
{
2020-10-28 13:45:53 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " LK%d%c " , status ? 1 : 0 ,
cat_term ) ;
2020-10-23 07:13:08 +00:00
}
2020-10-28 13:45:53 +00:00
2019-11-30 16:19:08 +00:00
break ;
case RIG_FUNC_MON :
if ( ! newcat_valid_command ( rig , " ML " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " ML0%03d%c " , status ? 1 : 0 ,
cat_term ) ;
break ;
case RIG_FUNC_NB :
if ( ! newcat_valid_command ( rig , " NB " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " NB0%d%c " , status ? 1 : 0 ,
cat_term ) ;
2020-10-02 03:51:31 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
{
priv - > cmd_str [ 2 ] = main_sub_vfo ;
2020-09-27 21:01:48 +00:00
}
2020-10-02 03:51:31 +00:00
2019-11-30 16:19:08 +00:00
break ;
2021-01-15 22:48:32 +00:00
case RIG_FUNC_NR :
{
2021-01-12 21:57:49 +00:00
pbwidth_t width ;
rmode_t mode = 0 ;
2019-11-30 16:19:08 +00:00
if ( ! newcat_valid_command ( rig , " NR " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2021-01-12 21:57:49 +00:00
if ( is_ft991 | | is_ftdx5000 | | is_ftdx101 )
{
newcat_get_mode ( rig , vfo , & mode , & width ) ;
}
2021-01-12 22:04:10 +00:00
2019-11-30 16:19:08 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " NR0%d%c " , status ? 1 : 0 ,
cat_term ) ;
2020-10-02 03:51:31 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
{
priv - > cmd_str [ 2 ] = main_sub_vfo ;
2020-09-27 21:01:48 +00:00
}
2020-10-02 03:51:31 +00:00
2021-01-12 21:42:49 +00:00
// Some Yaesu rigs reject this command in FM mode
if ( is_ft991 | | is_ftdx5000 | | is_ftdx101 )
{
if ( mode & RIG_MODE_FM | | mode & RIG_MODE_FMN )
{
priv - > question_mark_response_means_rejected = 1 ;
}
}
2021-01-15 22:48:32 +00:00
2019-11-30 16:19:08 +00:00
break ;
2021-01-12 21:57:49 +00:00
}
2019-11-30 16:19:08 +00:00
2021-01-15 22:48:32 +00:00
case RIG_FUNC_COMP :
{
2021-01-12 22:04:10 +00:00
pbwidth_t width ;
rmode_t mode = 0 ;
2019-11-30 16:19:08 +00:00
if ( ! newcat_valid_command ( rig , " PR " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2021-01-12 22:04:10 +00:00
if ( is_ft991 | | is_ftdx5000 | | is_ftdx101 )
{
newcat_get_mode ( rig , vfo , & mode , & width ) ;
}
2020-11-05 09:14:54 +00:00
if ( is_ft891 | | is_ft991 | | is_ftdx1200 | | is_ftdx3000 | | is_ftdx101 )
2020-10-13 21:55:32 +00:00
{
2020-11-05 09:14:54 +00:00
// There seems to be an error in the manuals for some of these rigs stating that values should be 1 = OFF and 2 = ON, but they are 0 = OFF and 1 = ON instead
2020-11-30 20:53:55 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " PR0%d%c " , status ? 1 : 0 ,
cat_term ) ;
2020-11-05 09:05:37 +00:00
}
2020-10-13 21:55:32 +00:00
else
{
2020-11-30 20:53:55 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " PR%d%c " , status ? 1 : 0 ,
cat_term ) ;
2020-10-13 21:55:32 +00:00
}
2020-10-15 20:44:43 +00:00
2021-01-12 22:04:10 +00:00
// Some Yaesu rigs reject this command in AM/FM/RTTY modes
if ( is_ft991 | | is_ftdx5000 | | is_ftdx101 )
{
2021-01-15 22:48:32 +00:00
if ( mode & RIG_MODE_AM | | mode & RIG_MODE_FM | | mode & RIG_MODE_AMN
| | mode & RIG_MODE_FMN | |
2021-01-12 22:04:10 +00:00
mode & RIG_MODE_RTTY | | mode & RIG_MODE_RTTYR )
{
priv - > question_mark_response_means_rejected = 1 ;
}
}
2021-01-15 22:48:32 +00:00
2019-11-30 16:19:08 +00:00
break ;
2021-01-12 22:04:10 +00:00
}
2019-11-30 16:19:08 +00:00
case RIG_FUNC_VOX :
if ( ! newcat_valid_command ( rig , " VX " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " VX%d%c " , status ? 1 : 0 ,
cat_term ) ;
break ;
case RIG_FUNC_TUNER :
if ( ! newcat_valid_command ( rig , " AC " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2020-10-15 20:44:43 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " AC00%d%c " ,
status = = 0 ? 0 : status ,
2019-11-30 16:19:08 +00:00
cat_term ) ;
break ;
2020-08-28 17:16:17 +00:00
case RIG_FUNC_RIT :
if ( ! newcat_valid_command ( rig , " RT " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2020-08-28 17:16:17 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " RT%d%c " , status ? 1 : 0 ,
cat_term ) ;
break ;
case RIG_FUNC_XIT :
if ( ! newcat_valid_command ( rig , " XT " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2020-08-28 17:16:17 +00:00
}
2020-10-10 15:50:24 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " XT%d%c " , status ? 1 : 0 ,
2020-08-28 17:16:17 +00:00
cat_term ) ;
break ;
2019-11-30 16:19:08 +00:00
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2019-11-30 16:19:08 +00:00
}
2020-11-08 11:03:48 +00:00
err = newcat_set_cmd ( rig ) ;
// Clear flag after executing command
priv - > question_mark_response_means_rejected = 0 ;
return err ;
2019-11-30 16:19:08 +00:00
}
int newcat_get_func ( RIG * rig , vfo_t vfo , setting_t func , int * status )
{
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
int err ;
int ret_data_len ;
2020-10-23 06:56:20 +00:00
int last_char_index ;
2019-11-30 16:19:08 +00:00
char * retfunc ;
char main_sub_vfo = ' 0 ' ;
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
2020-10-12 03:25:01 +00:00
if ( rig - > caps - > targetable_vfo & ( RIG_TARGETABLE_MODE | RIG_TARGETABLE_TONE ) )
{
main_sub_vfo = ( RIG_VFO_B = = vfo | | RIG_VFO_SUB = = vfo ) ? ' 1 ' : ' 0 ' ;
}
2019-11-30 16:19:08 +00:00
switch ( func )
{
2021-01-15 22:48:32 +00:00
case RIG_FUNC_ANF :
{
2021-01-12 21:57:49 +00:00
pbwidth_t width ;
rmode_t mode = 0 ;
2019-11-30 16:19:08 +00:00
if ( ! newcat_valid_command ( rig , " BC " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2021-01-12 21:57:49 +00:00
if ( is_ft991 | | is_ftdx5000 | | is_ftdx101 )
{
err = newcat_get_mode ( rig , vfo , & mode , & width ) ;
}
2019-11-30 16:19:08 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " BC0%c " , cat_term ) ;
2020-05-27 17:23:08 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
2019-11-30 16:19:08 +00:00
{
priv - > cmd_str [ 2 ] = main_sub_vfo ;
}
2021-01-12 21:42:49 +00:00
// Some Yaesu rigs reject this command in FM mode
if ( is_ft991 | | is_ftdx5000 | | is_ftdx101 )
{
if ( mode & RIG_MODE_FM | | mode & RIG_MODE_FMN )
{
priv - > question_mark_response_means_rejected = 1 ;
}
}
2021-01-15 22:48:32 +00:00
2019-11-30 16:19:08 +00:00
break ;
2021-01-12 21:57:49 +00:00
}
2019-11-30 16:19:08 +00:00
case RIG_FUNC_MN :
if ( ! newcat_valid_command ( rig , " BP " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " BP00%c " , cat_term ) ;
2020-05-27 17:23:08 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
2019-11-30 16:19:08 +00:00
{
priv - > cmd_str [ 2 ] = main_sub_vfo ;
}
break ;
case RIG_FUNC_FBKIN :
if ( ! newcat_valid_command ( rig , " BI " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " BI%c " , cat_term ) ;
break ;
case RIG_FUNC_TONE :
if ( ! newcat_valid_command ( rig , " CT " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " CT0%c " , cat_term ) ;
2020-09-26 22:45:45 +00:00
2020-09-27 21:01:48 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_TONE )
2020-09-26 22:45:45 +00:00
{
priv - > cmd_str [ 2 ] = main_sub_vfo ;
}
2019-11-30 16:19:08 +00:00
break ;
case RIG_FUNC_TSQL :
if ( ! newcat_valid_command ( rig , " CT " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " CT0%c " , cat_term ) ;
2020-09-26 22:45:45 +00:00
2020-09-27 21:01:48 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_TONE )
2020-09-26 22:45:45 +00:00
{
priv - > cmd_str [ 2 ] = main_sub_vfo ;
}
2019-11-30 16:19:08 +00:00
break ;
case RIG_FUNC_LOCK :
if ( ! newcat_valid_command ( rig , " LK " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " LK%c " , cat_term ) ;
break ;
case RIG_FUNC_MON :
if ( ! newcat_valid_command ( rig , " ML " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " ML0%c " , cat_term ) ;
break ;
case RIG_FUNC_NB :
if ( ! newcat_valid_command ( rig , " NB " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " NB0%c " , cat_term ) ;
2020-09-26 22:45:45 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
{
priv - > cmd_str [ 2 ] = main_sub_vfo ;
}
2019-11-30 16:19:08 +00:00
break ;
case RIG_FUNC_NR :
if ( ! newcat_valid_command ( rig , " NR " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " NR0%c " , cat_term ) ;
2020-09-26 22:45:45 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
{
priv - > cmd_str [ 2 ] = main_sub_vfo ;
}
2019-11-30 16:19:08 +00:00
break ;
case RIG_FUNC_COMP :
if ( ! newcat_valid_command ( rig , " PR " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2020-10-26 08:06:38 +00:00
if ( is_ftdx1200 | | is_ftdx3000 | | is_ft891 | | is_ft991 | | is_ftdx101 )
2020-10-13 21:55:32 +00:00
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " PR0%c " , cat_term ) ;
}
else
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " PR%c " , cat_term ) ;
}
2020-10-15 20:44:43 +00:00
2019-11-30 16:19:08 +00:00
break ;
case RIG_FUNC_VOX :
if ( ! newcat_valid_command ( rig , " VX " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " VX%c " , cat_term ) ;
break ;
case RIG_FUNC_TUNER :
if ( ! newcat_valid_command ( rig , " AC " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " AC%c " , cat_term ) ;
break ;
2020-08-28 17:16:17 +00:00
case RIG_FUNC_RIT :
if ( ! newcat_valid_command ( rig , " RT " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2020-08-28 17:16:17 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " RT%c " , cat_term ) ;
break ;
case RIG_FUNC_XIT :
if ( ! newcat_valid_command ( rig , " XT " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2020-08-28 17:16:17 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " XT%c " , cat_term ) ;
break ;
2019-11-30 16:19:08 +00:00
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2019-11-30 16:19:08 +00:00
}
2021-01-12 21:42:49 +00:00
err = newcat_get_cmd ( rig ) ;
// Clear flag after executing command
priv - > question_mark_response_means_rejected = 0 ;
if ( err ! = RIG_OK )
2019-11-30 16:19:08 +00:00
{
return err ;
}
ret_data_len = strlen ( priv - > ret_data ) ;
/* skip command */
retfunc = priv - > ret_data + strlen ( priv - > cmd_str ) - 1 ;
/* chop term */
priv - > ret_data [ ret_data_len - 1 ] = ' \0 ' ;
2020-10-23 06:58:40 +00:00
last_char_index = strlen ( retfunc ) - 1 ;
2020-10-23 06:56:20 +00:00
2020-10-15 20:23:12 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: retfunc='%s' \n " , __func__ , retfunc ) ;
2020-10-23 16:36:42 +00:00
2019-11-30 16:19:08 +00:00
switch ( func )
{
case RIG_FUNC_MN :
* status = ( retfunc [ 2 ] = = ' 0 ' ) ? 0 : 1 ;
break ;
2020-10-13 21:55:32 +00:00
case RIG_FUNC_COMP :
2020-11-05 09:14:54 +00:00
* status = ( retfunc [ 0 ] = = ' 0 ' ) ? 0 : 1 ;
2020-10-13 21:55:32 +00:00
break ;
2020-10-22 21:04:43 +00:00
case RIG_FUNC_MON :
// The number of digits varies by rig, but the last digit indicates the status always
2020-10-23 06:56:20 +00:00
* status = ( retfunc [ last_char_index ] = = ' 0 ' ) ? 0 : 1 ;
2020-10-22 21:04:43 +00:00
break ;
2020-10-28 13:45:53 +00:00
2020-10-23 07:13:08 +00:00
case RIG_FUNC_LOCK :
2020-10-26 08:06:38 +00:00
if ( is_ftdx1200 | | is_ftdx3000 | | is_ftdx5000 | | is_ftdx101 )
2020-10-23 07:13:08 +00:00
{
// These rigs can lock Main/Sub VFO dials individually
* status = ( retfunc [ 0 ] = = ' 0 ' | | retfunc [ 0 ] = = ' 4 ' ) ? 0 : 1 ;
}
else
{
* status = ( retfunc [ 0 ] = = ' 0 ' ) ? 0 : 1 ;
}
2020-10-28 13:45:53 +00:00
2020-10-23 07:13:08 +00:00
break ;
2019-11-30 16:19:08 +00:00
case RIG_FUNC_ANF :
case RIG_FUNC_FBKIN :
case RIG_FUNC_NB :
case RIG_FUNC_NR :
case RIG_FUNC_VOX :
* status = ( retfunc [ 0 ] = = ' 0 ' ) ? 0 : 1 ;
break ;
case RIG_FUNC_TONE :
* status = ( retfunc [ 0 ] = = ' 2 ' ) ? 1 : 0 ;
break ;
case RIG_FUNC_TSQL :
* status = ( retfunc [ 0 ] = = ' 1 ' ) ? 1 : 0 ;
break ;
case RIG_FUNC_TUNER :
* status = ( retfunc [ 2 ] = = ' 1 ' ) ? 1 : 0 ;
break ;
2020-08-28 17:16:17 +00:00
case RIG_FUNC_RIT :
* status = ( retfunc [ 0 ] = = ' 1 ' ) ? 1 : 0 ;
break ;
case RIG_FUNC_XIT :
* status = ( retfunc [ 0 ] = = ' 1 ' ) ? 1 : 0 ;
break ;
2019-11-30 16:19:08 +00:00
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2019-11-30 16:19:08 +00:00
}
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2019-11-30 16:19:08 +00:00
}
int newcat_set_parm ( RIG * rig , setting_t parm , value_t val )
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
int newcat_get_parm ( RIG * rig , setting_t parm , value_t * val )
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
int newcat_set_ext_level ( RIG * rig , vfo_t vfo , token_t token , value_t val )
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
2020-10-25 16:06:13 +00:00
switch ( token )
{
2020-10-28 13:45:53 +00:00
case TOK_ROOFING_FILTER :
return set_roofing_filter ( rig , vfo , val . i ) ;
2019-11-30 16:19:08 +00:00
2020-10-28 13:45:53 +00:00
default :
rig_debug ( RIG_DEBUG_ERR , " %s: Unsupported ext level %s \n " , __func__ ,
rig_strlevel ( token ) ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-10-25 16:06:13 +00:00
}
}
2019-11-30 16:19:08 +00:00
int newcat_get_ext_level ( RIG * rig , vfo_t vfo , token_t token , value_t * val )
{
2020-10-25 16:06:13 +00:00
int retval ;
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
2020-10-25 16:06:13 +00:00
switch ( token )
{
2020-10-28 13:45:53 +00:00
case TOK_ROOFING_FILTER :
{
struct newcat_roofing_filter * roofing_filter ;
retval = get_roofing_filter ( rig , vfo , & roofing_filter ) ;
2019-11-30 16:19:08 +00:00
2020-10-28 13:45:53 +00:00
if ( retval ! = RIG_OK )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( retval ) ;
2020-10-25 16:06:13 +00:00
}
2020-10-28 13:45:53 +00:00
val - > i = roofing_filter - > index ;
break ;
}
default :
rig_debug ( RIG_DEBUG_ERR , " %s: Unsupported ext level %s \n " , __func__ ,
rig_strlevel ( token ) ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-10-25 16:06:13 +00:00
}
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2020-10-25 16:06:13 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_set_ext_parm ( RIG * rig , token_t token , value_t val )
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
int newcat_get_ext_parm ( RIG * rig , token_t token , value_t * val )
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
int newcat_send_dtmf ( RIG * rig , vfo_t vfo , const char * digits )
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
int newcat_recv_dtmf ( RIG * rig , vfo_t vfo , char * digits , int * length )
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
int newcat_send_morse ( RIG * rig , vfo_t vfo , const char * msg )
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
int newcat_set_bank ( RIG * rig , vfo_t vfo , int bank )
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
int newcat_set_mem ( RIG * rig , vfo_t vfo , int ch )
{
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
int err , i ;
ncboolean restore_vfo ;
chan_t * chan_list ;
channel_t valid_chan ;
channel_cap_t * mem_caps = NULL ;
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
if ( ! newcat_valid_command ( rig , " MC " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
chan_list = rig - > caps - > chan_list ;
for ( i = 0 ; i < CHANLSTSIZ & & ! RIG_IS_CHAN_END ( chan_list [ i ] ) ; i + + )
{
if ( ch > = chan_list [ i ] . startc & &
ch < = chan_list [ i ] . endc )
{
mem_caps = & chan_list [ i ] . mem_caps ;
break ;
}
}
/* Test for valid usable channel, skip if empty */
memset ( & valid_chan , 0 , sizeof ( channel_t ) ) ;
valid_chan . channel_num = ch ;
2020-11-30 05:32:14 +00:00
err = newcat_get_channel ( rig , vfo , & valid_chan , 1 ) ;
2019-11-30 16:19:08 +00:00
2019-12-24 16:00:45 +00:00
if ( err < 0 )
{
return err ;
}
2019-11-30 16:19:08 +00:00
if ( valid_chan . freq < = 1.0 )
{
mem_caps = NULL ;
}
rig_debug ( RIG_DEBUG_TRACE , " %s: valChan Freq = %f \n " , __func__ ,
valid_chan . freq ) ;
/* Out of Range, or empty */
if ( ! mem_caps )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2019-11-30 16:19:08 +00:00
}
/* set to usable vfo if needed */
err = newcat_set_vfo_from_alias ( rig , & vfo ) ;
if ( err < 0 )
{
return err ;
}
/* Restore to VFO mode or leave in Memory Mode */
switch ( vfo )
{
case RIG_VFO_A :
2020-10-06 20:50:37 +00:00
case RIG_VFO_MAIN :
2019-11-30 16:19:08 +00:00
/* Jump back from memory channel */
restore_vfo = TRUE ;
break ;
case RIG_VFO_MEM :
Fix spelling errors
Fixed using the following command:
codespell --write-changes --summary --skip=*.m4 --ignore-words-list="develope,get's,quitt,setts,som,ue,vektor"
codespell --write-changes --summary --skip=aclocal.m4,lib --ignore-words-list="develope,get's,quitt,setts,som,ue,vektor"
Codespell home page: https://github.com/codespell-project/codespell
2020-07-24 07:02:12 +00:00
/* Jump from channel to channel in memory mode */
2019-11-30 16:19:08 +00:00
restore_vfo = FALSE ;
break ;
case RIG_VFO_B :
2020-10-06 20:50:37 +00:00
case RIG_VFO_SUB :
2019-11-30 16:19:08 +00:00
default :
/* Only works with VFO A */
return - RIG_ENTARGET ;
}
/* Set Memory Channel Number ************** */
2020-03-20 12:51:32 +00:00
rig_debug ( RIG_DEBUG_TRACE , " channel_num = %d, vfo = %s \n " , ch , rig_strvfo ( vfo ) ) ;
2019-11-30 16:19:08 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " MC%03d%c " , ch , cat_term ) ;
rig_debug ( RIG_DEBUG_TRACE , " %s: cmd_str = %s \n " , __func__ , priv - > cmd_str ) ;
2020-10-25 16:06:13 +00:00
priv - > question_mark_response_means_rejected = 1 ;
err = newcat_set_cmd ( rig ) ;
priv - > question_mark_response_means_rejected = 0 ;
2019-11-30 16:19:08 +00:00
if ( err ! = RIG_OK )
{
return err ;
}
/* Restore VFO even if setting to blank memory channel */
if ( restore_vfo )
{
err = newcat_vfomem_toggle ( rig ) ;
if ( err ! = RIG_OK )
{
return err ;
}
}
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2019-11-30 16:19:08 +00:00
}
int newcat_get_mem ( RIG * rig , vfo_t vfo , int * ch )
{
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
int err ;
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
if ( ! newcat_valid_command ( rig , " MC " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " MC%c " , cat_term ) ;
rig_debug ( RIG_DEBUG_TRACE , " %s: cmd_str = %s \n " , __func__ , priv - > cmd_str ) ;
/* Get Memory Channel Number */
if ( RIG_OK ! = ( err = newcat_get_cmd ( rig ) ) )
{
return err ;
}
* ch = atoi ( priv - > ret_data + 2 ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2019-11-30 16:19:08 +00:00
}
int newcat_vfo_op ( RIG * rig , vfo_t vfo , vfo_op_t op )
{
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
int err ;
char main_sub_vfo = ' 0 ' ;
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
/* Set Main or SUB vfo */
err = newcat_set_vfo_from_alias ( rig , & vfo ) ;
if ( err < 0 )
{
return err ;
}
2020-05-27 17:23:08 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
2019-11-30 16:19:08 +00:00
{
2020-10-06 20:50:37 +00:00
main_sub_vfo = ( RIG_VFO_B = = vfo | | RIG_VFO_SUB = = vfo ) ? ' 1 ' : ' 0 ' ;
2019-11-30 16:19:08 +00:00
}
switch ( op )
{
case RIG_OP_TUNE :
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " AC002%c " , cat_term ) ;
break ;
case RIG_OP_CPY :
if ( newcat_is_rig ( rig , RIG_MODEL_FT450 ) )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " VV%c " , cat_term ) ;
}
else
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " AB%c " , cat_term ) ;
}
break ;
case RIG_OP_XCHG :
case RIG_OP_TOGGLE :
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " SV%c " , cat_term ) ;
break ;
case RIG_OP_UP :
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " UP%c " , cat_term ) ;
break ;
case RIG_OP_DOWN :
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " DN%c " , cat_term ) ;
break ;
case RIG_OP_BAND_UP :
if ( main_sub_vfo = = 1 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " BU1%c " , cat_term ) ;
}
else
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " BU0%c " , cat_term ) ;
}
break ;
case RIG_OP_BAND_DOWN :
if ( main_sub_vfo = = 1 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " BD1%c " , cat_term ) ;
}
else
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " BD0%c " , cat_term ) ;
}
break ;
case RIG_OP_FROM_VFO :
/* VFOA ! */
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " AM%c " , cat_term ) ;
break ;
case RIG_OP_TO_VFO :
/* VFOA ! */
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " MA%c " , cat_term ) ;
break ;
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2019-11-30 16:19:08 +00:00
}
return newcat_set_cmd ( rig ) ;
}
int newcat_scan ( RIG * rig , vfo_t vfo , scan_t scan , int ch )
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
int newcat_set_trn ( RIG * rig , int trn )
{
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
char c ;
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
if ( ! newcat_valid_command ( rig , " AI " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
if ( trn = = RIG_TRN_OFF )
{
c = ' 0 ' ;
}
else
{
c = ' 1 ' ;
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " AI%c%c " , c , cat_term ) ;
rig_debug ( RIG_DEBUG_TRACE , " cmd_str = %s \n " , priv - > cmd_str ) ;
return newcat_set_cmd ( rig ) ;
}
int newcat_get_trn ( RIG * rig , int * trn )
{
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
int err ;
char c ;
char command [ ] = " AI " ;
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
if ( ! newcat_valid_command ( rig , command ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%c " , command , cat_term ) ;
/* Get Auto Information */
if ( RIG_OK ! = ( err = newcat_get_cmd ( rig ) ) )
{
return err ;
}
c = priv - > ret_data [ 2 ] ;
if ( c = = ' 0 ' )
{
* trn = RIG_TRN_OFF ;
}
else
{
* trn = RIG_TRN_RIG ;
}
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2019-11-30 16:19:08 +00:00
}
int newcat_decode_event ( RIG * rig )
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2020-11-30 05:32:14 +00:00
int newcat_set_channel ( RIG * rig , vfo_t vfo , const channel_t * chan )
2019-11-30 16:19:08 +00:00
{
struct rig_state * state = & rig - > state ;
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
int err , i ;
int rxit ;
char c_rit , c_xit , c_mode , c_vfo , c_tone , c_rptr_shift ;
tone_t tone ;
ncboolean restore_vfo ;
chan_t * chan_list ;
channel_cap_t * mem_caps = NULL ;
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
if ( ! newcat_valid_command ( rig , " MW " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
chan_list = rig - > caps - > chan_list ;
for ( i = 0 ; i < CHANLSTSIZ & & ! RIG_IS_CHAN_END ( chan_list [ i ] ) ; i + + )
{
if ( chan - > channel_num > = chan_list [ i ] . startc & &
chan - > channel_num < = chan_list [ i ] . endc & &
// writable memory types... NOT 60-METERS or READ-ONLY channels
( chan_list [ i ] . type = = RIG_MTYPE_MEM | |
chan_list [ i ] . type = = RIG_MTYPE_EDGE ) )
{
mem_caps = & chan_list [ i ] . mem_caps ;
break ;
}
}
/* Out of Range */
if ( ! mem_caps )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
/* Set Restore to VFO or leave in memory mode */
switch ( state - > current_vfo )
{
case RIG_VFO_A :
2020-10-06 20:50:37 +00:00
case RIG_VFO_B :
2019-11-30 16:19:08 +00:00
/* Jump back from memory channel */
restore_vfo = TRUE ;
break ;
case RIG_VFO_MEM :
Fix spelling errors
Fixed using the following command:
codespell --write-changes --summary --skip=*.m4 --ignore-words-list="develope,get's,quitt,setts,som,ue,vektor"
codespell --write-changes --summary --skip=aclocal.m4,lib --ignore-words-list="develope,get's,quitt,setts,som,ue,vektor"
Codespell home page: https://github.com/codespell-project/codespell
2020-07-24 07:02:12 +00:00
/* Jump from channel to channel in memory mode */
2019-11-30 16:19:08 +00:00
restore_vfo = FALSE ;
break ;
2020-10-06 20:50:37 +00:00
case RIG_VFO_SUB :
2019-11-30 16:19:08 +00:00
default :
2020-10-10 15:47:51 +00:00
/* Only works with VFO Main */
2019-11-30 16:19:08 +00:00
return - RIG_ENTARGET ;
}
/* Write Memory Channel ************************* */
/* Clarifier TX, RX */
if ( chan - > rit )
{
rxit = chan - > rit ;
c_rit = ' 1 ' ;
c_xit = ' 0 ' ;
}
else if ( chan - > xit )
{
rxit = chan - > xit ;
c_rit = ' 0 ' ;
c_xit = ' 1 ' ;
}
else
{
rxit = 0 ;
c_rit = ' 0 ' ;
c_xit = ' 0 ' ;
}
/* MODE */
2020-04-20 04:18:59 +00:00
c_mode = newcat_modechar ( chan - > mode ) ;
2019-11-30 16:19:08 +00:00
/* VFO Fixed */
c_vfo = ' 0 ' ;
/* CTCSS Tone / Sql */
if ( chan - > ctcss_tone )
{
c_tone = ' 2 ' ;
tone = chan - > ctcss_tone ;
}
else if ( chan - > ctcss_sql )
{
c_tone = ' 1 ' ;
tone = chan - > ctcss_sql ;
}
else
{
c_tone = ' 0 ' ;
tone = 0 ;
}
for ( i = 0 ; rig - > caps - > ctcss_list [ i ] ! = 0 ; i + + )
if ( tone = = rig - > caps - > ctcss_list [ i ] )
{
tone = i ;
if ( tone > 49 )
{
tone = 0 ;
}
break ;
}
/* Repeater Shift */
switch ( chan - > rptr_shift )
{
case RIG_RPT_SHIFT_NONE : c_rptr_shift = ' 0 ' ; break ;
case RIG_RPT_SHIFT_PLUS : c_rptr_shift = ' 1 ' ; break ;
case RIG_RPT_SHIFT_MINUS : c_rptr_shift = ' 2 ' ; break ;
default : c_rptr_shift = ' 0 ' ;
}
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) ,
2020-03-20 12:51:32 +00:00
" MW%03d%08d%+.4d%c%c%c%c%c%02u%c%c " ,
2019-11-30 16:19:08 +00:00
chan - > channel_num , ( int ) chan - > freq , rxit , c_rit , c_xit , c_mode , c_vfo ,
c_tone , tone , c_rptr_shift , cat_term ) ;
rig_debug ( RIG_DEBUG_TRACE , " %s: cmd_str = %s \n " , __func__ , priv - > cmd_str ) ;
/* Set Memory Channel */
2020-10-25 16:06:13 +00:00
priv - > question_mark_response_means_rejected = 1 ;
err = newcat_set_cmd ( rig ) ;
priv - > question_mark_response_means_rejected = 0 ;
2019-11-30 16:19:08 +00:00
if ( err ! = RIG_OK )
{
return err ;
}
/* Restore VFO ********************************** */
if ( restore_vfo )
{
err = newcat_vfomem_toggle ( rig ) ;
return err ;
}
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2019-11-30 16:19:08 +00:00
}
2020-11-30 05:32:14 +00:00
int newcat_get_channel ( RIG * rig , vfo_t vfo , channel_t * chan , int read_only )
2019-11-30 16:19:08 +00:00
{
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
char * retval ;
char c , c2 ;
int err , i ;
chan_t * chan_list ;
channel_cap_t * mem_caps = NULL ;
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
if ( ! newcat_valid_command ( rig , " MR " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
chan_list = rig - > caps - > chan_list ;
for ( i = 0 ; i < CHANLSTSIZ & & ! RIG_IS_CHAN_END ( chan_list [ i ] ) ; i + + )
{
if ( chan - > channel_num > = chan_list [ i ] . startc & &
chan - > channel_num < = chan_list [ i ] . endc )
{
mem_caps = & chan_list [ i ] . mem_caps ;
break ;
}
}
/* Out of Range */
if ( ! mem_caps )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2019-11-30 19:05:21 +00:00
rig_debug ( RIG_DEBUG_TRACE , " sizeof(channel_t) = %d \n " , ( int ) sizeof ( channel_t ) ) ;
rig_debug ( RIG_DEBUG_TRACE , " sizeof(priv->cmd_str) = %d \n " ,
( int ) sizeof ( priv - > cmd_str ) ) ;
2019-11-30 16:19:08 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " MR%03d%c " , chan - > channel_num ,
cat_term ) ;
rig_debug ( RIG_DEBUG_TRACE , " %s: cmd_str = %s \n " , __func__ , priv - > cmd_str ) ;
/* Get Memory Channel */
2020-10-25 16:06:13 +00:00
priv - > question_mark_response_means_rejected = 1 ;
err = newcat_get_cmd ( rig ) ;
priv - > question_mark_response_means_rejected = 0 ;
2020-10-28 13:45:53 +00:00
2020-10-25 16:06:13 +00:00
if ( RIG_OK ! = err )
2019-11-30 16:19:08 +00:00
{
if ( - RIG_ERJCTED = = err )
{
/* Invalid channel, has not been set up, make sure freq is
0 to indicate empty channel */
chan - > freq = 0. ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2019-11-30 16:19:08 +00:00
}
return err ;
}
/* ret_data string to channel_t struct :: this will destroy ret_data */
/* rptr_shift P10 ************************ */
retval = priv - > ret_data + 25 ;
switch ( * retval )
{
case ' 0 ' : chan - > rptr_shift = RIG_RPT_SHIFT_NONE ; break ;
case ' 1 ' : chan - > rptr_shift = RIG_RPT_SHIFT_PLUS ; break ;
case ' 2 ' : chan - > rptr_shift = RIG_RPT_SHIFT_MINUS ; break ;
default : chan - > rptr_shift = RIG_RPT_SHIFT_NONE ;
}
* retval = ' \0 ' ;
/* CTCSS Encoding P8 ********************* */
retval = priv - > ret_data + 22 ;
c = * retval ;
/* CTCSS Tone P9 ************************* */
chan - > ctcss_tone = 0 ;
chan - > ctcss_sql = 0 ;
retval = priv - > ret_data + 23 ;
i = atoi ( retval ) ;
if ( c = = ' 1 ' )
{
chan - > ctcss_sql = rig - > caps - > ctcss_list [ i ] ;
}
else if ( c = = ' 2 ' )
{
chan - > ctcss_tone = rig - > caps - > ctcss_list [ i ] ;
}
/* vfo, mem, P7 ************************** */
retval = priv - > ret_data + 21 ;
if ( * retval = = ' 1 ' )
{
chan - > vfo = RIG_VFO_MEM ;
}
else
{
chan - > vfo = RIG_VFO_CURR ;
}
/* MODE P6 ******************************* */
chan - > width = 0 ;
retval = priv - > ret_data + 20 ;
2020-04-20 04:18:59 +00:00
chan - > mode = newcat_rmode ( * retval ) ;
2019-11-30 16:19:08 +00:00
2020-04-20 04:18:59 +00:00
if ( chan - > mode = = RIG_MODE_NONE )
2019-11-30 16:19:08 +00:00
{
2020-02-23 17:26:09 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: unknown mode=%c \n " , __func__ , * retval ) ;
2020-01-15 14:15:29 +00:00
chan - > mode = RIG_MODE_LSB ;
2019-11-30 16:19:08 +00:00
}
/* Clarifier TX P5 *********************** */
retval = priv - > ret_data + 19 ;
c2 = * retval ;
/* Clarifier RX P4 *********************** */
retval = priv - > ret_data + 18 ;
c = * retval ;
* retval = ' \0 ' ;
/* Clarifier Offset P3 ******************* */
chan - > rit = 0 ;
chan - > xit = 0 ;
retval = priv - > ret_data + 13 ;
2009-01-07 00:50:53 +00:00
2019-11-30 16:19:08 +00:00
if ( c = = ' 1 ' )
{
chan - > rit = atoi ( retval ) ;
}
else if ( c2 = = ' 1 ' )
{
chan - > xit = atoi ( retval ) ;
2009-01-07 00:50:53 +00:00
}
2019-11-30 16:19:08 +00:00
* retval = ' \0 ' ;
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
/* Frequency P2 ************************** */
retval = priv - > ret_data + 5 ;
chan - > freq = atof ( retval ) ;
2008-09-22 21:34:45 +00:00
2020-04-26 20:44:38 +00:00
if ( ! read_only )
{
// Set rig to channel values
2020-05-09 20:52:49 +00:00
rig_debug ( RIG_DEBUG_ERR ,
" %s: please contact hamlib mailing list to implement this \n " , __func__ ) ;
rig_debug ( RIG_DEBUG_ERR ,
" %s: need to know if rig updates when channel read or not \n " , __func__ ) ;
2020-05-06 13:06:14 +00:00
return - RIG_ENIMPL ;
2020-04-26 19:37:03 +00:00
}
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
const char * newcat_get_info ( RIG * rig )
2008-09-22 21:34:45 +00:00
{
2019-11-30 16:19:08 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2020-10-28 13:30:25 +00:00
static char idbuf [ 129 ] ; /* extra large static string array */
2008-09-22 21:34:45 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
/* Build the command string */
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " ID; " ) ;
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: cmd_str = %s \n " , __func__ , priv - > cmd_str ) ;
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
/* Get Identification Channel */
2020-01-14 18:50:48 +00:00
if ( RIG_OK ! = newcat_get_cmd ( rig ) )
2019-11-30 16:19:08 +00:00
{
return NULL ;
}
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
priv - > ret_data [ 6 ] = ' \0 ' ;
snprintf ( idbuf , sizeof ( idbuf ) , " %s " , priv - > ret_data ) ;
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
return idbuf ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
/*
* newcat_valid_command
*
* Determine whether or not the command is valid for the specified
* rig . This function should be called before sending the command
* to the rig to make it easier to differentiate invalid and illegal
* commands ( for a rig ) .
*/
ncboolean newcat_valid_command ( RIG * rig , char const * const command )
2008-09-22 21:34:45 +00:00
{
2019-11-30 16:19:08 +00:00
const struct rig_caps * caps ;
int search_high ;
int search_low ;
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s %s \n " , __func__ , command ) ;
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
caps = rig - > caps ;
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
if ( ! caps )
{
rig_debug ( RIG_DEBUG_ERR , " %s: Rig capabilities not valid \n " , __func__ ) ;
return FALSE ;
}
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
/*
* Determine the type of rig from the model number . Note it is
* possible for several model variants to exist ; i . e . , all the
* FT - 9000 variants .
*/
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
is_ft450 = newcat_is_rig ( rig , RIG_MODEL_FT450 ) ;
is_ft891 = newcat_is_rig ( rig , RIG_MODEL_FT891 ) ;
is_ft950 = newcat_is_rig ( rig , RIG_MODEL_FT950 ) ;
is_ft991 = newcat_is_rig ( rig , RIG_MODEL_FT991 ) ;
is_ft2000 = newcat_is_rig ( rig , RIG_MODEL_FT2000 ) ;
2020-11-05 09:05:37 +00:00
is_ftdx9000 = newcat_is_rig ( rig , RIG_MODEL_FT9000 ) ;
2020-10-26 08:06:38 +00:00
is_ftdx5000 = newcat_is_rig ( rig , RIG_MODEL_FTDX5000 ) ;
is_ftdx1200 = newcat_is_rig ( rig , RIG_MODEL_FTDX1200 ) ;
is_ftdx3000 = newcat_is_rig ( rig , RIG_MODEL_FTDX3000 ) ;
is_ftdx101 = newcat_is_rig ( rig , RIG_MODEL_FTDX101D ) ;
2020-12-28 21:17:49 +00:00
is_ftdx10 = newcat_is_rig ( rig , RIG_MODEL_FTDX10 ) ;
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
if ( ! is_ft450 & & ! is_ft950 & & ! is_ft891 & & ! is_ft991 & & ! is_ft2000
2020-12-28 21:17:49 +00:00
& & ! is_ftdx5000 & & ! is_ftdx9000 & & ! is_ftdx1200 & & ! is_ftdx3000 & & ! is_ftdx101
& & ! is_ftdx10 )
2019-11-30 16:19:08 +00:00
{
2020-10-26 08:06:38 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: '%s' is unknown \n " , __func__ , caps - > model_name ) ;
2019-11-30 16:19:08 +00:00
return FALSE ;
}
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
/*
* Make sure the command is known , and then check to make sure
2020-10-26 08:06:38 +00:00
* is it valid for the rig .
2019-11-30 16:19:08 +00:00
*/
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
search_low = 0 ;
search_high = valid_commands_count ;
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
while ( search_low < = search_high )
{
int search_test ;
2019-12-24 16:00:45 +00:00
int search_index ;
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
search_index = ( search_low + search_high ) / 2 ;
search_test = strcmp ( valid_commands [ search_index ] . command , command ) ;
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
if ( search_test > 0 )
{
search_high = search_index - 1 ;
}
else if ( search_test < 0 )
{
search_low = search_index + 1 ;
}
else
{
/*
* The command is valid . Now make sure it is supported by the rig .
*/
if ( is_ft450 & & valid_commands [ search_index ] . ft450 )
{
return TRUE ;
}
else if ( is_ft891 & & valid_commands [ search_index ] . ft891 )
{
return TRUE ;
}
else if ( is_ft950 & & valid_commands [ search_index ] . ft950 )
{
return TRUE ;
}
else if ( is_ft991 & & valid_commands [ search_index ] . ft991 )
{
return TRUE ;
}
else if ( is_ft2000 & & valid_commands [ search_index ] . ft2000 )
{
return TRUE ;
}
2020-10-26 08:06:38 +00:00
else if ( is_ftdx5000 & & valid_commands [ search_index ] . ft5000 )
2019-11-30 16:19:08 +00:00
{
return TRUE ;
}
2020-11-05 09:05:37 +00:00
else if ( is_ftdx9000 & & valid_commands [ search_index ] . ft9000 )
2019-11-30 16:19:08 +00:00
{
return TRUE ;
}
2020-10-26 08:06:38 +00:00
else if ( is_ftdx1200 & & valid_commands [ search_index ] . ft1200 )
2019-11-30 16:19:08 +00:00
{
return TRUE ;
}
2020-10-26 08:06:38 +00:00
else if ( is_ftdx3000 & & valid_commands [ search_index ] . ft3000 )
2019-11-30 16:19:08 +00:00
{
return TRUE ;
}
2020-10-26 08:06:38 +00:00
else if ( is_ftdx101 & & valid_commands [ search_index ] . ft101 )
2019-11-30 16:19:08 +00:00
{
return TRUE ;
}
2020-12-28 21:17:49 +00:00
else if ( is_ftdx10 & & valid_commands [ search_index ] . ft10 )
{
return TRUE ;
}
2019-11-30 16:19:08 +00:00
else
{
rig_debug ( RIG_DEBUG_TRACE , " %s: '%s' command '%s' not supported \n " ,
__func__ , caps - > model_name , command ) ;
return FALSE ;
}
}
}
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: '%s' command '%s' not valid \n " ,
__func__ , caps - > model_name , command ) ;
return FALSE ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
ncboolean newcat_is_rig ( RIG * rig , rig_model_t model )
2008-09-22 21:34:45 +00:00
{
2019-11-30 16:19:08 +00:00
ncboolean is_rig ;
2008-09-22 21:34:45 +00:00
2021-01-17 13:25:28 +00:00
//a bit too verbose so TRACE level here
rig_debug ( RIG_DEBUG_TRACE , " %s(%d):%s called \n " , __FILE__ , __LINE__ , __func__ ) ;
2019-11-30 16:19:08 +00:00
is_rig = ( model = = rig - > caps - > rig_model ) ? TRUE : FALSE ;
return is_rig ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
/*
* newcat_set_tx_vfo does not set priv - > curr_vfo
*/
int newcat_set_tx_vfo ( RIG * rig , vfo_t tx_vfo )
2008-09-22 21:34:45 +00:00
{
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2019-11-30 16:19:08 +00:00
int err ;
char p1 ;
2020-06-11 22:27:36 +00:00
char * command = " FT " ;
2011-07-09 03:27:06 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2009-01-04 00:05:25 +00:00
2019-11-30 16:19:08 +00:00
if ( ! newcat_valid_command ( rig , " FT " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2009-11-28 14:27:37 +00:00
}
2019-11-30 16:19:08 +00:00
err = newcat_set_vfo_from_alias ( rig , & tx_vfo ) ;
2009-11-28 14:27:37 +00:00
if ( err < 0 )
2019-11-30 16:19:08 +00:00
{
2009-11-28 14:27:37 +00:00
return err ;
}
2019-11-30 16:19:08 +00:00
switch ( tx_vfo )
{
case RIG_VFO_A :
2020-10-06 20:50:37 +00:00
case RIG_VFO_MAIN :
2019-11-30 16:19:08 +00:00
p1 = ' 0 ' ;
break ;
2009-11-28 14:27:37 +00:00
2019-11-30 16:19:08 +00:00
case RIG_VFO_B :
2020-10-06 20:50:37 +00:00
case RIG_VFO_SUB :
2019-11-30 16:19:08 +00:00
p1 = ' 1 ' ;
break ;
2009-11-28 14:27:37 +00:00
2019-11-30 16:19:08 +00:00
case RIG_VFO_MEM :
/* VFO A */
if ( priv - > current_mem = = NC_MEM_CHANNEL_NONE )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2019-11-30 16:19:08 +00:00
}
else /* Memory Channel mode */
{
p1 = ' 0 ' ;
}
break ;
2009-11-28 14:27:37 +00:00
2019-11-30 16:19:08 +00:00
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2019-11-30 16:19:08 +00:00
}
2009-11-28 14:27:37 +00:00
2019-11-30 16:19:08 +00:00
/* TODO: G4WJS - FT-450 only has toggle command so not sure how to
definitively set the TX VFO ( VS ; doesn ' t seem to help
either ) */
if ( newcat_is_rig ( rig , RIG_MODEL_FT950 ) | |
newcat_is_rig ( rig , RIG_MODEL_FT2000 ) | |
newcat_is_rig ( rig , RIG_MODEL_FTDX5000 ) | |
2020-10-26 08:08:41 +00:00
newcat_is_rig ( rig , RIG_MODEL_FTDX1200 ) | |
2019-11-30 16:19:08 +00:00
newcat_is_rig ( rig , RIG_MODEL_FT991 ) | |
newcat_is_rig ( rig , RIG_MODEL_FTDX3000 ) )
{
p1 = p1 + 2 ; /* use non-Toggle commands */
2009-11-28 14:27:37 +00:00
}
2020-10-26 08:06:38 +00:00
if ( is_ftdx101 )
2020-06-11 22:27:36 +00:00
{
// what other Yaeus rigs should be using this?
// The DX101D returns FT0 when in split and not transmitting
command = " ST " ;
}
2020-06-14 17:55:14 +00:00
2020-06-11 22:27:36 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%c%c " , command , p1 , cat_term ) ;
2019-11-30 16:19:08 +00:00
rig_debug ( RIG_DEBUG_TRACE , " cmd_str = %s \n " , priv - > cmd_str ) ;
/* Set TX VFO */
return newcat_set_cmd ( rig ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
/*
* newcat_get_tx_vfo does not set priv - > curr_vfo
*/
int newcat_get_tx_vfo ( RIG * rig , vfo_t * tx_vfo )
2008-09-22 21:34:45 +00:00
{
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2008-11-01 22:39:07 +00:00
int err ;
2019-11-30 16:19:08 +00:00
char c ;
vfo_t vfo_mode ;
char const * command = " FT " ;
2011-07-09 03:27:06 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2020-10-26 08:06:38 +00:00
if ( is_ftdx101 )
2020-06-10 21:25:19 +00:00
{
// what other Yaeus rigs should be using this?
// The DX101D returns FT0 when in split and not transmitting
command = " ST " ;
}
2019-11-30 16:19:08 +00:00
if ( ! newcat_valid_command ( rig , command ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2008-11-01 22:39:07 +00:00
2019-11-30 16:19:08 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%c " , command , cat_term ) ;
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
/* Get TX VFO */
if ( RIG_OK ! = ( err = newcat_get_cmd ( rig ) ) )
{
2008-11-01 22:39:07 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
c = priv - > ret_data [ 2 ] ;
2008-11-01 22:39:07 +00:00
2019-11-30 16:19:08 +00:00
switch ( c )
{
case ' 0 ' :
2020-10-10 16:44:40 +00:00
if ( rig - > state . vfo_list & RIG_VFO_MAIN ) { * tx_vfo = RIG_VFO_MAIN ; }
2020-10-07 04:14:27 +00:00
else { * tx_vfo = RIG_VFO_A ; }
2020-06-14 20:28:52 +00:00
rig - > state . cache . split = 0 ;
2019-11-30 16:19:08 +00:00
break ;
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
case ' 1 ' :
2020-10-10 16:44:40 +00:00
if ( rig - > state . vfo_list & RIG_VFO_SUB ) { * tx_vfo = RIG_VFO_SUB ; }
2020-10-07 04:14:27 +00:00
else { * tx_vfo = RIG_VFO_B ; }
2020-06-14 20:28:52 +00:00
rig - > state . cache . split = 1 ;
2019-11-30 16:19:08 +00:00
break ;
2008-11-01 22:39:07 +00:00
2019-11-30 16:19:08 +00:00
default :
rig_debug ( RIG_DEBUG_ERR , " %s: Unknown tx_vfo=%c from index 2 of %s \n " , __func__ ,
c , priv - > ret_data ) ;
return - RIG_EPROTO ;
}
2008-12-15 21:52:36 +00:00
2019-11-30 16:19:08 +00:00
/* Check to see if RIG is in MEM mode */
err = newcat_get_vfo_mode ( rig , & vfo_mode ) ;
2020-02-23 17:26:09 +00:00
if ( err ! = RIG_OK )
{
2020-01-14 18:50:48 +00:00
return err ;
}
2009-01-07 00:50:53 +00:00
2019-11-30 16:19:08 +00:00
if ( vfo_mode = = RIG_VFO_MEM & & * tx_vfo = = RIG_VFO_A )
{
* tx_vfo = RIG_VFO_MEM ;
2009-01-07 00:50:53 +00:00
}
2019-11-30 16:19:08 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: tx_vfo = %s \n " , __func__ , rig_strvfo ( * tx_vfo ) ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_set_vfo_from_alias ( RIG * rig , vfo_t * vfo )
2008-09-22 21:34:45 +00:00
{
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: alias vfo = %s \n " , __func__ , rig_strvfo ( * vfo ) ) ;
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
switch ( * vfo )
{
case RIG_VFO_A :
case RIG_VFO_B :
case RIG_VFO_MEM :
/* passes through */
break ;
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
case RIG_VFO_CURR : /* RIG_VFO_RX == RIG_VFO_CURR */
case RIG_VFO_VFO :
* vfo = rig - > state . current_vfo ;
break ;
2011-07-09 03:27:06 +00:00
2019-11-30 16:19:08 +00:00
case RIG_VFO_TX :
2020-10-07 04:14:27 +00:00
2019-11-30 16:19:08 +00:00
/* set to another vfo for split or uplink */
2020-10-07 04:14:27 +00:00
if ( rig - > state . vfo_list & RIG_VFO_MAIN )
{
* vfo = ( rig - > state . current_vfo = = RIG_VFO_SUB ) ? RIG_VFO_MAIN : RIG_VFO_SUB ;
}
else
{
* vfo = ( rig - > state . current_vfo = = RIG_VFO_B ) ? RIG_VFO_A : RIG_VFO_B ;
}
2019-11-30 16:19:08 +00:00
break ;
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
case RIG_VFO_MAIN :
2020-10-06 20:50:37 +00:00
* vfo = RIG_VFO_MAIN ;
2019-11-30 16:19:08 +00:00
break ;
2008-12-30 18:52:32 +00:00
2019-11-30 16:19:08 +00:00
case RIG_VFO_SUB :
2020-10-06 20:50:37 +00:00
* vfo = RIG_VFO_SUB ;
2019-11-30 16:19:08 +00:00
break ;
2008-12-30 18:52:32 +00:00
2019-11-30 16:19:08 +00:00
default :
2020-03-20 12:51:32 +00:00
rig_debug ( RIG_DEBUG_TRACE , " Unrecognized. vfo= %s \n " , rig_strvfo ( * vfo ) ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2019-11-30 16:19:08 +00:00
}
2008-12-30 18:52:32 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2019-11-30 16:19:08 +00:00
}
2008-12-30 18:52:32 +00:00
2019-11-30 16:19:08 +00:00
/*
* Found newcat_set_level ( ) floating point math problem
* Using rigctl on FT950 I was trying to set RIG_LEVEL_COMP to 12
* I kept setting it to 11. I wrote some test software and
* found out that 0.12 * 100 = 11 with my setup .
Fix spelling errors
Fixed using the following command:
codespell --write-changes --summary --skip=*.m4 --ignore-words-list="develope,get's,quitt,setts,som,ue,vektor"
codespell --write-changes --summary --skip=aclocal.m4,lib --ignore-words-list="develope,get's,quitt,setts,som,ue,vektor"
Codespell home page: https://github.com/codespell-project/codespell
2020-07-24 07:02:12 +00:00
* Compiler is gcc 4.2 .4 , CPU is AMD X2
2019-11-30 16:19:08 +00:00
* This works somewhat but Find a better way .
* The newcat_get_level ( ) seems to work correctly .
* Terry KJ4EED
*
*/
int newcat_scale_float ( int scale , float fval )
{
float f ;
float fudge = 0.003 ;
if ( ( fval + fudge ) > 1.0 )
{
f = scale * fval ;
}
else
{
f = scale * ( fval + fudge ) ;
}
return ( int ) f ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_set_narrow ( RIG * rig , vfo_t vfo , ncboolean narrow )
2008-09-22 21:34:45 +00:00
{
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2008-12-30 18:52:32 +00:00
int err ;
char c ;
2019-11-30 16:19:08 +00:00
char main_sub_vfo = ' 0 ' ;
2011-07-09 03:27:06 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
if ( ! newcat_valid_command ( rig , " NA " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2008-12-30 18:52:32 +00:00
2019-11-30 16:19:08 +00:00
err = newcat_set_vfo_from_alias ( rig , & vfo ) ;
if ( err < 0 )
{
2008-12-30 18:52:32 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2008-12-30 18:52:32 +00:00
2020-05-27 17:23:08 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
2019-11-30 16:19:08 +00:00
{
2020-10-06 20:50:37 +00:00
main_sub_vfo = ( RIG_VFO_B = = vfo | | RIG_VFO_SUB = = vfo ) ? ' 1 ' : ' 0 ' ;
2019-11-30 16:19:08 +00:00
}
2008-12-30 18:52:32 +00:00
2019-11-30 16:19:08 +00:00
if ( narrow = = TRUE )
{
c = ' 1 ' ;
}
else
{
c = ' 0 ' ;
}
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " NA%c%c%c " , main_sub_vfo , c ,
cat_term ) ;
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
rig_debug ( RIG_DEBUG_TRACE , " cmd_str = %s \n " , priv - > cmd_str ) ;
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
return newcat_set_cmd ( rig ) ;
2008-09-22 21:34:45 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_get_narrow ( RIG * rig , vfo_t vfo , ncboolean * narrow )
2009-01-10 14:52:49 +00:00
{
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2019-11-30 16:19:08 +00:00
int err ;
char c ;
char command [ ] = " NA " ;
char main_sub_vfo = ' 0 ' ;
2011-07-09 03:27:06 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2009-01-10 14:52:49 +00:00
2019-11-30 16:19:08 +00:00
if ( ! newcat_valid_command ( rig , command ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2009-11-28 14:27:37 +00:00
}
2019-11-30 16:19:08 +00:00
err = newcat_set_vfo_from_alias ( rig , & vfo ) ;
2009-11-28 14:27:37 +00:00
2019-11-30 16:19:08 +00:00
if ( err < 0 )
{
return err ;
2009-11-28 14:27:37 +00:00
}
2020-05-27 17:23:08 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
2019-11-30 16:19:08 +00:00
{
2020-10-06 20:50:37 +00:00
main_sub_vfo = ( RIG_VFO_B = = vfo | | RIG_VFO_SUB = = vfo ) ? ' 1 ' : ' 0 ' ;
2009-11-28 14:27:37 +00:00
}
2019-11-30 16:19:08 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%c%c " , command , main_sub_vfo ,
cat_term ) ;
2009-11-28 14:27:37 +00:00
2019-11-30 16:19:08 +00:00
/* Get NAR */
if ( RIG_OK ! = ( err = newcat_get_cmd ( rig ) ) )
{
2009-11-28 14:27:37 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2009-11-28 14:27:37 +00:00
2019-11-30 16:19:08 +00:00
c = priv - > ret_data [ 3 ] ;
if ( c = = ' 1 ' )
{
* narrow = TRUE ;
}
else
{
* narrow = FALSE ;
2009-11-28 14:27:37 +00:00
}
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2009-01-10 14:52:49 +00:00
}
2020-10-05 16:11:43 +00:00
// returns 1 if in narrow mode 0 if not, < 0 if error
2020-10-05 17:53:56 +00:00
// if vfo != RIG_VFO_NONE then will use NA0 or NA1 depending on vfo Main or Sub
static int get_narrow ( RIG * rig , vfo_t vfo )
2020-10-05 16:11:43 +00:00
{
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
int narrow = 0 ;
int err ;
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2020-10-05 16:11:43 +00:00
// find out if we're in narrow or wide mode
2020-10-05 22:00:19 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " NA%c%c " ,
vfo = = RIG_VFO_SUB ? ' 1 ' : ' 0 ' , cat_term ) ;
2020-10-05 16:11:43 +00:00
if ( RIG_OK ! = ( err = newcat_get_cmd ( rig ) ) )
{
return err ;
}
if ( sscanf ( priv - > ret_data , " NA%*1d%3d " , & narrow ) ! = 1 )
{
rig_debug ( RIG_DEBUG_ERR , " %s: unable to parse width from '%s' \n " , __func__ ,
priv - > ret_data ) ;
return - RIG_EPROTO ;
}
return narrow ;
}
2009-01-10 14:52:49 +00:00
2019-11-30 16:19:08 +00:00
int newcat_set_rx_bandwidth ( RIG * rig , vfo_t vfo , rmode_t mode , pbwidth_t width )
2008-09-22 21:34:45 +00:00
{
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2019-11-30 16:19:08 +00:00
int err ;
2020-10-05 22:00:19 +00:00
int w ;
2019-11-30 16:19:08 +00:00
char main_sub_vfo = ' 0 ' ;
2011-07-09 03:27:06 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s vfo=%s, mode=%s, width=%d \n " , __func__ ,
rig_strvfo ( vfo ) , rig_strrmode ( mode ) , ( int ) width ) ;
2008-09-22 21:34:45 +00:00
2019-11-30 16:19:08 +00:00
if ( ! newcat_valid_command ( rig , " SH " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2009-01-04 00:05:25 +00:00
2019-11-30 16:19:08 +00:00
err = newcat_set_vfo_from_alias ( rig , & vfo ) ;
2009-01-04 00:05:25 +00:00
2019-11-30 16:19:08 +00:00
if ( err < 0 )
{
return err ;
2009-01-07 00:50:53 +00:00
}
2009-01-04 00:05:25 +00:00
2020-10-05 22:00:19 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
2019-11-30 16:19:08 +00:00
{
2020-10-05 22:00:19 +00:00
main_sub_vfo = ( RIG_VFO_SUB = = vfo ) ? ' 1 ' : ' 0 ' ;
2019-11-30 16:19:08 +00:00
}
2009-01-04 00:05:25 +00:00
2020-11-10 20:17:15 +00:00
// NOTE: RIG_PASSBAND_NORMAL (0) should select the default filter width (SH00)
2020-10-05 22:00:19 +00:00
if ( is_ft950 )
2019-11-30 16:19:08 +00:00
{
switch ( mode )
{
case RIG_MODE_PKTUSB :
case RIG_MODE_PKTLSB :
case RIG_MODE_RTTY :
case RIG_MODE_RTTYR :
case RIG_MODE_CW :
case RIG_MODE_CWR :
2020-11-06 21:48:49 +00:00
// Narrow mode must be chosen correctly before filter width
err = newcat_set_narrow ( rig , vfo , width < = 500 ? TRUE : FALSE ) ;
2020-11-30 20:53:55 +00:00
2020-11-06 21:48:49 +00:00
if ( err ! = RIG_OK )
{
return err ;
}
2020-11-06 08:35:21 +00:00
if ( width = = RIG_PASSBAND_NORMAL ) { w = 0 ; }
else if ( width < = 100 ) { w = 3 ; }
2020-10-05 22:00:19 +00:00
else if ( width < = 200 ) { w = 4 ; }
else if ( width < = 300 ) { w = 5 ; }
else if ( width < = 400 ) { w = 6 ; }
else if ( width < = 500 ) { w = 7 ; }
else if ( width < = 800 ) { w = 8 ; }
else if ( width < = 1200 ) { w = 9 ; }
else if ( width < = 1400 ) { w = 10 ; }
else if ( width < = 1700 ) { w = 11 ; }
else if ( width < = 2000 ) { w = 12 ; }
2020-11-06 08:35:21 +00:00
else { w = 13 ; } // 2400 Hz
2020-11-30 20:53:55 +00:00
2019-11-30 16:19:08 +00:00
break ;
2009-01-07 00:50:53 +00:00
2019-11-30 16:19:08 +00:00
case RIG_MODE_LSB :
case RIG_MODE_USB :
2020-11-06 21:48:49 +00:00
// Narrow mode must be chosen correctly before filter width
err = newcat_set_narrow ( rig , vfo , width < = 1800 ? TRUE : FALSE ) ;
2020-11-30 20:53:55 +00:00
2020-11-06 21:48:49 +00:00
if ( err ! = RIG_OK )
{
return err ;
}
2020-11-06 08:35:21 +00:00
if ( width = = RIG_PASSBAND_NORMAL ) { w = 0 ; }
else if ( width < = 200 ) { w = 1 ; }
2020-10-05 22:00:19 +00:00
else if ( width < = 400 ) { w = 2 ; }
else if ( width < = 600 ) { w = 3 ; }
else if ( width < = 850 ) { w = 4 ; }
else if ( width < = 1100 ) { w = 5 ; }
else if ( width < = 1350 ) { w = 6 ; }
else if ( width < = 1500 ) { w = 7 ; }
else if ( width < = 1650 ) { w = 8 ; }
else if ( width < = 1800 ) { w = 9 ; }
else if ( width < = 1950 ) { w = 10 ; }
else if ( width < = 2100 ) { w = 11 ; }
else if ( width < = 2250 ) { w = 12 ; }
else if ( width < = 2400 ) { w = 13 ; }
else if ( width < = 2450 ) { w = 14 ; }
else if ( width < = 2500 ) { w = 15 ; }
else if ( width < = 2600 ) { w = 16 ; }
else if ( width < = 2700 ) { w = 17 ; }
else if ( width < = 2800 ) { w = 18 ; }
else if ( width < = 2900 ) { w = 19 ; }
2020-11-06 08:35:21 +00:00
else { w = 20 ; } // 3000 Hz
2020-11-30 20:53:55 +00:00
2019-11-30 16:19:08 +00:00
break ;
2008-09-22 21:34:45 +00:00
2020-11-06 21:48:49 +00:00
case RIG_MODE_AM :
case RIG_MODE_FM :
case RIG_MODE_PKTFM :
case RIG_MODE_FMN :
// Set roofing filter and narrow mode
break ;
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-11-06 21:48:49 +00:00
} // end switch(mode)
if ( ( err = set_roofing_filter_for_width ( rig , vfo , width ) ) ! = RIG_OK )
{
return err ;
}
switch ( mode )
{
2019-11-30 16:19:08 +00:00
case RIG_MODE_AM :
case RIG_MODE_FM :
case RIG_MODE_PKTFM :
2020-12-05 22:00:15 +00:00
if ( width > 0 & & width < rig_passband_normal ( rig , mode ) )
2019-11-30 16:19:08 +00:00
{
2020-12-28 21:17:49 +00:00
err = newcat_set_narrow ( rig , vfo , TRUE ) ;
2019-11-30 16:19:08 +00:00
}
else
{
err = newcat_set_narrow ( rig , vfo , FALSE ) ;
}
2020-11-30 20:53:55 +00:00
2019-11-30 16:19:08 +00:00
return err ;
2008-09-22 21:34:45 +00:00
2020-11-06 08:35:21 +00:00
case RIG_MODE_FMN :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2020-11-06 08:35:21 +00:00
}
} // end is_ft950 */
2020-10-05 22:00:19 +00:00
else if ( is_ft891 )
2019-11-30 16:19:08 +00:00
{
switch ( mode )
{
case RIG_MODE_PKTUSB :
case RIG_MODE_PKTLSB :
case RIG_MODE_RTTY :
case RIG_MODE_RTTYR :
case RIG_MODE_CW :
case RIG_MODE_CWR :
2020-11-06 21:48:49 +00:00
// Narrow mode must be chosen correctly before filter width
err = newcat_set_narrow ( rig , vfo , width < = 500 ? TRUE : FALSE ) ;
2020-11-30 20:53:55 +00:00
2020-11-06 21:48:49 +00:00
if ( err ! = RIG_OK )
{
return err ;
}
2020-11-06 08:35:21 +00:00
if ( width = = RIG_PASSBAND_NORMAL ) { w = 0 ; }
else if ( width < = 50 ) { w = 1 ; }
2020-10-05 22:00:19 +00:00
else if ( width < = 100 ) { w = 2 ; }
else if ( width < = 150 ) { w = 3 ; }
else if ( width < = 200 ) { w = 4 ; }
else if ( width < = 250 ) { w = 5 ; }
else if ( width < = 300 ) { w = 6 ; }
else if ( width < = 350 ) { w = 7 ; }
else if ( width < = 400 ) { w = 8 ; }
else if ( width < = 450 ) { w = 9 ; }
else if ( width < = 500 ) { w = 10 ; }
else if ( width < = 800 ) { w = 11 ; }
else if ( width < = 1200 ) { w = 12 ; }
else if ( width < = 1400 ) { w = 13 ; }
else if ( width < = 1700 ) { w = 14 ; }
else if ( width < = 2000 ) { w = 15 ; }
else if ( width < = 2400 ) { w = 16 ; }
2020-11-06 08:35:21 +00:00
else { w = 17 ; } // 3000 Hz
2020-11-30 20:53:55 +00:00
2019-11-30 16:19:08 +00:00
break ;
2008-11-28 22:59:08 +00:00
2019-11-30 16:19:08 +00:00
case RIG_MODE_LSB :
case RIG_MODE_USB :
2020-11-06 21:48:49 +00:00
// Narrow mode must be chosen correctly before filter width
err = newcat_set_narrow ( rig , vfo , width < = 1800 ? TRUE : FALSE ) ;
2020-11-30 20:53:55 +00:00
2020-11-06 21:48:49 +00:00
if ( err ! = RIG_OK )
{
return err ;
}
2020-11-06 08:35:21 +00:00
if ( width = = RIG_PASSBAND_NORMAL ) { w = 0 ; }
else if ( width < = 200 ) { w = 1 ; }
2020-10-05 22:00:19 +00:00
else if ( width < = 400 ) { w = 2 ; }
else if ( width < = 600 ) { w = 3 ; }
else if ( width < = 850 ) { w = 4 ; }
else if ( width < = 1100 ) { w = 5 ; }
else if ( width < = 1350 ) { w = 6 ; }
else if ( width < = 1500 ) { w = 7 ; }
2020-11-06 08:35:21 +00:00
else if ( width < = 1650 ) { w = 8 ; }
2020-10-05 22:00:19 +00:00
else if ( width < = 1800 ) { w = 9 ; }
else if ( width < = 1950 ) { w = 10 ; }
else if ( width < = 2100 ) { w = 11 ; }
else if ( width < = 2200 ) { w = 12 ; }
else if ( width < = 2300 ) { w = 13 ; }
else if ( width < = 2400 ) { w = 14 ; }
else if ( width < = 2500 ) { w = 15 ; }
else if ( width < = 2600 ) { w = 16 ; }
else if ( width < = 2700 ) { w = 17 ; }
else if ( width < = 2800 ) { w = 18 ; }
else if ( width < = 2900 ) { w = 19 ; }
else if ( width < = 3000 ) { w = 20 ; }
2020-11-06 08:35:21 +00:00
else { w = 21 ; } // 3000 Hz
2020-11-30 20:53:55 +00:00
2009-01-08 12:57:31 +00:00
break ;
2019-11-30 16:19:08 +00:00
case RIG_MODE_AM :
2020-05-06 20:23:14 +00:00
case RIG_MODE_FM :
2019-11-30 16:19:08 +00:00
case RIG_MODE_PKTFM :
2020-12-05 22:00:15 +00:00
if ( width > 0 & & width < rig_passband_normal ( rig , mode ) )
2019-11-30 16:19:08 +00:00
{
2020-12-28 21:17:49 +00:00
err = newcat_set_narrow ( rig , vfo , TRUE ) ;
2019-11-30 16:19:08 +00:00
}
else
{
err = newcat_set_narrow ( rig , vfo , FALSE ) ;
}
2020-11-30 20:53:55 +00:00
2019-11-30 16:19:08 +00:00
return err ;
2020-11-06 08:35:21 +00:00
case RIG_MODE_FMN :
break ;
2020-05-09 20:52:49 +00:00
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-11-06 08:35:21 +00:00
} // end switch(mode)
} // end is_ft891
2020-10-05 22:00:19 +00:00
else if ( is_ft991 )
2020-05-09 20:52:49 +00:00
{
switch ( mode )
{
case RIG_MODE_PKTUSB :
case RIG_MODE_PKTLSB :
case RIG_MODE_RTTY :
case RIG_MODE_RTTYR :
case RIG_MODE_CW :
case RIG_MODE_CWR :
2020-11-06 21:48:49 +00:00
// Narrow mode must be chosen correctly before filter width
err = newcat_set_narrow ( rig , vfo , width < = 500 ? TRUE : FALSE ) ;
2020-11-30 20:53:55 +00:00
2020-11-06 21:48:49 +00:00
if ( err ! = RIG_OK )
{
return err ;
}
2020-11-06 08:35:21 +00:00
if ( width = = RIG_PASSBAND_NORMAL ) { w = 0 ; }
else if ( width < = 50 ) { w = 1 ; }
2020-10-05 22:00:19 +00:00
else if ( width < = 100 ) { w = 2 ; }
else if ( width < = 150 ) { w = 3 ; }
else if ( width < = 200 ) { w = 4 ; }
else if ( width < = 250 ) { w = 5 ; }
else if ( width < = 305 ) { w = 6 ; }
else if ( width < = 350 ) { w = 7 ; }
else if ( width < = 400 ) { w = 8 ; }
else if ( width < = 450 ) { w = 9 ; }
else if ( width < = 500 ) { w = 10 ; }
else if ( width < = 800 ) { w = 11 ; }
else if ( width < = 1200 ) { w = 12 ; }
else if ( width < = 1400 ) { w = 13 ; }
else if ( width < = 1700 ) { w = 14 ; }
else if ( width < = 2000 ) { w = 15 ; }
else if ( width < = 2400 ) { w = 16 ; }
2020-11-06 08:35:21 +00:00
else { w = 17 ; } // 3000 Hz
2020-11-30 20:53:55 +00:00
2020-05-09 20:52:49 +00:00
break ;
case RIG_MODE_LSB :
case RIG_MODE_USB :
2020-11-06 21:48:49 +00:00
// Narrow mode must be chosen correctly before filter width
err = newcat_set_narrow ( rig , vfo , width < = 1800 ? TRUE : FALSE ) ;
2020-11-30 20:53:55 +00:00
2020-11-06 21:48:49 +00:00
if ( err ! = RIG_OK )
{
return err ;
}
2020-11-06 08:35:21 +00:00
if ( width = = RIG_PASSBAND_NORMAL ) { w = 0 ; }
else if ( width < = 200 ) { w = 1 ; }
2020-10-05 22:00:19 +00:00
else if ( width < = 400 ) { w = 2 ; }
else if ( width < = 600 ) { w = 3 ; }
else if ( width < = 850 ) { w = 4 ; }
else if ( width < = 1100 ) { w = 5 ; }
else if ( width < = 1350 ) { w = 6 ; }
else if ( width < = 1500 ) { w = 7 ; }
2020-11-06 08:35:21 +00:00
else if ( width < = 1650 ) { w = 8 ; }
2020-10-05 22:00:19 +00:00
else if ( width < = 1800 ) { w = 9 ; }
else if ( width < = 1950 ) { w = 10 ; }
else if ( width < = 2100 ) { w = 11 ; }
else if ( width < = 2200 ) { w = 12 ; }
else if ( width < = 2300 ) { w = 13 ; }
else if ( width < = 2400 ) { w = 14 ; }
else if ( width < = 2500 ) { w = 15 ; }
else if ( width < = 2600 ) { w = 16 ; }
else if ( width < = 2700 ) { w = 17 ; }
else if ( width < = 2800 ) { w = 18 ; }
else if ( width < = 2900 ) { w = 19 ; }
else if ( width < = 3000 ) { w = 20 ; }
2020-11-06 08:35:21 +00:00
else { w = 21 ; } // 3200 Hz
2020-11-30 20:53:55 +00:00
2020-05-09 20:52:49 +00:00
break ;
2020-11-06 08:35:21 +00:00
case RIG_MODE_AM : // Only 1 passband each for AM or AMN
if ( width = = RIG_PASSBAND_NORMAL | | width = = 9000 )
2020-05-09 20:52:49 +00:00
{
err = newcat_set_narrow ( rig , vfo , FALSE ) ;
}
2020-11-30 20:53:55 +00:00
2020-05-09 20:52:49 +00:00
return err ;
case RIG_MODE_AMN :
2020-11-06 08:35:21 +00:00
if ( width = = RIG_PASSBAND_NORMAL | | width = = 6000 )
2020-05-09 20:52:49 +00:00
{
2020-12-28 21:17:49 +00:00
err = newcat_set_narrow ( rig , vfo , TRUE ) ;
2020-05-09 20:52:49 +00:00
}
2020-11-30 20:53:55 +00:00
2020-05-09 20:52:49 +00:00
return err ;
2020-11-06 08:35:21 +00:00
case RIG_MODE_FM : // Only 1 passband each for FM or FMN
if ( width = = RIG_PASSBAND_NORMAL | | width = = 16000 )
2020-05-09 20:52:49 +00:00
{
err = newcat_set_narrow ( rig , vfo , FALSE ) ;
}
2020-11-30 20:53:55 +00:00
2020-05-09 20:52:49 +00:00
return err ;
case RIG_MODE_FMN :
2020-11-06 08:35:21 +00:00
if ( width = = RIG_PASSBAND_NORMAL | | width = = 9000 )
2020-05-09 20:52:49 +00:00
{
2020-12-28 21:17:49 +00:00
err = newcat_set_narrow ( rig , vfo , TRUE ) ;
2020-05-09 20:52:49 +00:00
}
2020-11-30 20:53:55 +00:00
2020-05-09 20:52:49 +00:00
return err ;
case RIG_MODE_C4FM :
2020-11-06 08:35:21 +00:00
if ( width = = RIG_PASSBAND_NORMAL | | width = = 16000 )
2020-05-09 20:52:49 +00:00
{
2020-12-28 21:17:49 +00:00
err = newcat_set_narrow ( rig , vfo , TRUE ) ;
2020-05-09 20:52:49 +00:00
}
else if ( width = = 9000 )
{
err = newcat_set_narrow ( rig , vfo , FALSE ) ;
}
else
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-05-09 20:52:49 +00:00
}
2020-11-30 20:53:55 +00:00
2020-05-09 20:52:49 +00:00
return err ;
case RIG_MODE_PKTFM :
2020-12-05 22:00:15 +00:00
if ( width > 0 & & width < rig_passband_normal ( rig , mode ) )
2020-05-09 20:52:49 +00:00
{
2020-12-28 21:17:49 +00:00
err = newcat_set_narrow ( rig , vfo , TRUE ) ;
2020-05-09 20:52:49 +00:00
}
else
{
err = newcat_set_narrow ( rig , vfo , FALSE ) ;
}
2020-11-30 20:53:55 +00:00
2020-05-09 20:52:49 +00:00
return err ;
2008-12-28 00:25:31 +00:00
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-11-06 08:35:21 +00:00
} // end switch(mode)
} // end is_ft991
else if ( is_ftdx1200 | | is_ftdx3000 )
2019-11-30 16:19:08 +00:00
{
2020-11-06 08:35:21 +00:00
// FTDX 1200 and FTDX 3000 have the same set of filter choices
2019-11-30 16:19:08 +00:00
switch ( mode )
{
case RIG_MODE_PKTUSB :
case RIG_MODE_PKTLSB :
case RIG_MODE_RTTY :
case RIG_MODE_RTTYR :
case RIG_MODE_CW :
case RIG_MODE_CWR :
2020-11-06 21:48:49 +00:00
// Narrow mode must be chosen correctly before filter width
err = newcat_set_narrow ( rig , vfo , width < = 500 ? TRUE : FALSE ) ;
2020-11-30 20:53:55 +00:00
2020-11-06 21:48:49 +00:00
if ( err ! = RIG_OK )
{
return err ;
}
2020-11-06 08:35:21 +00:00
if ( width = = RIG_PASSBAND_NORMAL ) { w = 0 ; }
2020-10-05 22:00:19 +00:00
else if ( width < = 50 ) { w = 1 ; }
else if ( width < = 100 ) { w = 2 ; }
else if ( width < = 150 ) { w = 3 ; }
else if ( width < = 200 ) { w = 4 ; }
else if ( width < = 250 ) { w = 5 ; }
else if ( width < = 300 ) { w = 6 ; }
else if ( width < = 350 ) { w = 7 ; }
else if ( width < = 400 ) { w = 8 ; }
else if ( width < = 450 ) { w = 9 ; }
else if ( width < = 500 ) { w = 10 ; }
else if ( width < = 800 ) { w = 11 ; }
else if ( width < = 1200 ) { w = 12 ; }
else if ( width < = 1400 ) { w = 13 ; }
else if ( width < = 1700 ) { w = 14 ; }
else if ( width < = 2000 ) { w = 15 ; }
2020-11-06 08:35:21 +00:00
else { w = 16 ; } // 2400 Hz
2020-11-30 20:53:55 +00:00
2008-12-28 00:25:31 +00:00
break ;
2008-12-10 23:53:56 +00:00
2019-11-30 16:19:08 +00:00
case RIG_MODE_LSB :
case RIG_MODE_USB :
2020-11-06 21:48:49 +00:00
// Narrow mode must be chosen correctly before filter width
err = newcat_set_narrow ( rig , vfo , width < = 1800 ? TRUE : FALSE ) ;
2020-11-30 20:53:55 +00:00
2020-11-06 21:48:49 +00:00
if ( err ! = RIG_OK )
{
return err ;
}
2020-11-06 08:35:21 +00:00
if ( width = = RIG_PASSBAND_NORMAL ) { w = 0 ; }
2020-10-05 22:00:19 +00:00
else if ( width < = 200 ) { w = 1 ; }
else if ( width < = 400 ) { w = 2 ; }
else if ( width < = 600 ) { w = 3 ; }
else if ( width < = 850 ) { w = 4 ; }
else if ( width < = 1100 ) { w = 5 ; }
else if ( width < = 1350 ) { w = 6 ; }
else if ( width < = 1500 ) { w = 7 ; }
else if ( width < = 1650 ) { w = 8 ; }
else if ( width < = 1800 ) { w = 9 ; }
else if ( width < = 1950 ) { w = 10 ; }
else if ( width < = 2100 ) { w = 11 ; }
else if ( width < = 2200 ) { w = 12 ; }
else if ( width < = 2300 ) { w = 13 ; }
else if ( width < = 2400 ) { w = 14 ; }
else if ( width < = 2500 ) { w = 15 ; }
else if ( width < = 2600 ) { w = 16 ; }
else if ( width < = 2700 ) { w = 17 ; }
else if ( width < = 2800 ) { w = 18 ; }
else if ( width < = 2900 ) { w = 19 ; }
else if ( width < = 3000 ) { w = 20 ; }
else if ( width < = 3200 ) { w = 21 ; }
else if ( width < = 3400 ) { w = 22 ; }
else if ( width < = 3600 ) { w = 23 ; }
else if ( width < = 3800 ) { w = 24 ; }
2020-11-06 08:35:21 +00:00
else { w = 25 ; } // 4000 Hz
2020-11-30 20:53:55 +00:00
2019-11-30 16:19:08 +00:00
break ;
2008-12-23 22:36:51 +00:00
2020-11-06 21:48:49 +00:00
case RIG_MODE_AM :
2020-11-07 22:15:48 +00:00
case RIG_MODE_AMN :
2020-11-06 21:48:49 +00:00
case RIG_MODE_FM :
case RIG_MODE_PKTFM :
case RIG_MODE_FMN :
// Set roofing filter and narrow mode
break ;
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-11-06 21:48:49 +00:00
} // end switch(mode)
if ( ( err = set_roofing_filter_for_width ( rig , vfo , width ) ) ! = RIG_OK )
{
return err ;
}
switch ( mode )
{
2019-11-30 16:19:08 +00:00
case RIG_MODE_AM :
2020-11-07 22:15:48 +00:00
case RIG_MODE_AMN :
2019-11-30 16:19:08 +00:00
case RIG_MODE_FM :
case RIG_MODE_PKTFM :
2020-11-07 22:15:48 +00:00
case RIG_MODE_FMN :
2020-12-05 22:00:15 +00:00
if ( width > 0 & & width < rig_passband_normal ( rig , mode ) )
2019-11-30 16:19:08 +00:00
{
2020-12-28 21:17:49 +00:00
err = newcat_set_narrow ( rig , vfo , TRUE ) ;
2019-11-30 16:19:08 +00:00
}
else
{
err = newcat_set_narrow ( rig , vfo , FALSE ) ;
}
2020-11-30 20:53:55 +00:00
2019-11-30 16:19:08 +00:00
return err ;
2020-11-06 08:35:21 +00:00
}
} // end is_ftdx1200 and is_ftdx3000
else if ( is_ftdx5000 )
{
switch ( mode )
{
case RIG_MODE_PKTUSB :
case RIG_MODE_PKTLSB :
case RIG_MODE_RTTY :
case RIG_MODE_RTTYR :
case RIG_MODE_CW :
case RIG_MODE_CWR :
2020-11-06 21:48:49 +00:00
// Narrow mode must be chosen correctly before filter width
err = newcat_set_narrow ( rig , vfo , width < = 500 ? TRUE : FALSE ) ;
2020-11-30 20:53:55 +00:00
2020-11-06 21:48:49 +00:00
if ( err ! = RIG_OK )
{
return err ;
}
2020-11-06 08:35:21 +00:00
if ( width = = RIG_PASSBAND_NORMAL ) { w = 0 ; }
else if ( width < = 50 ) { w = 1 ; }
else if ( width < = 100 ) { w = 2 ; }
else if ( width < = 150 ) { w = 3 ; }
else if ( width < = 200 ) { w = 4 ; }
else if ( width < = 250 ) { w = 5 ; }
else if ( width < = 300 ) { w = 6 ; }
else if ( width < = 350 ) { w = 7 ; }
else if ( width < = 400 ) { w = 8 ; }
else if ( width < = 450 ) { w = 9 ; }
else if ( width < = 500 ) { w = 10 ; }
else if ( width < = 800 ) { w = 11 ; }
else if ( width < = 1200 ) { w = 12 ; }
else if ( width < = 1400 ) { w = 13 ; }
else if ( width < = 1700 ) { w = 14 ; }
else if ( width < = 2000 ) { w = 15 ; }
else { w = 16 ; } // 2400 Hz
2020-11-30 20:53:55 +00:00
2020-11-06 08:35:21 +00:00
break ;
case RIG_MODE_LSB :
case RIG_MODE_USB :
2020-11-06 21:48:49 +00:00
// Narrow mode must be chosen correctly before filter width
err = newcat_set_narrow ( rig , vfo , width < = 1800 ? TRUE : FALSE ) ;
2020-11-30 20:53:55 +00:00
2020-11-06 21:48:49 +00:00
if ( err ! = RIG_OK )
{
return err ;
}
2020-11-06 08:35:21 +00:00
if ( width = = RIG_PASSBAND_NORMAL ) { w = 0 ; }
else if ( width < = 200 ) { w = 1 ; }
else if ( width < = 400 ) { w = 2 ; }
else if ( width < = 600 ) { w = 3 ; }
else if ( width < = 850 ) { w = 4 ; }
else if ( width < = 1100 ) { w = 5 ; }
else if ( width < = 1350 ) { w = 6 ; }
else if ( width < = 1500 ) { w = 7 ; }
else if ( width < = 1650 ) { w = 8 ; }
else if ( width < = 1800 ) { w = 9 ; }
else if ( width < = 1950 ) { w = 10 ; }
else if ( width < = 2100 ) { w = 11 ; }
else if ( width < = 2250 ) { w = 12 ; }
else if ( width < = 2400 ) { w = 13 ; }
else if ( width < = 2500 ) { w = 15 ; }
else if ( width < = 2600 ) { w = 16 ; }
else if ( width < = 2700 ) { w = 17 ; }
else if ( width < = 2800 ) { w = 18 ; }
else if ( width < = 2900 ) { w = 19 ; }
else if ( width < = 3000 ) { w = 20 ; }
else if ( width < = 3200 ) { w = 21 ; }
else if ( width < = 3400 ) { w = 22 ; }
else if ( width < = 3600 ) { w = 23 ; }
else if ( width < = 3800 ) { w = 24 ; }
else { w = 25 ; } // 4000 Hz
2020-11-30 20:53:55 +00:00
2020-11-06 08:35:21 +00:00
break ;
2020-11-06 21:48:49 +00:00
case RIG_MODE_AM :
2020-11-07 22:15:48 +00:00
case RIG_MODE_AMN :
2020-11-06 21:48:49 +00:00
case RIG_MODE_FM :
case RIG_MODE_PKTFM :
case RIG_MODE_FMN :
// Set roofing filter and narrow mode
break ;
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-11-06 21:48:49 +00:00
} // end switch(mode)
if ( ( err = set_roofing_filter_for_width ( rig , vfo , width ) ) ! = RIG_OK )
{
return err ;
}
switch ( mode )
{
2020-11-06 08:35:21 +00:00
case RIG_MODE_AM :
2020-11-07 22:15:48 +00:00
case RIG_MODE_AMN :
2020-11-06 08:35:21 +00:00
case RIG_MODE_FM :
case RIG_MODE_PKTFM :
2020-11-07 22:15:48 +00:00
case RIG_MODE_FMN :
2020-12-05 22:00:15 +00:00
if ( width > 0 & & width < rig_passband_normal ( rig , mode ) )
2020-11-06 08:35:21 +00:00
{
2020-12-28 21:17:49 +00:00
err = newcat_set_narrow ( rig , vfo , TRUE ) ;
2020-11-06 08:35:21 +00:00
}
else
{
err = newcat_set_narrow ( rig , vfo , FALSE ) ;
}
2020-11-30 20:53:55 +00:00
2020-11-06 08:35:21 +00:00
return err ;
}
} // end is_ftdx5000
2020-12-28 21:17:49 +00:00
else if ( is_ftdx101 | | is_ftdx10 )
2020-10-03 20:06:53 +00:00
{
switch ( mode )
{
case RIG_MODE_PKTUSB :
case RIG_MODE_PKTLSB :
case RIG_MODE_RTTY :
case RIG_MODE_RTTYR :
case RIG_MODE_CW :
case RIG_MODE_CWR :
2020-11-10 20:17:15 +00:00
if ( width = = RIG_PASSBAND_NORMAL ) { w = 0 ; }
2020-10-04 17:25:36 +00:00
else if ( width < = 50 ) { w = 1 ; }
else if ( width < = 100 ) { w = 2 ; }
else if ( width < = 150 ) { w = 3 ; }
else if ( width < = 200 ) { w = 4 ; }
else if ( width < = 250 ) { w = 5 ; }
else if ( width < = 300 ) { w = 6 ; }
else if ( width < = 350 ) { w = 7 ; }
else if ( width < = 400 ) { w = 8 ; }
else if ( width < = 450 ) { w = 9 ; }
else if ( width < = 500 ) { w = 10 ; }
else if ( width < = 600 ) { w = 11 ; }
else if ( width < = 800 ) { w = 12 ; }
else if ( width < = 1200 ) { w = 13 ; }
else if ( width < = 1400 ) { w = 14 ; }
else if ( width < = 1700 ) { w = 15 ; }
else if ( width < = 2000 ) { w = 16 ; }
else if ( width < = 2400 ) { w = 17 ; }
else { w = 18 ; }
2020-11-30 20:53:55 +00:00
2020-10-03 20:06:53 +00:00
break ;
case RIG_MODE_LSB :
case RIG_MODE_USB :
2020-11-10 20:17:15 +00:00
if ( width = = RIG_PASSBAND_NORMAL ) { w = 0 ; }
2020-10-04 17:25:36 +00:00
else if ( width < = 300 ) { w = 1 ; }
else if ( width < = 400 ) { w = 2 ; }
else if ( width < = 600 ) { w = 3 ; }
else if ( width < = 850 ) { w = 4 ; }
else if ( width < = 1100 ) { w = 5 ; }
else if ( width < = 1200 ) { w = 6 ; }
else if ( width < = 1500 ) { w = 7 ; }
else if ( width < = 1650 ) { w = 8 ; }
else if ( width < = 1800 ) { w = 9 ; }
else if ( width < = 1950 ) { w = 10 ; }
else if ( width < = 2100 ) { w = 11 ; }
else if ( width < = 2200 ) { w = 12 ; }
else if ( width < = 2300 ) { w = 13 ; }
else if ( width < = 2400 ) { w = 14 ; }
else if ( width < = 2500 ) { w = 15 ; }
else if ( width < = 2600 ) { w = 16 ; }
else if ( width < = 2700 ) { w = 17 ; }
else if ( width < = 2800 ) { w = 18 ; }
else if ( width < = 2900 ) { w = 19 ; }
else if ( width < = 3000 ) { w = 20 ; }
else if ( width < = 3200 ) { w = 21 ; }
else if ( width < = 3500 ) { w = 22 ; }
else { w = 23 ; } // 4000Hz
2020-11-30 20:53:55 +00:00
2020-11-06 08:35:21 +00:00
break ;
2020-11-06 21:48:49 +00:00
case RIG_MODE_AM :
case RIG_MODE_AMN :
case RIG_MODE_FM :
case RIG_MODE_PKTFM :
case RIG_MODE_FMN :
// Set roofing filter and narrow mode
break ;
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-10-05 22:00:19 +00:00
} // end switch(mode)
2020-10-07 17:48:25 +00:00
2020-10-25 16:06:13 +00:00
if ( ( err = set_roofing_filter_for_width ( rig , vfo , width ) ) ! = RIG_OK )
2020-10-07 14:00:21 +00:00
{
return err ;
}
2020-11-06 21:48:49 +00:00
switch ( mode )
{
case RIG_MODE_AM :
case RIG_MODE_FM :
case RIG_MODE_PKTFM :
2020-12-05 22:00:15 +00:00
if ( width > 0 & & width < rig_passband_normal ( rig , mode ) )
2020-11-06 21:48:49 +00:00
{
2020-12-28 21:17:49 +00:00
err = newcat_set_narrow ( rig , vfo , TRUE ) ;
2020-11-06 21:48:49 +00:00
}
else
{
err = newcat_set_narrow ( rig , vfo , FALSE ) ;
}
2020-11-30 20:53:55 +00:00
2020-11-06 21:48:49 +00:00
return err ;
case RIG_MODE_AMN :
case RIG_MODE_FMN :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2020-11-06 21:48:49 +00:00
}
2020-10-26 08:06:38 +00:00
} // end is_ftdx101
2020-12-05 21:11:12 +00:00
else if ( is_ft2000 )
{
// We need details on the widths here, manuals lack information.
switch ( mode )
{
case RIG_MODE_CW :
case RIG_MODE_CWR :
// Narrow mode overrides DSP filter width on FT-2000
newcat_set_narrow ( rig , vfo , FALSE ) ;
2020-12-05 21:43:07 +00:00
// CW bandwidth is 2400 Hz at value 16
2020-12-05 21:11:12 +00:00
if ( width = = RIG_PASSBAND_NORMAL ) { w = 16 ; }
2020-12-05 21:43:07 +00:00
else if ( width < = 200 ) { w = 4 ; }
else if ( width < = 500 ) { w = 6 ; }
else if ( width < = 2400 ) { w = 16 ; }
else { w = 31 ; } // No effect?
break ;
2020-12-05 22:00:15 +00:00
case RIG_MODE_PKTUSB :
case RIG_MODE_PKTLSB :
// Narrow mode overrides DSP filter width on FT-2000
newcat_set_narrow ( rig , vfo , FALSE ) ;
// Packet SSB bandwidth is 2400 Hz at value 31
if ( width = = RIG_PASSBAND_NORMAL ) { w = 31 ; }
else if ( width < = 200 ) { w = 8 ; }
else if ( width < = 500 ) { w = 16 ; }
else { w = 31 ; } // 2400
break ;
2020-12-05 21:43:07 +00:00
case RIG_MODE_RTTY :
case RIG_MODE_RTTYR :
// Narrow mode overrides DSP filter width on FT-2000
newcat_set_narrow ( rig , vfo , FALSE ) ;
if ( width = = RIG_PASSBAND_NORMAL ) { w = 16 ; }
else if ( width < = 300 ) { w = 8 ; }
2020-12-05 21:11:12 +00:00
else if ( width < = 500 ) { w = 16 ; }
else { w = 31 ; } // 2400
break ;
case RIG_MODE_LSB :
case RIG_MODE_USB :
// Narrow mode overrides DSP filter width on FT-2000
newcat_set_narrow ( rig , vfo , FALSE ) ;
if ( width = = RIG_PASSBAND_NORMAL ) { w = 16 ; }
else if ( width < = 1800 ) { w = 8 ; }
else if ( width < = 2400 ) { w = 16 ; }
else if ( width < = 3000 ) { w = 25 ; }
else { w = 31 ; } // 4000
break ;
case RIG_MODE_AM :
case RIG_MODE_FM :
case RIG_MODE_PKTFM :
case RIG_MODE_AMN :
case RIG_MODE_FMN :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2020-12-05 21:11:12 +00:00
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-12-05 21:11:12 +00:00
}
if ( ( err = set_roofing_filter_for_width ( rig , vfo , width ) ) ! = RIG_OK )
{
return err ;
}
switch ( mode )
{
case RIG_MODE_AM :
case RIG_MODE_AMN :
case RIG_MODE_FM :
case RIG_MODE_PKTFM :
case RIG_MODE_FMN :
2020-12-05 22:00:15 +00:00
if ( width > 0 & & width < rig_passband_normal ( rig , mode ) )
2020-12-05 21:11:12 +00:00
{
2020-12-28 21:17:49 +00:00
err = newcat_set_narrow ( rig , vfo , TRUE ) ;
2020-12-05 21:11:12 +00:00
}
else
{
err = newcat_set_narrow ( rig , vfo , FALSE ) ;
}
return err ;
}
}
2020-10-07 04:14:27 +00:00
else
2019-11-30 16:19:08 +00:00
{
2020-12-05 21:11:12 +00:00
// FT-450, FTDX 9000
2020-11-04 22:07:53 +00:00
// We need details on the widths here, manuals lack information.
2019-11-30 16:19:08 +00:00
switch ( mode )
{
case RIG_MODE_PKTUSB :
case RIG_MODE_PKTLSB :
case RIG_MODE_RTTY :
case RIG_MODE_RTTYR :
case RIG_MODE_CW :
case RIG_MODE_CWR :
2020-12-05 21:11:12 +00:00
if ( width = = RIG_PASSBAND_NORMAL ) { w = 16 ; }
else if ( width < = 500 ) { w = 6 ; }
2020-10-07 04:14:27 +00:00
else if ( width < = 1800 ) { w = 16 ; }
else { w = 24 ; }
2020-11-30 20:53:55 +00:00
2019-11-30 16:19:08 +00:00
break ;
case RIG_MODE_LSB :
case RIG_MODE_USB :
2020-12-05 21:11:12 +00:00
if ( width = = RIG_PASSBAND_NORMAL ) { w = 16 ; }
else if ( width < = 1800 ) { w = 8 ; }
2020-10-07 04:14:27 +00:00
else if ( width < = 2400 ) { w = 16 ; }
else { w = 25 ; } // 3000
2020-11-30 20:53:55 +00:00
2019-11-30 16:19:08 +00:00
break ;
case RIG_MODE_AM :
case RIG_MODE_FM :
case RIG_MODE_PKTFM :
2020-12-05 22:00:15 +00:00
if ( width > 0 & & width < rig_passband_normal ( rig , mode ) )
2019-11-30 16:19:08 +00:00
{
2020-12-28 21:17:49 +00:00
err = newcat_set_narrow ( rig , vfo , TRUE ) ;
2019-11-30 16:19:08 +00:00
}
else
{
err = newcat_set_narrow ( rig , vfo , FALSE ) ;
}
2020-11-30 20:53:55 +00:00
2019-11-30 16:19:08 +00:00
return err ;
2020-11-06 21:48:49 +00:00
case RIG_MODE_FMN :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2020-11-06 21:48:49 +00:00
2019-11-30 16:19:08 +00:00
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-11-06 21:48:49 +00:00
} /* end switch(mode) */
2020-10-05 22:00:19 +00:00
2020-11-06 08:35:21 +00:00
} /* end else */
2008-12-23 22:36:51 +00:00
2020-12-28 21:17:49 +00:00
if ( is_ftdx101 | | is_ft891 | | is_ftdx10 )
2020-10-07 14:19:44 +00:00
{
2020-12-18 14:52:38 +00:00
// some rigs now require the bandwidth be turned "on"
int on = is_ft891 ;
2020-12-22 05:50:29 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " SH%c%d%02d; " , main_sub_vfo , on ,
w ) ;
2020-10-07 14:19:44 +00:00
}
2021-01-08 07:12:29 +00:00
else if ( is_ft2000 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " SH0%02d; " , w ) ;
}
2020-10-07 14:19:44 +00:00
else
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " SH%c%02d; " , main_sub_vfo , w ) ;
}
2008-12-23 22:36:51 +00:00
2020-10-03 20:06:53 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: cmd_str = %s \n " , __func__ , priv - > cmd_str ) ;
2009-01-04 00:05:25 +00:00
2008-12-23 22:36:51 +00:00
/* Set RX Bandwidth */
2015-09-29 20:06:12 +00:00
return newcat_set_cmd ( rig ) ;
2008-12-23 22:36:51 +00:00
}
2020-10-25 16:06:13 +00:00
static int set_roofing_filter ( RIG * rig , vfo_t vfo , int index )
{
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
struct newcat_priv_caps * priv_caps = ( struct newcat_priv_caps * ) rig - > caps - > priv ;
2020-10-26 08:44:01 +00:00
struct newcat_roofing_filter * roofing_filters ;
2020-10-25 16:06:13 +00:00
char main_sub_vfo = ' 0 ' ;
char roofing_filter_choice = 0 ;
int err ;
2020-10-25 20:20:42 +00:00
int i ;
2020-10-25 16:06:13 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2020-10-25 16:06:13 +00:00
if ( priv_caps = = NULL )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2020-10-25 16:06:13 +00:00
}
2020-10-26 08:44:01 +00:00
roofing_filters = priv_caps - > roofing_filters ;
2020-10-25 16:06:13 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
{
main_sub_vfo = ( RIG_VFO_B = = vfo | | RIG_VFO_SUB = = vfo ) ? ' 1 ' : ' 0 ' ;
}
if ( ! newcat_valid_command ( rig , " RF " ) )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2020-10-25 16:06:13 +00:00
}
2020-10-25 20:20:42 +00:00
for ( i = 0 ; roofing_filters [ i ] . index > = 0 ; i + + )
2020-10-25 16:06:13 +00:00
{
2020-10-25 20:20:42 +00:00
struct newcat_roofing_filter * current_filter = & roofing_filters [ i ] ;
2020-10-25 16:06:13 +00:00
char set_value = current_filter - > set_value ;
2020-10-28 13:45:53 +00:00
2020-10-25 16:06:13 +00:00
if ( set_value = = 0 )
{
continue ;
}
roofing_filter_choice = set_value ;
if ( current_filter - > index = = index )
{
break ;
}
}
if ( roofing_filter_choice = = 0 )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-10-25 16:06:13 +00:00
}
2020-10-28 13:45:53 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " RF%c%c%c " , main_sub_vfo ,
roofing_filter_choice , cat_term ) ;
2020-10-25 16:06:13 +00:00
2020-10-25 20:24:40 +00:00
priv - > question_mark_response_means_rejected = 1 ;
err = newcat_set_cmd ( rig ) ;
priv - > question_mark_response_means_rejected = 0 ;
if ( RIG_OK ! = err )
2020-10-25 16:06:13 +00:00
{
return err ;
}
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2020-10-25 16:06:13 +00:00
}
static int set_roofing_filter_for_width ( RIG * rig , vfo_t vfo , int width )
{
struct newcat_priv_caps * priv_caps = ( struct newcat_priv_caps * ) rig - > caps - > priv ;
2020-11-07 21:46:09 +00:00
int index = 0 ;
2020-10-25 16:06:13 +00:00
int i ;
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2020-10-25 16:06:13 +00:00
if ( priv_caps = = NULL )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2020-10-25 16:06:13 +00:00
}
for ( i = 0 ; i < priv_caps - > roofing_filter_count ; i + + )
{
struct newcat_roofing_filter * current_filter = & priv_caps - > roofing_filters [ i ] ;
char set_value = current_filter - > set_value ;
// Skip get-only values and optional filters
if ( set_value = = 0 | | current_filter - > optional )
{
continue ;
}
// The last filter is always the narrowest
if ( current_filter - > width < width )
{
break ;
}
2020-10-25 20:30:40 +00:00
2020-10-26 07:14:26 +00:00
index = current_filter - > index ;
2020-10-25 16:06:13 +00:00
}
return set_roofing_filter ( rig , vfo , index ) ;
}
2020-10-28 13:45:53 +00:00
static int get_roofing_filter ( RIG * rig , vfo_t vfo ,
struct newcat_roofing_filter * * roofing_filter )
2020-10-04 13:38:46 +00:00
{
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2020-10-25 16:06:13 +00:00
struct newcat_priv_caps * priv_caps = ( struct newcat_priv_caps * ) rig - > caps - > priv ;
2020-10-26 08:44:01 +00:00
struct newcat_roofing_filter * roofing_filters ;
2020-10-25 16:06:13 +00:00
char roofing_filter_choice ;
2020-10-04 13:38:46 +00:00
char main_sub_vfo = ' 0 ' ;
char rf_vfo = ' X ' ;
int err ;
int n ;
2020-10-25 16:06:13 +00:00
int i ;
2020-10-04 13:38:46 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2020-10-04 13:38:46 +00:00
2020-10-25 16:06:13 +00:00
if ( priv_caps = = NULL )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2020-10-25 16:06:13 +00:00
}
2020-10-26 08:44:01 +00:00
roofing_filters = priv_caps - > roofing_filters ;
2020-10-04 13:38:46 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
{
2020-10-06 20:50:37 +00:00
main_sub_vfo = ( RIG_VFO_B = = vfo | | RIG_VFO_SUB = = vfo ) ? ' 1 ' : ' 0 ' ;
2020-10-04 13:38:46 +00:00
}
2020-10-28 13:45:53 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " RF%c%c " , main_sub_vfo ,
cat_term ) ;
2020-10-04 13:38:46 +00:00
if ( RIG_OK ! = ( err = newcat_get_cmd ( rig ) ) )
{
return err ;
}
2020-10-25 16:06:13 +00:00
n = sscanf ( priv - > ret_data , " RF%c%c " , & rf_vfo , & roofing_filter_choice ) ;
2020-10-04 13:38:46 +00:00
if ( n ! = 2 )
{
rig_debug ( RIG_DEBUG_ERR ,
" %s: error parsing '%s' for vfo and roofing filter, got %d parsed \n " , __func__ ,
priv - > ret_data , n ) ;
return - RIG_EPROTO ;
}
2020-10-25 16:06:13 +00:00
for ( i = 0 ; i < priv_caps - > roofing_filter_count ; i + + )
{
struct newcat_roofing_filter * current_filter = & roofing_filters [ i ] ;
2020-10-28 13:45:53 +00:00
2020-10-25 16:06:13 +00:00
if ( current_filter - > get_value = = roofing_filter_choice )
{
* roofing_filter = current_filter ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2020-10-25 16:06:13 +00:00
}
}
rig_debug ( RIG_DEBUG_ERR ,
2020-10-28 13:45:53 +00:00
" %s: Expected a valid roofing filter but got %c from '%s' \n " , __func__ ,
roofing_filter_choice , priv - > ret_data ) ;
2020-10-25 16:06:13 +00:00
2020-10-25 20:14:19 +00:00
return RIG_EPROTO ;
2020-10-04 13:38:46 +00:00
}
2008-12-23 22:36:51 +00:00
2009-01-07 20:59:12 +00:00
int newcat_get_rx_bandwidth ( RIG * rig , vfo_t vfo , rmode_t mode , pbwidth_t * width )
2008-12-23 22:36:51 +00:00
{
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2008-12-23 22:36:51 +00:00
int err ;
2009-11-22 21:52:11 +00:00
int w ;
2020-11-07 21:30:34 +00:00
int sh_command_valid = 1 ;
2020-12-05 22:11:44 +00:00
int narrow = 0 ;
2008-12-23 22:36:51 +00:00
char cmd [ ] = " SH " ;
char main_sub_vfo = ' 0 ' ;
2011-07-09 03:27:06 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
rig_debug ( RIG_DEBUG_TRACE , " %s vfo=%s, mode=%s \n " , __func__ ,
2020-12-22 05:50:29 +00:00
rig_strvfo ( vfo ) , rig_strrmode ( mode ) ) ;
2008-12-23 22:36:51 +00:00
if ( ! newcat_valid_command ( rig , cmd ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2008-12-23 22:36:51 +00:00
err = newcat_set_vfo_from_alias ( rig , & vfo ) ;
2019-11-30 16:19:08 +00:00
2008-12-23 22:36:51 +00:00
if ( err < 0 )
2019-11-30 16:19:08 +00:00
{
2008-12-23 22:36:51 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2008-12-23 22:36:51 +00:00
2020-11-07 21:30:34 +00:00
if ( is_ft950 | | is_ftdx5000 )
2020-10-07 04:14:27 +00:00
{
2020-11-07 21:30:34 +00:00
// Some Yaesu rigs cannot query SH in modes such as AM/FM
2020-11-07 21:46:09 +00:00
switch ( mode )
2020-10-06 21:51:34 +00:00
{
2020-11-07 21:30:34 +00:00
case RIG_MODE_FM :
case RIG_MODE_FMN :
case RIG_MODE_PKTFM :
case RIG_MODE_AM :
case RIG_MODE_AMN :
case RIG_MODE_PKTAM :
sh_command_valid = 0 ;
break ;
2020-10-06 21:51:34 +00:00
}
}
2020-05-27 17:23:08 +00:00
if ( rig - > caps - > targetable_vfo & RIG_TARGETABLE_MODE )
2019-11-30 16:19:08 +00:00
{
2020-10-06 20:50:37 +00:00
main_sub_vfo = ( RIG_VFO_B = = vfo | | RIG_VFO_SUB = = vfo ) ? ' 1 ' : ' 0 ' ;
2019-11-30 16:19:08 +00:00
}
2008-12-23 22:36:51 +00:00
2020-11-07 21:30:34 +00:00
if ( sh_command_valid )
2019-11-30 16:19:08 +00:00
{
2021-01-08 07:12:29 +00:00
if ( is_ft2000 )
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s0%c " , cmd , cat_term ) ;
}
else
{
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%c%c " , cmd , main_sub_vfo ,
2021-01-09 16:13:17 +00:00
cat_term ) ;
2021-01-08 07:12:29 +00:00
}
2009-01-07 20:59:12 +00:00
2020-11-07 21:30:34 +00:00
err = newcat_get_cmd ( rig ) ;
2020-11-30 20:53:55 +00:00
2020-11-07 21:30:34 +00:00
if ( err ! = RIG_OK )
2020-10-07 17:48:25 +00:00
{
2020-11-07 21:30:34 +00:00
return err ;
2020-10-07 17:48:25 +00:00
}
2020-11-07 21:30:34 +00:00
2020-12-15 21:25:28 +00:00
w = 0 ; // use default in case of error
2020-12-17 21:07:04 +00:00
2020-12-15 21:25:28 +00:00
if ( strlen ( priv - > ret_data ) = = 7 )
2020-11-07 21:30:34 +00:00
{
2020-12-15 21:25:28 +00:00
int on ;
2020-12-18 05:57:25 +00:00
// do we need to pay attention to the Main/Sub here?
int n = sscanf ( priv - > ret_data , " SH%*1d%1d%3d " , & on , & w ) ;
2020-12-22 05:50:29 +00:00
2020-12-18 05:57:25 +00:00
if ( n ! = 2 )
{
err = - RIG_EPROTO ;
}
2020-12-17 21:07:04 +00:00
2020-12-18 05:57:25 +00:00
#if 0 // this may apply to another Yaesu rig
2020-12-22 05:50:29 +00:00
2020-12-17 21:07:04 +00:00
if ( n = = 2 )
{
2020-12-15 21:25:28 +00:00
if ( ! on ) { w = 0 ; }
}
else
2020-12-09 23:48:09 +00:00
{
err = - RIG_EPROTO ;
2020-12-15 21:25:28 +00:00
}
2020-12-22 05:50:29 +00:00
2020-12-18 05:57:25 +00:00
# endif
2020-12-15 21:25:28 +00:00
}
else if ( strlen ( priv - > ret_data ) = = 6 )
{
int n = sscanf ( priv - > ret_data , " SH%3d " , & w ) ;
2020-12-17 21:07:04 +00:00
if ( n ! = 1 ) { err = - RIG_EPROTO ; }
2020-12-15 21:25:28 +00:00
}
else
{
err = - RIG_EPROTO ;
2020-11-07 21:30:34 +00:00
}
2020-12-15 21:25:28 +00:00
2020-12-17 21:07:04 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: w=%d \n " , __func__ , w ) ;
2020-11-07 21:30:34 +00:00
if ( err ! = RIG_OK )
{
rig_debug ( RIG_DEBUG_ERR , " %s: unable to parse width from '%s' \n " , __func__ ,
priv - > ret_data ) ;
return - RIG_EPROTO ;
}
2020-10-07 14:19:44 +00:00
}
2020-10-07 17:48:25 +00:00
else
{
2020-11-07 21:30:34 +00:00
// Some Yaesu rigs cannot query filter width using SH command in modes such as AM/FM
w = 0 ;
2020-10-05 16:11:43 +00:00
}
2020-10-07 04:14:27 +00:00
2020-11-06 08:35:21 +00:00
if ( is_ft950 )
2019-11-30 16:19:08 +00:00
{
2020-10-05 17:53:56 +00:00
if ( ( narrow = get_narrow ( rig , RIG_VFO_MAIN ) ) < 0 )
2019-11-30 16:19:08 +00:00
{
2020-10-05 16:11:43 +00:00
return - RIG_EPROTO ;
}
2008-12-23 22:36:51 +00:00
2019-11-30 16:19:08 +00:00
switch ( mode )
{
case RIG_MODE_PKTUSB :
case RIG_MODE_PKTLSB :
case RIG_MODE_RTTY :
case RIG_MODE_RTTYR :
case RIG_MODE_CW :
case RIG_MODE_CWR :
switch ( w )
{
2020-10-05 16:11:43 +00:00
case 0 :
2020-11-06 08:35:21 +00:00
* width = narrow ? 300 : 500 ;
2020-10-05 16:11:43 +00:00
break ;
2019-11-30 16:19:08 +00:00
2020-11-06 08:35:21 +00:00
case 3 : * width = 100 ; break ;
2019-11-30 16:19:08 +00:00
2020-11-06 08:35:21 +00:00
case 4 : * width = 200 ; break ;
2019-11-30 16:19:08 +00:00
2020-11-06 08:35:21 +00:00
case 5 : * width = 300 ; break ;
2019-11-30 16:19:08 +00:00
2020-11-06 08:35:21 +00:00
case 6 : * width = 400 ; break ;
2019-11-30 16:19:08 +00:00
2020-11-06 08:35:21 +00:00
case 7 : * width = 5000 ; break ;
2019-11-30 16:19:08 +00:00
2020-11-06 08:35:21 +00:00
case 8 : * width = 800 ; break ;
2020-10-05 16:34:38 +00:00
2020-11-06 08:35:21 +00:00
case 9 : * width = 1200 ; break ;
2020-10-05 16:34:38 +00:00
2020-11-06 08:35:21 +00:00
case 10 : * width = 1400 ; break ;
2020-10-05 16:34:38 +00:00
2020-11-06 08:35:21 +00:00
case 11 : * width = 1700 ; break ;
2020-10-05 16:34:38 +00:00
2020-11-06 08:35:21 +00:00
case 12 : * width = 2000 ; break ;
2020-10-05 16:34:38 +00:00
2020-11-06 08:35:21 +00:00
case 13 : * width = 2400 ; break ;
2019-11-30 16:19:08 +00:00
2021-01-17 13:25:28 +00:00
default : RETURNFUNC ( - RIG_EINVAL ) ;
2019-11-30 16:19:08 +00:00
}
break ;
case RIG_MODE_LSB :
case RIG_MODE_USB :
2020-11-06 08:35:21 +00:00
switch ( w )
2019-11-30 16:19:08 +00:00
{
2020-10-05 16:11:43 +00:00
case 0 :
2020-11-06 08:35:21 +00:00
* width = narrow ? 1800 : 2400 ;
2020-10-05 16:11:43 +00:00
break ;
2019-11-30 16:19:08 +00:00
2020-10-05 16:11:43 +00:00
case 1 : * width = 200 ; break ;
2019-11-30 16:19:08 +00:00
2020-10-05 16:11:43 +00:00
case 2 : * width = 400 ; break ;
2019-11-30 16:19:08 +00:00
2020-10-05 16:11:43 +00:00
case 3 : * width = 600 ; break ;
2019-11-30 16:19:08 +00:00
2020-10-05 16:11:43 +00:00
case 4 : * width = 850 ; break ;
2019-11-30 16:19:08 +00:00
2020-10-05 16:11:43 +00:00
case 5 : * width = 1100 ; break ;
2019-11-30 16:19:08 +00:00
2020-10-05 16:11:43 +00:00
case 6 : * width = 1350 ; break ;
2019-11-30 16:19:08 +00:00
2020-10-05 16:11:43 +00:00
case 7 : * width = 1500 ; break ;
2019-11-30 16:19:08 +00:00
2020-10-05 16:11:43 +00:00
case 8 : * width = 1650 ; break ;
2019-11-30 16:19:08 +00:00
2020-10-05 16:11:43 +00:00
case 9 : * width = 1800 ; break ;
2019-11-30 16:19:08 +00:00
2020-10-05 16:11:43 +00:00
case 10 : * width = 1950 ; break ;
2019-11-30 16:19:08 +00:00
2020-10-05 16:11:43 +00:00
case 11 : * width = 2100 ; break ;
2019-11-30 16:19:08 +00:00
2020-10-05 16:11:43 +00:00
case 12 : * width = 2250 ; break ;
2019-11-30 16:19:08 +00:00
2020-10-05 16:11:43 +00:00
case 13 : * width = 2400 ; break ;
2019-11-30 16:19:08 +00:00
2020-10-05 16:11:43 +00:00
case 14 : * width = 2450 ; break ;
2019-11-30 16:19:08 +00:00
2020-10-05 16:11:43 +00:00
case 15 : * width = 2500 ; break ;
2019-11-30 16:19:08 +00:00
2020-10-05 16:11:43 +00:00
case 16 : * width = 2600 ; break ;
2019-11-30 16:19:08 +00:00
2020-10-05 16:11:43 +00:00
case 17 : * width = 2700 ; break ;
2019-11-30 16:19:08 +00:00
2020-10-05 16:11:43 +00:00
case 18 : * width = 2800 ; break ;
2019-11-30 16:19:08 +00:00
2020-10-05 16:11:43 +00:00
case 19 : * width = 2900 ; break ;
2019-11-30 16:19:08 +00:00
2020-10-05 16:11:43 +00:00
case 20 : * width = 3000 ; break ;
2019-11-30 16:19:08 +00:00
2020-11-06 08:35:21 +00:00
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2019-11-30 16:19:08 +00:00
}
2020-11-30 20:53:55 +00:00
2019-11-30 16:19:08 +00:00
break ;
case RIG_MODE_AM :
2020-11-06 08:35:21 +00:00
* width = narrow ? 6000 : 9000 ;
break ;
2019-11-30 16:19:08 +00:00
case RIG_MODE_PKTFM :
case RIG_MODE_FM :
2020-11-06 08:35:21 +00:00
* width = narrow ? 9000 : 16000 ;
break ;
case RIG_MODE_FMN :
* width = 9000 ;
break ;
2019-11-30 16:19:08 +00:00
default :
2020-12-15 21:25:28 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: unknown mode=%s \n " , __func__ , rig_strrmode ( mode ) ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2015-04-04 16:55:20 +00:00
} /* end switch(mode) */
2020-11-06 08:35:21 +00:00
} /* end if is_ft950 */
else if ( is_ft891 )
2020-05-09 20:52:49 +00:00
{
2020-10-05 17:53:56 +00:00
if ( ( narrow = get_narrow ( rig , vfo ) ) < 0 )
2020-10-05 16:34:38 +00:00
{
2020-12-15 21:25:28 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: error narrow < 0, narrow=%d \n " , __func__ , narrow ) ;
2020-10-05 16:34:38 +00:00
return - RIG_EPROTO ;
}
2020-05-09 20:52:49 +00:00
switch ( mode )
{
case RIG_MODE_PKTUSB :
case RIG_MODE_PKTLSB :
case RIG_MODE_RTTY :
case RIG_MODE_RTTYR :
case RIG_MODE_CW :
case RIG_MODE_CWR :
switch ( w )
{
2020-10-05 17:53:56 +00:00
case 0 :
2020-11-06 08:35:21 +00:00
if ( mode = = RIG_MODE_CW | | mode = = RIG_MODE_CWR )
{
* width = narrow ? 500 : 2400 ;
}
else
{
* width = narrow ? 300 : 500 ;
}
2020-11-30 20:53:55 +00:00
2020-10-05 17:53:56 +00:00
break ;
case 1 : * width = 50 ; break ;
case 2 : * width = 100 ; break ;
case 3 : * width = 150 ; break ;
case 4 : * width = 200 ; break ;
case 5 : * width = 250 ; break ;
case 6 : * width = 300 ; break ;
case 7 : * width = 350 ; break ;
case 8 : * width = 400 ; break ;
case 9 : * width = 450 ; break ;
case 10 : * width = 500 ; break ;
case 11 : * width = 800 ; break ;
case 12 : * width = 1200 ; break ;
case 13 : * width = 1400 ; break ;
case 14 : * width = 1700 ; break ;
case 15 : * width = 2000 ; break ;
case 16 : * width = 2400 ; break ;
case 17 : * width = 3000 ; break ;
2020-05-09 20:52:49 +00:00
2020-12-17 21:07:04 +00:00
default :
2020-12-15 21:25:28 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: unknown w=%d \n " , __func__ , w ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-05-09 20:52:49 +00:00
}
break ;
case RIG_MODE_LSB :
case RIG_MODE_USB :
switch ( w )
{
2020-10-05 17:53:56 +00:00
case 0 : * width = narrow ? 1500 : 2400 ; break ;
2020-05-09 20:52:49 +00:00
2020-10-05 17:53:56 +00:00
case 1 : * width = 200 ; break ;
2020-05-09 20:52:49 +00:00
2020-10-05 17:53:56 +00:00
case 2 : * width = 400 ; break ;
2020-05-09 20:52:49 +00:00
2020-10-05 17:53:56 +00:00
case 3 : * width = 600 ; break ;
2020-05-09 20:52:49 +00:00
2020-10-05 17:53:56 +00:00
case 4 : * width = 850 ; break ;
2020-05-09 20:52:49 +00:00
2020-10-05 17:53:56 +00:00
case 5 : * width = 1100 ; break ;
2020-05-09 20:52:49 +00:00
2020-10-05 17:53:56 +00:00
case 6 : * width = 1350 ; break ;
2020-05-09 20:52:49 +00:00
2020-10-05 17:53:56 +00:00
case 7 : * width = 1500 ; break ;
2020-05-09 20:52:49 +00:00
2020-10-05 17:53:56 +00:00
case 8 : * width = 1650 ; break ;
2020-05-09 20:52:49 +00:00
2020-10-05 17:53:56 +00:00
case 9 : * width = 1800 ; break ;
2020-05-09 20:52:49 +00:00
2020-10-05 17:53:56 +00:00
case 10 : * width = 1950 ; break ;
2020-05-09 20:52:49 +00:00
case 11 : * width = 2100 ; break ;
2020-10-05 17:53:56 +00:00
case 12 : * width = 2200 ; break ;
2020-05-09 20:52:49 +00:00
2020-10-05 17:53:56 +00:00
case 13 : * width = 2300 ; break ;
2020-05-09 20:52:49 +00:00
2020-10-05 17:53:56 +00:00
case 14 : * width = 2400 ; break ;
2020-05-09 20:52:49 +00:00
2020-10-05 17:53:56 +00:00
case 15 : * width = 2500 ; break ;
2020-05-09 20:52:49 +00:00
2020-10-05 17:53:56 +00:00
case 16 : * width = 2600 ; break ;
2020-05-09 20:52:49 +00:00
2020-10-05 17:53:56 +00:00
case 17 : * width = 2700 ; break ;
2020-05-09 20:52:49 +00:00
2020-10-05 17:53:56 +00:00
case 18 : * width = 2800 ; break ;
2020-05-09 20:52:49 +00:00
2020-10-05 17:53:56 +00:00
case 19 : * width = 2900 ; break ;
2020-05-09 20:52:49 +00:00
2020-10-05 17:53:56 +00:00
case 20 : * width = 3000 ; break ;
case 21 : * width = 3200 ; break ;
2020-05-09 20:52:49 +00:00
2020-12-17 21:07:04 +00:00
default :
2020-12-15 21:25:28 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: unknown mode=%s \n " , __func__ , rig_strrmode ( mode ) ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-05-09 20:52:49 +00:00
}
break ;
case RIG_MODE_AM :
2020-11-04 22:07:53 +00:00
case RIG_MODE_FMN :
2020-11-06 08:35:21 +00:00
* width = 9000 ;
break ;
case RIG_MODE_AMN :
* width = 6000 ;
break ;
2020-05-09 20:52:49 +00:00
2020-10-05 17:53:56 +00:00
case RIG_MODE_FM :
2020-05-09 20:52:49 +00:00
case RIG_MODE_PKTFM :
2020-10-05 17:53:56 +00:00
* width = 16000 ;
2020-05-09 20:52:49 +00:00
break ;
default :
2020-12-15 21:25:28 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: unknown mode=%s \n " , __func__ , rig_strrmode ( mode ) ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-05-09 20:52:49 +00:00
} /* end switch(mode) */
2020-11-06 08:35:21 +00:00
} /* end if is_ft891 */
else if ( is_ft991 )
2020-10-04 13:38:46 +00:00
{
2020-11-06 08:35:21 +00:00
if ( ( narrow = get_narrow ( rig , vfo ) ) < 0 )
2020-10-04 13:38:46 +00:00
{
2020-11-06 08:35:21 +00:00
return - RIG_EPROTO ;
2020-10-04 13:38:46 +00:00
}
switch ( mode )
{
case RIG_MODE_PKTUSB :
case RIG_MODE_PKTLSB :
case RIG_MODE_RTTY :
case RIG_MODE_RTTYR :
case RIG_MODE_CW :
case RIG_MODE_CWR :
switch ( w )
{
2020-11-06 08:35:21 +00:00
case 0 :
if ( mode = = RIG_MODE_CW | | mode = = RIG_MODE_CWR )
{
* width = narrow ? 500 : 2400 ;
}
else
{
* width = narrow ? 300 : 500 ;
}
2020-11-30 20:53:55 +00:00
2020-11-06 08:35:21 +00:00
break ;
2020-10-04 13:38:46 +00:00
case 1 : * width = 50 ; break ;
case 2 : * width = 100 ; break ;
case 3 : * width = 150 ; break ;
case 4 : * width = 200 ; break ;
case 5 : * width = 250 ; break ;
case 6 : * width = 300 ; break ;
case 7 : * width = 350 ; break ;
case 8 : * width = 400 ; break ;
2020-11-06 08:35:21 +00:00
case 9 : * width = 450 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 10 : * width = 500 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 11 : * width = 800 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 12 : * width = 1200 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 13 : * width = 1400 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 14 : * width = 1700 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 15 : * width = 2000 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 16 : * width = 2400 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 17 : * width = 3000 ; break ;
2020-10-04 13:38:46 +00:00
2021-01-17 13:25:28 +00:00
default : RETURNFUNC ( - RIG_EINVAL ) ;
2020-10-04 13:38:46 +00:00
}
break ;
case RIG_MODE_LSB :
case RIG_MODE_USB :
switch ( w )
{
2020-11-06 08:35:21 +00:00
case 0 : * width = narrow ? 1500 : 2400 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 1 : * width = 200 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 2 : * width = 400 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 3 : * width = 600 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 4 : * width = 850 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 5 : * width = 1100 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 6 : * width = 1350 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 7 : * width = 1500 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 8 : * width = 1650 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 9 : * width = 1800 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 10 : * width = 1950 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 11 : * width = 2100 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 12 : * width = 2200 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 13 : * width = 2300 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 14 : * width = 2400 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 15 : * width = 2500 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 16 : * width = 2600 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 17 : * width = 2700 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 18 : * width = 2800 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 19 : * width = 2900 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 20 : * width = 3000 ; break ;
2020-10-04 13:38:46 +00:00
2020-11-06 08:35:21 +00:00
case 21 : * width = 3200 ; break ;
2020-10-04 13:38:46 +00:00
2021-01-17 13:25:28 +00:00
default : RETURNFUNC ( - RIG_EINVAL ) ;
2020-11-06 08:35:21 +00:00
}
2020-10-06 13:59:28 +00:00
2020-11-06 08:35:21 +00:00
break ;
case RIG_MODE_AM :
case RIG_MODE_FMN :
* width = 9000 ;
break ;
case RIG_MODE_AMN :
* width = 6000 ;
break ;
case RIG_MODE_FM :
case RIG_MODE_C4FM :
case RIG_MODE_PKTFM :
* width = 16000 ;
break ;
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-11-06 08:35:21 +00:00
} /* end switch(mode) */
} /* end if is_ft991 */
else if ( is_ftdx1200 | | is_ftdx3000 )
{
if ( ( narrow = get_narrow ( rig , RIG_VFO_MAIN ) ) < 0 )
{
return - RIG_EPROTO ;
}
switch ( mode )
{
case RIG_MODE_PKTUSB :
case RIG_MODE_PKTLSB :
case RIG_MODE_RTTY :
case RIG_MODE_RTTYR :
case RIG_MODE_CW :
case RIG_MODE_CWR :
switch ( w )
{
case 0 :
* width = narrow ? 500 : 2400 ;
break ;
case 1 : * width = 50 ; break ;
case 2 : * width = 100 ; break ;
case 3 : * width = 150 ; break ;
case 4 : * width = 200 ; break ;
case 5 : * width = 250 ; break ;
case 6 : * width = 300 ; break ;
case 7 : * width = 350 ; break ;
case 8 : * width = 400 ; break ;
case 9 : * width = 450 ; break ;
case 10 : * width = 500 ; break ;
case 11 : * width = 800 ; break ;
case 12 : * width = 1200 ; break ;
case 13 : * width = 1400 ; break ;
case 14 : * width = 1700 ; break ;
case 15 : * width = 2000 ; break ;
case 16 : * width = 2400 ; break ;
2021-01-17 13:25:28 +00:00
default : RETURNFUNC ( - RIG_EINVAL ) ;
2020-11-06 08:35:21 +00:00
}
break ;
case RIG_MODE_LSB :
case RIG_MODE_USB :
switch ( w )
{
case 0 :
* width = narrow ? 1500 : 2400 ;
break ;
case 1 : * width = 200 ; break ;
case 2 : * width = 400 ; break ;
case 3 : * width = 600 ; break ;
case 4 : * width = 850 ; break ;
case 5 : * width = 1100 ; break ;
case 6 : * width = 1350 ; break ;
case 7 : * width = 1500 ; break ;
case 8 : * width = 1650 ; break ;
case 9 : * width = 1800 ; break ;
case 10 : * width = 1950 ; break ;
case 11 : * width = 2100 ; break ;
case 12 : * width = 2250 ; break ;
case 13 : * width = 2400 ; break ;
case 14 : * width = 2450 ; break ;
case 15 : * width = 2500 ; break ;
case 16 : * width = 2600 ; break ;
case 17 : * width = 2700 ; break ;
case 18 : * width = 2800 ; break ;
case 19 : * width = 2900 ; break ;
case 20 : * width = 3000 ; break ;
case 21 : * width = 3200 ; break ;
case 22 : * width = 3400 ; break ;
case 23 : * width = 3600 ; break ;
case 24 : * width = 3800 ; break ;
case 25 : * width = 4000 ; break ;
2021-01-17 13:25:28 +00:00
default : RETURNFUNC ( - RIG_EINVAL ) ;
2020-11-06 08:35:21 +00:00
}
break ;
case RIG_MODE_AM :
* width = narrow ? 6000 : 9000 ;
break ;
case RIG_MODE_PKTFM :
case RIG_MODE_FM :
* width = narrow ? 9000 : 16000 ;
break ;
case RIG_MODE_FMN :
* width = 9000 ;
break ;
2020-11-07 22:15:48 +00:00
case RIG_MODE_AMN :
* width = 6000 ;
break ;
2020-11-06 08:35:21 +00:00
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-11-06 08:35:21 +00:00
} /* end switch(mode) */
} /* end if is_ftdx1200 or is_ftdx3000 */
else if ( is_ftdx5000 )
{
if ( ( narrow = get_narrow ( rig , RIG_VFO_MAIN ) ) < 0 )
{
return - RIG_EPROTO ;
}
switch ( mode )
{
case RIG_MODE_PKTUSB :
case RIG_MODE_PKTLSB :
case RIG_MODE_RTTY :
case RIG_MODE_RTTYR :
case RIG_MODE_CW :
case RIG_MODE_CWR :
switch ( w )
{
case 0 :
* width = narrow ? 500 : 2400 ;
break ;
case 1 : * width = 50 ; break ;
case 2 : * width = 100 ; break ;
case 3 : * width = 150 ; break ;
case 4 : * width = 200 ; break ;
case 5 : * width = 250 ; break ;
case 6 : * width = 300 ; break ;
case 7 : * width = 350 ; break ;
case 8 : * width = 400 ; break ;
case 9 : * width = 450 ; break ;
case 10 : * width = 500 ; break ;
case 11 : * width = 800 ; break ;
case 12 : * width = 1200 ; break ;
case 13 : * width = 1400 ; break ;
case 14 : * width = 1700 ; break ;
case 15 : * width = 2000 ; break ;
case 16 : * width = 2400 ; break ;
2021-01-17 13:25:28 +00:00
default : RETURNFUNC ( - RIG_EINVAL ) ;
2020-11-06 08:35:21 +00:00
}
break ;
case RIG_MODE_LSB :
case RIG_MODE_USB :
switch ( w )
{
case 0 :
* width = narrow ? 1500 : 2400 ;
break ;
case 1 : * width = 200 ; break ;
case 2 : * width = 400 ; break ;
case 3 : * width = 600 ; break ;
case 4 : * width = 850 ; break ;
case 5 : * width = 1100 ; break ;
case 6 : * width = 1350 ; break ;
case 7 : * width = 1500 ; break ;
case 8 : * width = 1650 ; break ;
case 9 : * width = 1800 ; break ;
case 10 : * width = 1950 ; break ;
case 11 : * width = 2100 ; break ;
case 12 : * width = 2250 ; break ;
case 13 : * width = 2400 ; break ;
// 14 is not defined for FTDX 5000, but leaving here for completeness
case 14 : * width = 2400 ; break ;
case 15 : * width = 2500 ; break ;
case 16 : * width = 2600 ; break ;
case 17 : * width = 2700 ; break ;
case 18 : * width = 2800 ; break ;
case 19 : * width = 2900 ; break ;
case 20 : * width = 3000 ; break ;
case 21 : * width = 3200 ; break ;
case 22 : * width = 3400 ; break ;
case 23 : * width = 3600 ; break ;
case 24 : * width = 3800 ; break ;
case 25 : * width = 4000 ; break ;
2021-01-17 13:25:28 +00:00
default : RETURNFUNC ( - RIG_EINVAL ) ;
2020-11-06 08:35:21 +00:00
}
break ;
case RIG_MODE_AM :
* width = narrow ? 6000 : 9000 ;
break ;
case RIG_MODE_PKTFM :
case RIG_MODE_FM :
* width = narrow ? 9000 : 16000 ;
break ;
case RIG_MODE_FMN :
* width = 9000 ;
break ;
2020-11-07 22:15:48 +00:00
case RIG_MODE_AMN :
* width = 6000 ;
break ;
2020-11-06 08:35:21 +00:00
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-11-06 08:35:21 +00:00
} /* end switch(mode) */
} /* end if is_ftdx5000 */
2020-12-28 21:17:49 +00:00
else if ( is_ftdx101 | | is_ftdx10 )
2020-11-06 08:35:21 +00:00
{
rig_debug ( RIG_DEBUG_TRACE , " %s: is_ftdx101 w=%d, mode=%s \n " , __func__ , w ,
rig_strrmode ( mode ) ) ;
if ( w = = 0 ) // then we need to know the roofing filter
{
struct newcat_roofing_filter * roofing_filter ;
int err = get_roofing_filter ( rig , vfo , & roofing_filter ) ;
if ( err = = RIG_OK )
{
* width = roofing_filter - > width ;
}
}
switch ( mode )
{
case RIG_MODE_PKTUSB :
case RIG_MODE_PKTLSB :
case RIG_MODE_RTTY :
case RIG_MODE_RTTYR :
case RIG_MODE_CW :
case RIG_MODE_CWR :
switch ( w )
{
case 0 : break ; /* use roofing filter width */
case 1 : * width = 50 ; break ;
case 2 : * width = 100 ; break ;
case 3 : * width = 150 ; break ;
case 4 : * width = 200 ; break ;
case 5 : * width = 250 ; break ;
case 6 : * width = 300 ; break ;
case 7 : * width = 350 ; break ;
case 8 : * width = 400 ; break ;
case 9 : * width = 450 ; break ;
case 10 : * width = 500 ; break ;
case 11 : * width = 600 ; break ;
case 12 : * width = 800 ; break ;
case 13 : * width = 1200 ; break ;
case 14 : * width = 1400 ; break ;
case 15 : * width = 1700 ; break ;
case 16 : * width = 2000 ; break ;
case 17 : * width = 2400 ; break ;
case 18 : * width = 3000 ; break ;
2021-01-17 13:25:28 +00:00
default : RETURNFUNC ( - RIG_EINVAL ) ;
2020-11-06 08:35:21 +00:00
}
break ;
case RIG_MODE_LSB :
case RIG_MODE_USB :
switch ( w )
{
case 0 : break ; /* use roofing filter width */
case 1 : * width = 300 ; break ;
case 2 : * width = 400 ; break ;
case 3 : * width = 600 ; break ;
case 4 : * width = 850 ; break ;
case 5 : * width = 1100 ; break ;
case 6 : * width = 1200 ; break ;
case 7 : * width = 1500 ; break ;
case 8 : * width = 1650 ; break ;
case 9 : * width = 1800 ; break ;
case 10 : * width = 1950 ; break ;
case 11 : * width = 2100 ; break ;
case 12 : * width = 2200 ; break ;
case 13 : * width = 2300 ; break ;
case 14 : * width = 2400 ; break ;
case 15 : * width = 2500 ; break ;
case 16 : * width = 2600 ; break ;
case 17 : * width = 2700 ; break ;
case 18 : * width = 2800 ; break ;
case 19 : * width = 2900 ; break ;
case 20 : * width = 3000 ; break ;
case 21 : * width = 3200 ; break ;
case 22 : * width = 3500 ; break ;
case 23 : * width = 4000 ; break ;
2020-10-06 13:59:28 +00:00
2020-10-07 04:14:27 +00:00
default :
rig_debug ( RIG_DEBUG_ERR , " %s: unknown width=%d \n " , __func__ , w ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-10-04 13:38:46 +00:00
}
break ;
case RIG_MODE_AM :
2020-10-05 17:53:56 +00:00
case RIG_MODE_FMN :
case RIG_MODE_PKTFMN :
2020-11-06 08:35:21 +00:00
* width = 9000 ;
break ;
2020-10-05 22:00:19 +00:00
2020-10-05 17:53:56 +00:00
case RIG_MODE_AMN :
2020-11-06 08:35:21 +00:00
* width = 6000 ;
break ;
2020-10-05 22:00:19 +00:00
2020-10-04 13:38:46 +00:00
case RIG_MODE_FM :
2020-10-05 17:53:56 +00:00
case RIG_MODE_PKTFM :
2020-11-06 08:35:21 +00:00
* width = 16000 ;
break ;
2020-10-04 13:38:46 +00:00
default :
2020-10-07 04:14:27 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: bad mode \n " , __func__ ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-10-04 13:38:46 +00:00
} /* end switch(mode) */
2020-10-07 04:14:27 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: end if FTDX101D \n " , __func__ ) ;
2020-11-06 08:35:21 +00:00
} /* end if is_ftdx101 */
2020-12-05 21:11:12 +00:00
else if ( is_ft2000 )
{
2020-12-05 22:11:44 +00:00
if ( ( narrow = get_narrow ( rig , RIG_VFO_MAIN ) ) < 0 )
{
return - RIG_EPROTO ;
}
2020-12-05 21:11:12 +00:00
switch ( mode )
{
case RIG_MODE_CW :
case RIG_MODE_CWR :
2020-12-05 22:00:15 +00:00
if ( w < = 4 )
{
* width = 200 ;
}
else if ( w < = 6 )
{
* width = 500 ;
}
else if ( w < = 16 )
{
* width = 2400 ;
}
else
{
* width = 3000 ;
}
2020-12-17 21:07:04 +00:00
2020-12-05 22:00:15 +00:00
break ;
case RIG_MODE_PKTUSB :
case RIG_MODE_PKTLSB :
2020-12-05 22:11:44 +00:00
if ( w < = 8 )
2020-12-05 21:11:12 +00:00
{
2020-12-05 21:43:07 +00:00
* width = 200 ;
}
else if ( w < = 16 )
{
2020-12-05 22:11:44 +00:00
* width = 500 ;
2020-12-05 21:43:07 +00:00
}
else
{
* width = 2400 ;
}
2020-12-17 21:07:04 +00:00
2020-12-05 21:43:07 +00:00
break ;
case RIG_MODE_RTTY :
case RIG_MODE_RTTYR :
if ( w < = 8 )
{
* width = 300 ;
2020-12-05 21:11:12 +00:00
}
else if ( w < = 16 )
{
* width = 500 ;
}
else
{
* width = 2400 ;
}
2020-12-17 21:07:04 +00:00
2020-12-05 21:11:12 +00:00
break ;
case RIG_MODE_LSB :
case RIG_MODE_USB :
if ( w < = 8 )
{
* width = 1800 ;
}
else if ( w < = 16 )
{
* width = 2400 ;
}
else if ( w < = 25 )
{
* width = 3000 ;
}
else
{
* width = 4000 ;
}
2020-12-17 21:07:04 +00:00
2020-12-05 21:11:12 +00:00
break ;
case RIG_MODE_AM :
* width = narrow ? 6000 : 9000 ;
break ;
case RIG_MODE_PKTFM :
case RIG_MODE_FM :
* width = narrow ? 9000 : 16000 ;
break ;
case RIG_MODE_FMN :
* width = 9000 ;
break ;
case RIG_MODE_AMN :
* width = 6000 ;
break ;
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2020-12-05 21:11:12 +00:00
} /* end switch (mode) */
} /* end if is_ft2000 */
2020-11-06 08:35:21 +00:00
else
2019-11-30 16:19:08 +00:00
{
2020-12-05 21:11:12 +00:00
/* FT450, FT9000 */
2019-11-30 16:19:08 +00:00
switch ( mode )
{
case RIG_MODE_PKTUSB :
case RIG_MODE_PKTLSB :
case RIG_MODE_RTTY :
case RIG_MODE_RTTYR :
case RIG_MODE_CW :
case RIG_MODE_CWR :
case RIG_MODE_LSB :
case RIG_MODE_USB :
if ( w < 16 )
{
* width = rig_passband_narrow ( rig , mode ) ;
}
else if ( w > 16 )
{
* width = rig_passband_wide ( rig , mode ) ;
}
else
{
* width = rig_passband_normal ( rig , mode ) ;
}
2020-12-17 21:07:04 +00:00
2019-11-30 16:19:08 +00:00
break ;
case RIG_MODE_AM :
2020-12-05 21:11:12 +00:00
* width = narrow ? 6000 : 9000 ;
break ;
2019-11-30 16:19:08 +00:00
case RIG_MODE_PKTFM :
case RIG_MODE_FM :
2020-12-05 21:11:12 +00:00
* width = narrow ? 9000 : 16000 ;
break ;
case RIG_MODE_FMN :
* width = 9000 ;
break ;
case RIG_MODE_AMN :
* width = 6000 ;
break ;
2019-11-30 16:19:08 +00:00
default :
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_EINVAL ) ;
2008-12-25 13:32:50 +00:00
} /* end switch (mode) */
2020-11-06 08:35:21 +00:00
} /* end else */
2020-10-07 04:14:27 +00:00
2021-01-17 13:25:28 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: RETURNFUNC(RIG_OK) \n " , __func__ ) ;
RETURNFUNC ( RIG_OK ) ;
2008-12-23 22:36:51 +00:00
}
2008-12-28 00:25:31 +00:00
2019-11-30 16:19:08 +00:00
int newcat_set_faststep ( RIG * rig , ncboolean fast_step )
2008-12-28 00:25:31 +00:00
{
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2008-12-28 00:25:31 +00:00
char c ;
2011-07-09 03:27:06 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-12-28 00:25:31 +00:00
if ( ! newcat_valid_command ( rig , " FS " ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2008-12-28 00:25:31 +00:00
2011-07-09 03:27:06 +00:00
if ( fast_step = = TRUE )
2019-11-30 16:19:08 +00:00
{
2008-12-28 00:25:31 +00:00
c = ' 1 ' ;
2019-11-30 16:19:08 +00:00
}
2011-07-09 03:27:06 +00:00
else
2019-11-30 16:19:08 +00:00
{
2008-12-28 00:25:31 +00:00
c = ' 0 ' ;
2019-11-30 16:19:08 +00:00
}
2008-12-28 00:25:31 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " FS%c%c " , c , cat_term ) ;
rig_debug ( RIG_DEBUG_TRACE , " cmd_str = %s \n " , priv - > cmd_str ) ;
2015-09-29 20:06:12 +00:00
return newcat_set_cmd ( rig ) ;
2008-12-28 00:25:31 +00:00
}
2019-11-30 16:19:08 +00:00
int newcat_get_faststep ( RIG * rig , ncboolean * fast_step )
2008-12-28 00:25:31 +00:00
{
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2008-12-28 00:25:31 +00:00
int err ;
char c ;
2009-11-22 21:52:11 +00:00
char command [ ] = " FS " ;
2011-07-09 03:27:06 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2008-12-28 00:25:31 +00:00
if ( ! newcat_valid_command ( rig , command ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2008-12-28 00:25:31 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%c " , command , cat_term ) ;
2019-11-30 16:19:08 +00:00
2008-12-28 00:25:31 +00:00
/* Get Fast Step */
2019-11-30 16:19:08 +00:00
if ( RIG_OK ! = ( err = newcat_get_cmd ( rig ) ) )
{
2008-12-28 00:25:31 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2008-12-28 00:25:31 +00:00
c = priv - > ret_data [ 2 ] ;
2019-11-30 16:19:08 +00:00
2008-12-28 00:25:31 +00:00
if ( c = = ' 1 ' )
2019-11-30 16:19:08 +00:00
{
2008-12-28 00:25:31 +00:00
* fast_step = TRUE ;
2019-11-30 16:19:08 +00:00
}
2008-12-28 00:25:31 +00:00
else
2019-11-30 16:19:08 +00:00
{
2008-12-28 00:25:31 +00:00
* fast_step = FALSE ;
2019-11-30 16:19:08 +00:00
}
2008-12-28 00:25:31 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2008-12-28 00:25:31 +00:00
}
2008-12-28 13:53:13 +00:00
2008-12-30 18:52:32 +00:00
2019-11-30 16:19:08 +00:00
int newcat_get_rigid ( RIG * rig )
2008-12-30 18:52:32 +00:00
{
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2019-11-30 16:19:08 +00:00
const char * s = NULL ;
2009-01-07 00:50:53 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2009-01-07 00:50:53 +00:00
2008-12-30 18:52:32 +00:00
/* if first valid get */
2019-11-30 16:19:08 +00:00
if ( priv - > rig_id = = NC_RIGID_NONE )
{
2008-12-30 18:52:32 +00:00
s = newcat_get_info ( rig ) ;
2019-11-30 16:19:08 +00:00
if ( s ! = NULL )
{
s + = 2 ; /* ID0310, jump past ID */
2009-01-04 00:05:25 +00:00
priv - > rig_id = atoi ( s ) ;
2008-12-31 18:17:56 +00:00
}
2008-12-30 18:52:32 +00:00
}
2009-01-07 00:50:53 +00:00
2020-03-26 16:11:46 +00:00
rig_debug ( RIG_DEBUG_TRACE , " rig_id = %d, *s = %s \n " , priv - > rig_id ,
s = = NULL ? " NULL " : s ) ;
2009-01-07 00:50:53 +00:00
2009-01-04 00:05:25 +00:00
return priv - > rig_id ;
2008-12-30 18:52:32 +00:00
}
2009-01-07 00:50:53 +00:00
2009-01-10 14:52:49 +00:00
/*
* input : RIG * , vfo_t *
* output : VFO mode : RIG_VFO_VFO for VFO A and B
* RIG_VFO_MEM for VFO MEM
2014-10-18 19:31:47 +00:00
* return : RIG_OK or error
2009-01-10 14:52:49 +00:00
*/
2019-11-30 16:19:08 +00:00
int newcat_get_vfo_mode ( RIG * rig , vfo_t * vfo_mode )
2009-01-10 14:52:49 +00:00
{
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2009-01-10 14:52:49 +00:00
int err ;
2019-12-09 23:12:13 +00:00
int offset = 0 ;
2014-10-12 16:02:24 +00:00
char command [ ] = " IF " ;
2009-01-10 14:52:49 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2009-01-10 14:52:49 +00:00
2014-10-12 16:02:24 +00:00
if ( ! newcat_valid_command ( rig , command ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2009-01-10 14:52:49 +00:00
/* Get VFO A Information ****************** */
2014-10-12 16:02:24 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%c " , command , cat_term ) ;
2019-11-30 16:19:08 +00:00
if ( RIG_OK ! = ( err = newcat_get_cmd ( rig ) ) )
{
2009-01-10 14:52:49 +00:00
return err ;
2019-11-30 16:19:08 +00:00
}
2009-01-10 14:52:49 +00:00
/* vfo, mem, P7 ************************** */
2017-06-27 15:48:44 +00:00
// e.g. FT450 has 27 byte IF response, FT991 has 28 byte if response (one more byte for P2 VFO A Freq)
// so we now check to ensure we know the length of the response
2019-11-30 16:19:08 +00:00
switch ( strlen ( priv - > ret_data ) )
{
case 27 : offset = 21 ; priv - > width_frequency = 8 ; break ;
case 28 : offset = 22 ; priv - > width_frequency = 9 ; break ;
default :
rig_debug ( RIG_DEBUG_ERR ,
2019-11-30 19:05:21 +00:00
" %s: incorrect length of IF response, expected 27 or 28, got %d " , __func__ ,
( int ) strlen ( priv - > ret_data ) ) ;
2019-11-30 16:19:08 +00:00
return - RIG_EPROTO ;
}
2020-04-20 04:18:59 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: offset=%d, width_frequency=%d \n " , __func__ ,
2019-11-30 16:19:08 +00:00
offset , priv - > width_frequency ) ;
switch ( priv - > ret_data [ offset ] )
{
case ' 0 ' : * vfo_mode = RIG_VFO_VFO ; break ;
case ' 1 ' : /* Memory */
case ' 2 ' : /* Memory Tune */
case ' 3 ' : /* Quick Memory Bank */
case ' 4 ' : /* Quick Memory Bank Tune */
default :
* vfo_mode = RIG_VFO_MEM ;
2009-01-10 14:52:49 +00:00
}
2020-03-26 16:11:46 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: vfo mode = %s \n " , __func__ ,
2020-04-20 04:18:59 +00:00
rig_strvfo ( * vfo_mode ) ) ;
2009-01-10 14:52:49 +00:00
2014-10-12 16:02:24 +00:00
return err ;
2009-01-10 14:52:49 +00:00
}
/*
2020-07-24 06:26:40 +00:00
* Writes data and waits for response
2009-01-10 14:52:49 +00:00
* input : complete CAT command string including termination in cmd_str
* output : complete CAT command answer string in ret_data
2014-10-18 19:31:47 +00:00
* return : RIG_OK or error
2009-01-10 14:52:49 +00:00
*/
2019-11-30 16:19:08 +00:00
int newcat_vfomem_toggle ( RIG * rig )
2009-01-10 14:52:49 +00:00
{
2014-10-12 16:02:24 +00:00
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
char command [ ] = " VM " ;
2009-01-10 14:52:49 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2009-01-10 14:52:49 +00:00
2014-10-12 16:02:24 +00:00
if ( ! newcat_valid_command ( rig , command ) )
2019-11-30 16:19:08 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2019-11-30 16:19:08 +00:00
}
2009-01-10 14:52:49 +00:00
2009-11-22 21:52:11 +00:00
/* copy set command */
2014-10-12 16:02:24 +00:00
snprintf ( priv - > cmd_str , sizeof ( priv - > cmd_str ) , " %s%c " , command , cat_term ) ;
2009-01-10 14:52:49 +00:00
2014-10-12 16:02:24 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: cmd_str = %s \n " , __func__ , priv - > cmd_str ) ;
2009-01-11 10:04:48 +00:00
2015-09-29 20:06:12 +00:00
return newcat_set_cmd ( rig ) ;
2014-10-12 16:02:24 +00:00
}
/*
2014-12-06 12:19:40 +00:00
* Writes a null terminated command string from priv - > cmd_str to the
* CAT port and returns a response from the rig in priv - > ret_data
* which is also null terminated .
*
* Honors the ' retry ' capabilities field by resending the command up
* to ' retry ' times until a valid response is received . In the special
* cases of receiving a valid response to a different command or the
* " ?; " busy please wait response ; the command is not resent but up to
* ' retry ' retries to receive a valid response are made .
2014-10-12 16:02:24 +00:00
*/
2020-10-25 16:06:13 +00:00
int newcat_get_cmd ( RIG * rig )
2014-10-12 16:02:24 +00:00
{
2019-11-30 16:19:08 +00:00
struct rig_state * state = & rig - > state ;
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
int retry_count = 0 ;
int rc = - RIG_EPROTO ;
2020-09-26 22:45:45 +00:00
int is_read_cmd = 0 ;
2014-10-12 16:02:24 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2020-04-26 20:44:38 +00:00
// try to cache rapid repeats of the IF command
// this is for WSJT-X/JTDX sequence of v/f/m/t
2020-04-27 14:36:40 +00:00
// should allow rapid repeat of any call using the IF; cmd
// Any call that changes something in the IF response should invalidate the cache
2020-04-27 15:00:07 +00:00
if ( strcmp ( priv - > cmd_str , " IF; " ) = = 0 & & priv - > cache_start . tv_sec ! = 0 )
2020-04-26 20:44:38 +00:00
{
int cache_age_ms ;
cache_age_ms = elapsed_ms ( & priv - > cache_start , 0 ) ;
if ( cache_age_ms < 500 ) // 500ms cache time
{
rig_debug ( RIG_DEBUG_TRACE , " %s: cache hit, age=%dms \n " , __func__ , cache_age_ms ) ;
strcpy ( priv - > ret_data , priv - > last_if_response ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2020-04-26 20:44:38 +00:00
}
2020-05-03 22:24:42 +00:00
2020-04-27 14:36:40 +00:00
// we drop through and do the real IF command
2020-04-26 20:44:38 +00:00
}
2020-05-03 22:24:42 +00:00
2020-09-27 03:34:02 +00:00
// any command that is read only should not expire cache
2020-09-27 21:01:48 +00:00
is_read_cmd =
strcmp ( priv - > cmd_str , " AG0; " ) = = 0
| | strcmp ( priv - > cmd_str , " AG1; " ) = = 0
| | strcmp ( priv - > cmd_str , " AN0; " ) = = 0
| | strcmp ( priv - > cmd_str , " AN1; " ) = = 0
| | strcmp ( priv - > cmd_str , " BP00; " ) = = 0
| | strcmp ( priv - > cmd_str , " BP01; " ) = = 0
| | strcmp ( priv - > cmd_str , " BP10; " ) = = 0
| | strcmp ( priv - > cmd_str , " BP11; " ) = = 0
| | strcmp ( priv - > cmd_str , " CN00; " ) = = 0
| | strcmp ( priv - > cmd_str , " CN10; " ) = = 0
| | strcmp ( priv - > cmd_str , " CO00; " ) = = 0
| | strcmp ( priv - > cmd_str , " CO01; " ) = = 0
| | strcmp ( priv - > cmd_str , " CO02; " ) = = 0
| | strcmp ( priv - > cmd_str , " CO03; " ) = = 0
| | strcmp ( priv - > cmd_str , " CO10; " ) = = 0
| | strcmp ( priv - > cmd_str , " CO11; " ) = = 0
| | strcmp ( priv - > cmd_str , " CO12; " ) = = 0
| | strcmp ( priv - > cmd_str , " CO13; " ) = = 0
| | strcmp ( priv - > cmd_str , " IS1; " ) = = 0
| | strcmp ( priv - > cmd_str , " IS0; " ) = = 0
| | strcmp ( priv - > cmd_str , " IS1; " ) = = 0
| | strcmp ( priv - > cmd_str , " MD0; " ) = = 0
| | strcmp ( priv - > cmd_str , " MD1; " ) = = 0
| | strcmp ( priv - > cmd_str , " NA0; " ) = = 0
| | strcmp ( priv - > cmd_str , " NA1; " ) = = 0
| | strcmp ( priv - > cmd_str , " NB0; " ) = = 0
| | strcmp ( priv - > cmd_str , " NB1; " ) = = 0
| | strcmp ( priv - > cmd_str , " NL0; " ) = = 0
| | strcmp ( priv - > cmd_str , " NL1; " ) = = 0
| | strcmp ( priv - > cmd_str , " NR0; " ) = = 0
| | strcmp ( priv - > cmd_str , " NR1; " ) = = 0
2020-10-12 03:25:01 +00:00
| | strcmp ( priv - > cmd_str , " NR0; " ) = = 0
| | strcmp ( priv - > cmd_str , " NR1; " ) = = 0
| | strcmp ( priv - > cmd_str , " OS0; " ) = = 0
2020-09-27 21:01:48 +00:00
| | strcmp ( priv - > cmd_str , " OS0; " ) = = 0
| | strcmp ( priv - > cmd_str , " OS1; " ) = = 0
| | strcmp ( priv - > cmd_str , " PA0; " ) = = 0
| | strcmp ( priv - > cmd_str , " PA1; " ) = = 0
| | strcmp ( priv - > cmd_str , " RA0; " ) = = 0
| | strcmp ( priv - > cmd_str , " RA1; " ) = = 0
| | strcmp ( priv - > cmd_str , " RF0; " ) = = 0
| | strcmp ( priv - > cmd_str , " RF1; " ) = = 0
| | strcmp ( priv - > cmd_str , " RL0; " ) = = 0
| | strcmp ( priv - > cmd_str , " RL1; " ) = = 0
| | strcmp ( priv - > cmd_str , " RM0; " ) = = 0
| | strcmp ( priv - > cmd_str , " RM1; " ) = = 0
| | strcmp ( priv - > cmd_str , " SM0; " ) = = 0
| | strcmp ( priv - > cmd_str , " SM1; " ) = = 0
| | strcmp ( priv - > cmd_str , " SQ0; " ) = = 0
| | strcmp ( priv - > cmd_str , " SQ1; " ) = = 0
| | strcmp ( priv - > cmd_str , " VT0; " ) = = 0
| | strcmp ( priv - > cmd_str , " VT1; " ) = = 0 ;
2020-09-26 22:45:45 +00:00
2020-05-03 22:24:42 +00:00
if ( priv - > cmd_str [ 2 ] ! =
2020-09-26 22:45:45 +00:00
' ; ' & & ! is_read_cmd ) // then we must be setting something so we'll invalidate the cache
2020-04-27 14:36:40 +00:00
{
rig_debug ( RIG_DEBUG_TRACE , " %s: cache invalidated \n " , __func__ ) ;
priv - > cache_start . tv_sec = 0 ;
}
2020-04-26 20:44:38 +00:00
2019-11-30 16:19:08 +00:00
while ( rc ! = RIG_OK & & retry_count + + < = state - > rigport . retry )
2014-10-12 16:02:24 +00:00
{
2021-01-13 14:48:48 +00:00
rig_flush ( & state - > rigport ) ; /* discard any unsolicited data */
2021-01-15 22:48:32 +00:00
2019-11-30 16:19:08 +00:00
if ( rc ! = - RIG_BUSBUSY )
2014-10-12 16:02:24 +00:00
{
2019-11-30 16:19:08 +00:00
/* send the command */
rig_debug ( RIG_DEBUG_TRACE , " cmd_str = %s \n " , priv - > cmd_str ) ;
if ( RIG_OK ! = ( rc = write_block ( & state - > rigport , priv - > cmd_str ,
strlen ( priv - > cmd_str ) ) ) )
2014-12-06 12:19:40 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( rc ) ;
2014-12-06 12:19:40 +00:00
}
2014-10-12 16:02:24 +00:00
}
2019-11-30 16:19:08 +00:00
/* read the reply */
if ( ( rc = read_string ( & state - > rigport , priv - > ret_data , sizeof ( priv - > ret_data ) ,
& cat_term , sizeof ( cat_term ) ) ) < = 0 )
2014-10-12 16:02:24 +00:00
{
2019-11-30 16:19:08 +00:00
continue ; /* usually a timeout - retry */
2014-10-12 16:02:24 +00:00
}
2019-11-30 16:19:08 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: read count = %d, ret_data = %s \n " ,
__func__ , rc , priv - > ret_data ) ;
rc = RIG_OK ; /* received something */
/* Check that command termination is correct - alternative is
2021-01-12 20:13:11 +00:00
response is longer than the buffer */
2020-04-04 22:38:48 +00:00
if ( cat_term ! = priv - > ret_data [ strlen ( priv - > ret_data ) - 1 ] )
2014-10-12 16:02:24 +00:00
{
2019-11-30 16:19:08 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: Command is not correctly terminated '%s' \n " ,
__func__ , priv - > ret_data ) ;
2021-01-12 20:13:11 +00:00
rc = - RIG_EPROTO ; /* retry */
2019-11-30 16:19:08 +00:00
/* we could decrement retry_count
here but there is a danger of
infinite looping so we just use up
a retry for safety ' s sake */
2021-01-12 20:13:11 +00:00
continue ;
2014-10-12 16:02:24 +00:00
}
2019-11-30 16:19:08 +00:00
/* check for error codes */
if ( 2 = = strlen ( priv - > ret_data ) )
2014-10-12 16:02:24 +00:00
{
2019-11-30 16:19:08 +00:00
/* The following error responses are documented for Kenwood
but not for Yaesu , but at least one of them is known to
occur in that the FT - 450 certainly responds to " IF; "
occasionally with " ?; " . The others are harmless even of
they do not occur as they are unambiguous . */
switch ( priv - > ret_data [ 0 ] )
2014-10-12 16:02:24 +00:00
{
case ' N ' :
2019-11-30 16:19:08 +00:00
/* Command recognized by rig but invalid data entered. */
rig_debug ( RIG_DEBUG_VERBOSE , " %s: NegAck for '%s' \n " , __func__ , priv - > cmd_str ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2014-10-12 16:02:24 +00:00
case ' O ' :
2019-11-30 16:19:08 +00:00
/* Too many characters sent without a carriage return */
rig_debug ( RIG_DEBUG_VERBOSE , " %s: Overflow for '%s' \n " , __func__ ,
priv - > cmd_str ) ;
rc = - RIG_EPROTO ;
break ; /* retry */
2014-10-12 16:02:24 +00:00
case ' E ' :
2019-11-30 16:19:08 +00:00
/* Communication error */
rig_debug ( RIG_DEBUG_VERBOSE , " %s: Communication error for '%s' \n " , __func__ ,
priv - > cmd_str ) ;
rc = - RIG_EIO ;
break ; /* retry */
2014-10-12 16:02:24 +00:00
case ' ? ' :
2021-01-15 22:48:32 +00:00
2020-11-08 11:03:48 +00:00
/* The ? response is ambiguous and undocumented by Yaesu, but for get commands it seems to
* indicate that the rig rejected the command because the state of the rig is not valid for the command
* or that the command parameter is invalid . Retrying the command does not fix the issue ,
* as the error is caused by the an invalid combination of rig state .
*
* For example , the following cases have been observed :
* - MR and MC commands are rejected when referring to an _empty_ memory channel even
* if the channel number is in a valid range
* - BC ( ANF ) and RL ( NR ) commands fail in AM / FM modes , because they are
* supported only in SSB / CW / RTTY modes
* - MG ( MICGAIN ) command fails in RTTY mode , as it ' s a digital mode
*
* There are many more cases like these and they vary by rig model .
*
* So far , " rig busy " type situations with the ? response have not been observed for get commands .
2020-12-13 15:40:52 +00:00
* Followup 20201213 FTDX3000 FB ; command returning ? ; so do NOT abort
* see https : //github.com/Hamlib/Hamlib/issues/464
2020-11-08 11:03:48 +00:00
*/
2021-01-12 09:00:18 +00:00
if ( priv - > question_mark_response_means_rejected )
{
2021-01-15 22:48:32 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: Command rejected by the rig (get): '%s' \n " ,
__func__ ,
priv - > cmd_str ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ERJCTED ) ;
2021-01-12 09:00:18 +00:00
}
2021-01-13 14:48:48 +00:00
rig_debug ( RIG_DEBUG_WARN , " %s: Rig busy - retrying %d of %d: '%s' \n " , __func__ ,
2021-01-15 22:48:32 +00:00
retry_count , state - > rigport . retry , priv - > cmd_str ) ;
2021-01-12 09:00:18 +00:00
2021-01-12 20:13:11 +00:00
rc = - RIG_ERJCTED ; /* retry */
2021-01-12 09:00:18 +00:00
break ;
2014-10-12 16:02:24 +00:00
}
2019-11-30 16:19:08 +00:00
continue ;
2014-10-12 16:02:24 +00:00
}
2019-11-30 16:19:08 +00:00
/* verify that reply was to the command we sent */
if ( ( priv - > ret_data [ 0 ] ! = priv - > cmd_str [ 0 ]
| | priv - > ret_data [ 1 ] ! = priv - > cmd_str [ 1 ] ) )
2014-10-12 16:02:24 +00:00
{
2019-11-30 16:19:08 +00:00
/*
* TODO : When RIG_TRN is enabled , we can pass the string
* to the decoder for callback . That way we don ' t ignore
* any commands .
*/
rig_debug ( RIG_DEBUG_ERR , " %s: wrong reply %.2s for command %.2s \n " ,
__func__ , priv - > ret_data , priv - > cmd_str ) ;
2020-11-21 21:54:31 +00:00
// we were using BUSBUSY but microham devices need retries
// this should be OK under all other circumstances too
//rc = -RIG_BUSBUSY; /* retry read only */
2020-12-11 20:55:33 +00:00
rc = - RIG_EPROTO ;
2014-10-12 16:02:24 +00:00
}
}
2014-10-18 19:31:47 +00:00
2020-04-26 20:44:38 +00:00
// update the cache
2020-04-27 14:36:40 +00:00
if ( strncmp ( priv - > cmd_str , " IF; " , 3 ) = = 0 )
2020-04-27 03:30:09 +00:00
{
elapsed_ms ( & priv - > cache_start , 1 ) ;
strcpy ( priv - > last_if_response , priv - > ret_data ) ;
}
2020-04-26 20:44:38 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( rc ) ;
2009-01-10 14:52:49 +00:00
}
2015-09-29 20:06:12 +00:00
2021-01-14 22:32:55 +00:00
/*
* This tries to set and read to validate the set command actually worked
* returns RIG_OK if set , - RIG_EIMPL if not implemented yet , or - RIG_EPROTO if unsuccesful
*/
int newcat_set_cmd_validate ( RIG * rig )
{
struct rig_state * state = & rig - > state ;
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
2021-01-14 23:25:39 +00:00
char valcmd [ 16 ] ;
2021-01-15 22:48:32 +00:00
int retries = 8 ;
int retry = 0 ;
2021-01-14 22:32:55 +00:00
int sleepms = 50 ;
int rc = - RIG_EPROTO ;
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2021-01-14 22:32:55 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: priv->cmd_str=%s \n " , __func__ , priv - > cmd_str ) ;
2021-01-15 22:48:32 +00:00
if ( ( strncmp ( priv - > cmd_str , " FA " , 2 ) = = 0 ) & & ( strlen ( priv - > cmd_str ) > 3 ) )
2021-01-14 22:32:55 +00:00
{
2021-01-15 22:48:32 +00:00
strcpy ( valcmd , " FA; " ) ;
2021-01-14 22:32:55 +00:00
}
2021-01-15 22:48:32 +00:00
else if ( ( strncmp ( priv - > cmd_str , " FB " , 2 ) = = 0 ) & & ( strlen ( priv - > cmd_str ) > 3 ) )
2021-01-14 22:32:55 +00:00
{
2021-01-15 22:48:32 +00:00
strcpy ( valcmd , " FB; " ) ;
2021-01-14 22:32:55 +00:00
}
2021-01-15 22:48:32 +00:00
else if ( ( strncmp ( priv - > cmd_str , " MD " , 2 ) = = 0 ) & & ( strlen ( priv - > cmd_str ) > 3 ) )
2021-01-14 22:32:55 +00:00
{
2021-01-15 22:48:32 +00:00
strcpy ( valcmd , priv - > cmd_str ) ; // pull the needed part of the cmd
valcmd [ 3 ] = ' ; ' ;
valcmd [ 4 ] = 0 ;
2021-01-14 22:32:55 +00:00
}
2021-01-15 22:48:32 +00:00
else if ( ( strncmp ( priv - > cmd_str , " TX " , 2 ) = = 0 ) & & ( strlen ( priv - > cmd_str ) > 3 ) )
2021-01-14 22:32:55 +00:00
{
2021-01-15 22:48:32 +00:00
strcpy ( valcmd , " TX; " ) ;
2021-01-14 22:32:55 +00:00
}
2021-01-15 22:48:32 +00:00
else if ( ( strncmp ( priv - > cmd_str , " FT " , 2 ) = = 0 ) & & ( strlen ( priv - > cmd_str ) > 3 ) )
2021-01-14 22:32:55 +00:00
{
2021-01-15 22:48:32 +00:00
strcpy ( valcmd , " FT; " ) ;
2021-01-14 22:32:55 +00:00
}
2021-01-15 22:48:32 +00:00
else if ( ( strncmp ( priv - > cmd_str , " AI " , 2 ) = = 0 ) & & ( strlen ( priv - > cmd_str ) > 3 ) )
2021-01-14 22:32:55 +00:00
{
2021-01-15 22:48:32 +00:00
strcpy ( valcmd , " AI; " ) ;
2021-01-14 22:32:55 +00:00
}
2021-01-15 22:48:32 +00:00
else if ( ( strncmp ( priv - > cmd_str , " VS " , 2 ) = = 0 ) & & ( strlen ( priv - > cmd_str ) > 3 ) )
2021-01-15 22:36:07 +00:00
{
2021-01-15 22:48:32 +00:00
strcpy ( valcmd , " VS; " ) ;
2021-01-15 22:36:07 +00:00
}
2021-01-14 22:32:55 +00:00
else
{
rig_debug ( RIG_DEBUG_ERR , " %s: %s not implemented \n " , __func__ , priv - > cmd_str ) ;
return - RIG_ENIMPL ;
}
2021-01-15 22:48:32 +00:00
2021-01-14 22:32:55 +00:00
while ( rc ! = RIG_OK & & retry + + < retries )
{
2021-01-15 16:58:47 +00:00
int bytes ;
2021-01-15 18:01:06 +00:00
char cmd [ 256 ] ; // big enough
2021-01-14 22:38:31 +00:00
rig_flush ( & state - > rigport ) ; /* discard any unsolicited data */
2021-01-15 22:48:32 +00:00
snprintf ( cmd , sizeof ( cmd ) , " %s%s " , priv - > cmd_str , valcmd ) ;
2021-01-15 18:01:06 +00:00
rc = write_block ( & state - > rigport , cmd , strlen ( cmd ) ) ;
2021-01-15 22:48:32 +00:00
if ( rc ! = RIG_OK ) { return - RIG_EIO ; }
2021-01-15 16:58:47 +00:00
bytes = read_string ( & state - > rigport , priv - > ret_data , sizeof ( priv - > ret_data ) ,
2021-01-15 22:48:32 +00:00
& cat_term , sizeof ( cat_term ) ) ;
if ( strncmp ( priv - > cmd_str , " FT " , 2 ) = = 0
& & strncmp ( priv - > ret_data , " FT " , 2 ) = = 0 )
2021-01-15 17:17:23 +00:00
{
// FT command does not echo what's sent so we just check the basic command
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2021-01-15 17:17:23 +00:00
}
2021-01-15 22:48:32 +00:00
if ( strncmp ( priv - > cmd_str , " TX " , 2 ) = = 0
& & strncmp ( priv - > ret_data , " TX " , 2 ) = = 0 )
2021-01-15 17:44:50 +00:00
{
// TX command does not echo what's sent so we just check the basic command
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2021-01-15 17:44:50 +00:00
}
2021-01-15 22:48:32 +00:00
2021-01-15 16:58:47 +00:00
if ( bytes > 0 )
2021-01-14 22:32:55 +00:00
{
// if they match we are validated
2021-01-17 13:25:28 +00:00
if ( strcmp ( priv - > cmd_str , priv - > ret_data ) = = 0 ) { RETURNFUNC ( RIG_OK ) ; }
2021-01-15 22:48:32 +00:00
else { rc = - RIG_EPROTO ; }
2021-01-14 22:32:55 +00:00
}
2021-01-15 22:48:32 +00:00
2021-01-17 13:25:28 +00:00
rig_debug ( RIG_DEBUG_WARN , " %s: cmd validation failed, '%s'!='%s', try#%d \n " ,
2021-01-15 22:48:32 +00:00
__func__ , priv - > cmd_str , priv - > ret_data , retry ) ;
hl_usleep ( sleepms * 1000 ) ;
}
2021-01-14 22:32:55 +00:00
return - RIG_EPROTO ;
}
2015-09-29 20:06:12 +00:00
/*
* Writes a null terminated command string from priv - > cmd_str to the
* CAT port that is not expected to have a response .
*
* Honors the ' retry ' capabilities field by resending the command up
* to ' retry ' times until a valid response is received . In the special
* cases of receiving a valid response to a different command or the
* " ?; " busy please wait response ; the command is not resent but up to
* ' retry ' retries to receive a valid response are made .
*/
2020-10-25 16:06:13 +00:00
int newcat_set_cmd ( RIG * rig )
2015-09-29 20:06:12 +00:00
{
2019-11-30 16:19:08 +00:00
struct rig_state * state = & rig - > state ;
struct newcat_priv_data * priv = ( struct newcat_priv_data * ) rig - > state . priv ;
int retry_count = 0 ;
int rc = - RIG_EPROTO ;
2016-06-05 14:26:21 +00:00
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2019-11-30 16:19:08 +00:00
/* pick a basic quick query command for verification */
char const * const verify_cmd = RIG_MODEL_FT9000 = = rig - > caps - > rig_model ?
" AI; " : " ID; " ;
2015-09-29 20:06:12 +00:00
2019-11-30 16:19:08 +00:00
while ( rc ! = RIG_OK & & retry_count + + < = state - > rigport . retry )
2015-09-29 20:06:12 +00:00
{
2020-06-23 14:01:46 +00:00
rig_flush ( & state - > rigport ) ; /* discard any unsolicited data */
2019-11-30 16:19:08 +00:00
/* send the command */
rig_debug ( RIG_DEBUG_TRACE , " cmd_str = %s \n " , priv - > cmd_str ) ;
2021-01-14 22:55:12 +00:00
rc = newcat_set_cmd_validate ( rig ) ;
2021-01-15 22:48:32 +00:00
if ( rc = = RIG_OK )
{
2021-01-14 22:32:55 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: cmd_validate OK \n " , __func__ ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2021-01-14 22:32:55 +00:00
}
2021-01-14 22:55:12 +00:00
else if ( rc = = - RIG_EPROTO )
{
rig_debug ( RIG_DEBUG_TRACE , " %s: set_cmd_validate failed \n " , __func__ ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( rc ) ;
2021-01-14 22:55:12 +00:00
}
2021-01-15 22:48:32 +00:00
rig_debug ( RIG_DEBUG_TRACE ,
" %s: newcat_set_cmd_validate not implemented...continuing \n " , __func__ ) ;
2021-01-14 22:32:55 +00:00
2019-11-30 16:19:08 +00:00
if ( RIG_OK ! = ( rc = write_block ( & state - > rigport , priv - > cmd_str ,
strlen ( priv - > cmd_str ) ) ) )
2015-09-29 20:06:12 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( rc ) ;
2015-09-29 20:06:12 +00:00
}
2016-06-05 21:46:55 +00:00
2019-11-30 16:19:08 +00:00
/* skip validation if high throughput is needed */
if ( priv - > fast_set_commands = = TRUE )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_OK ) ;
2019-11-30 16:19:08 +00:00
}
2015-09-29 20:06:12 +00:00
2021-01-15 22:48:32 +00:00
if ( strncmp ( priv - > cmd_str , " BS " , 2 ) = = 0 )
{
// the BS command needs time to do it's thing
hl_usleep ( 200 * 1000 ) ;
2021-01-13 21:38:20 +00:00
priv - > cache_start . tv_sec = 0 ; // invalidate the cache
}
2019-11-30 16:19:08 +00:00
/* send the verification command */
rig_debug ( RIG_DEBUG_TRACE , " cmd_str = %s \n " , verify_cmd ) ;
if ( RIG_OK ! = ( rc = write_block ( & state - > rigport , verify_cmd ,
strlen ( verify_cmd ) ) ) )
2015-09-29 20:06:12 +00:00
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( rc ) ;
2015-09-29 20:06:12 +00:00
}
2019-11-30 16:19:08 +00:00
/* read the reply */
if ( ( rc = read_string ( & state - > rigport , priv - > ret_data , sizeof ( priv - > ret_data ) ,
& cat_term , sizeof ( cat_term ) ) ) < = 0 )
2015-09-29 20:06:12 +00:00
{
2019-11-30 16:19:08 +00:00
continue ; /* usually a timeout - retry */
2015-09-29 20:06:12 +00:00
}
2019-11-30 16:19:08 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: read count = %d, ret_data = %s \n " ,
__func__ , rc , priv - > ret_data ) ;
rc = RIG_OK ; /* received something */
/* check for error codes */
if ( 2 = = strlen ( priv - > ret_data ) )
2015-09-29 20:06:12 +00:00
{
2019-11-30 16:19:08 +00:00
/* The following error responses are documented for Kenwood
but not for Yaesu , but at least one of them is known to
occur in that the FT - 450 certainly responds to " IF; "
occasionally with " ?; " . The others are harmless even of
they do not occur as they are unambiguous . */
switch ( priv - > ret_data [ 0 ] )
2015-09-29 20:06:12 +00:00
{
case ' N ' :
2019-11-30 16:19:08 +00:00
/* Command recognized by rig but invalid data entered. */
rig_debug ( RIG_DEBUG_VERBOSE , " %s: NegAck for '%s' \n " , __func__ , priv - > cmd_str ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ENAVAIL ) ;
2015-09-29 20:06:12 +00:00
case ' O ' :
2019-11-30 16:19:08 +00:00
/* Too many characters sent without a carriage return */
rig_debug ( RIG_DEBUG_VERBOSE , " %s: Overflow for '%s' \n " , __func__ ,
priv - > cmd_str ) ;
rc = - RIG_EPROTO ;
break ; /* retry */
2015-09-29 20:06:12 +00:00
case ' E ' :
2019-11-30 16:19:08 +00:00
/* Communication error */
rig_debug ( RIG_DEBUG_VERBOSE , " %s: Communication error for '%s' \n " , __func__ ,
priv - > cmd_str ) ;
rc = - RIG_EIO ;
break ; /* retry */
2015-09-29 20:06:12 +00:00
case ' ? ' :
2020-11-30 20:53:55 +00:00
2020-11-08 11:03:48 +00:00
/* The ? response is ambiguous and undocumented by Yaesu. For set commands it seems to indicate:
* 1 ) either that the rig is busy and the command needs to be retried
* 2 ) or that the rig rejected the command because the state of the rig is not valid for the command
* or that the command parameter is invalid . Retrying the command does not fix the issue
* in this case , as the error is caused by the an invalid combination of rig state .
* The latter case is consistent with behaviour of get commands .
*
* For example , the following cases have been observed :
* - MR and MC commands are rejected when referring to an _empty_ memory channel even
* if the channel number is in a valid range
* - BC ( ANF ) and RL ( NR ) commands fail in AM / FM modes , because they are
* supported only in SSB / CW / RTTY modes
* - MG ( MICGAIN ) command fails in RTTY mode , as it ' s a digital mode
*
* There are many more cases like these and they vary by rig model .
*/
2020-10-25 16:06:13 +00:00
if ( priv - > question_mark_response_means_rejected )
2020-10-25 08:35:51 +00:00
{
2021-01-15 22:48:32 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: Command rejected by the rig (set): '%s' \n " ,
__func__ ,
2020-10-28 13:45:53 +00:00
priv - > cmd_str ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( - RIG_ERJCTED ) ;
2020-10-25 08:35:51 +00:00
}
2020-10-28 13:45:53 +00:00
/* Rig busy wait please */
2021-01-12 09:00:18 +00:00
rig_debug ( RIG_DEBUG_WARN , " %s: Rig busy - retrying: '%s' \n " , __func__ ,
2021-01-15 22:48:32 +00:00
priv - > cmd_str ) ;
2019-11-30 16:19:08 +00:00
2021-01-13 14:48:48 +00:00
/* read/flush the verify command reply which should still be there */
2019-11-30 16:19:08 +00:00
if ( ( rc = read_string ( & state - > rigport , priv - > ret_data , sizeof ( priv - > ret_data ) ,
& cat_term , sizeof ( cat_term ) ) ) > 0 )
2016-08-23 08:44:19 +00:00
{
2019-11-30 16:19:08 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: read count = %d, ret_data = %s \n " ,
__func__ , rc , priv - > ret_data ) ;
rc = - RIG_BUSBUSY ; /* retry */
2016-08-23 08:44:19 +00:00
}
2019-11-30 16:19:08 +00:00
break ;
2015-09-29 20:06:12 +00:00
}
}
2019-11-30 16:19:08 +00:00
if ( RIG_OK = = rc )
2015-09-29 20:06:12 +00:00
{
2019-11-30 16:19:08 +00:00
/* Check that response prefix and response termination is
correct - alternative is response is longer that the
buffer */
if ( strncmp ( verify_cmd , priv - > ret_data , strlen ( verify_cmd ) - 1 )
2020-04-05 03:49:27 +00:00
| | ( cat_term ! = priv - > ret_data [ strlen ( priv - > ret_data ) - 1 ] ) )
2015-09-29 20:06:12 +00:00
{
2019-11-30 16:19:08 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: Unexpected verify command response '%s' \n " ,
__func__ , priv - > ret_data ) ;
rc = - RIG_BUSBUSY ;
continue ; /* retry */
2015-09-29 20:06:12 +00:00
}
}
}
2021-01-17 13:25:28 +00:00
RETURNFUNC ( rc ) ;
2015-09-29 20:06:12 +00:00
}
2020-04-20 04:18:59 +00:00
2020-04-27 03:30:09 +00:00
struct
{
2020-04-20 04:18:59 +00:00
rmode_t mode ;
char modechar ;
ncboolean chk_width ;
} static const newcat_mode_conv [ ] =
{
{ RIG_MODE_LSB , ' 1 ' , FALSE } ,
{ RIG_MODE_USB , ' 2 ' , FALSE } ,
{ RIG_MODE_CW , ' 3 ' , FALSE } ,
2020-12-28 21:17:49 +00:00
{ RIG_MODE_FM , ' 4 ' , TRUE } ,
{ RIG_MODE_AM , ' 5 ' , TRUE } ,
2020-04-20 04:18:59 +00:00
{ RIG_MODE_RTTY , ' 6 ' , FALSE } ,
{ RIG_MODE_CWR , ' 7 ' , FALSE } ,
{ RIG_MODE_PKTLSB , ' 8 ' , FALSE } ,
{ RIG_MODE_RTTYR , ' 9 ' , FALSE } ,
2020-12-28 21:17:49 +00:00
{ RIG_MODE_PKTFM , ' A ' , TRUE } ,
{ RIG_MODE_FMN , ' B ' , TRUE } ,
2020-04-20 04:18:59 +00:00
{ RIG_MODE_PKTUSB , ' C ' , FALSE } ,
2020-12-28 21:17:49 +00:00
{ RIG_MODE_AMN , ' D ' , TRUE } ,
{ RIG_MODE_C4FM , ' E ' , TRUE } ,
{ RIG_MODE_PKTFMN , ' F ' , TRUE }
2020-04-20 04:18:59 +00:00
} ;
rmode_t newcat_rmode ( char mode )
{
int i ;
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2020-04-20 04:18:59 +00:00
for ( i = 0 ; i < sizeof ( newcat_mode_conv ) / sizeof ( newcat_mode_conv [ 0 ] ) ; i + + )
{
if ( newcat_mode_conv [ i ] . modechar = = mode )
{
rig_debug ( RIG_DEBUG_TRACE , " %s: %s for %c \n " , __func__ ,
rig_strrmode ( newcat_mode_conv [ i ] . mode ) , mode ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( newcat_mode_conv [ i ] . mode ) ;
2020-04-27 03:30:09 +00:00
}
}
2020-04-20 04:18:59 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( RIG_MODE_NONE ) ;
2020-04-20 04:18:59 +00:00
}
char newcat_modechar ( rmode_t rmode )
{
int i ;
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2020-04-20 04:18:59 +00:00
for ( i = 0 ; i < sizeof ( newcat_mode_conv ) / sizeof ( newcat_mode_conv [ 0 ] ) ; i + + )
{
if ( newcat_mode_conv [ i ] . mode = = rmode )
{
rig_debug ( RIG_DEBUG_TRACE , " %s: return %c for %s \n " , __func__ ,
2020-04-27 03:30:09 +00:00
newcat_mode_conv [ i ] . modechar , rig_strrmode ( rmode ) ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( newcat_mode_conv [ i ] . modechar ) ;
2020-04-27 03:30:09 +00:00
}
2020-04-20 04:18:59 +00:00
}
2021-01-17 13:25:28 +00:00
RETURNFUNC ( ' 0 ' ) ;
2020-04-20 04:18:59 +00:00
}
rmode_t newcat_rmode_width ( RIG * rig , vfo_t vfo , char mode , pbwidth_t * width )
{
ncboolean narrow ;
int i ;
2021-01-17 13:25:28 +00:00
ENTERFUNC ;
2020-04-20 04:18:59 +00:00
2020-04-27 03:30:09 +00:00
if ( width ! = NULL )
{
2020-04-20 04:18:59 +00:00
* width = RIG_PASSBAND_NORMAL ;
2020-04-27 03:30:09 +00:00
}
2020-04-20 04:18:59 +00:00
for ( i = 0 ; i < sizeof ( newcat_mode_conv ) / sizeof ( newcat_mode_conv [ 0 ] ) ; i + + )
{
if ( newcat_mode_conv [ i ] . modechar = = mode )
{
if ( newcat_mode_conv [ i ] . chk_width = = TRUE & & width ! = NULL )
{
2020-05-09 20:52:49 +00:00
if ( newcat_is_rig ( rig , RIG_MODEL_FT991 )
& & mode = = ' E ' ) // crude fix because 991 hangs on NA0; command while in C4FM
2020-04-27 03:30:09 +00:00
{
2020-05-09 20:52:49 +00:00
rig_debug ( RIG_DEBUG_TRACE , " 991A & C4FM Skip newcat_get_narrow in %s \n " ,
__func__ ) ;
2020-04-27 03:30:09 +00:00
}
else
{
2020-05-09 20:52:49 +00:00
if ( newcat_get_narrow ( rig , vfo , & narrow ) ! = RIG_OK )
{
2021-01-17 13:25:28 +00:00
RETURNFUNC ( newcat_mode_conv [ i ] . mode ) ;
2020-05-09 20:52:49 +00:00
}
if ( narrow = = TRUE )
{
* width = rig_passband_narrow ( rig , mode ) ;
}
else
{
* width = rig_passband_normal ( rig , mode ) ;
}
2020-04-27 03:30:09 +00:00
}
2020-04-20 04:18:59 +00:00
}
2020-04-27 03:30:09 +00:00
2021-01-17 13:25:28 +00:00
RETURNFUNC ( newcat_mode_conv [ i ] . mode ) ;
2020-04-27 03:30:09 +00:00
}
2020-04-20 04:18:59 +00:00
}
2020-04-27 03:30:09 +00:00
2020-04-20 04:18:59 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s fell out the bottom %c %s \n " , __func__ ,
mode , rig_strrmode ( mode ) ) ;
2021-01-17 13:25:28 +00:00
RETURNFUNC ( ' 0 ' ) ;
2020-04-20 04:18:59 +00:00
}