2000-10-01 12:25:49 +00:00
/*
2001-07-13 19:08:15 +00:00
* Hamlib Interface - toolbox
2011-02-08 22:21:11 +00:00
* Copyright ( c ) 2000 - 2011 by Stephane Fillod
2000-10-01 12:25:49 +00:00
*
2011-08-22 01:07:57 +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 .
2000-10-01 12:25:49 +00:00
*
2011-08-22 01:07:57 +00:00
* This library is distributed in the hope that it will be useful ,
2001-07-13 19:08:15 +00:00
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
2011-08-22 01:07:57 +00:00
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU
* Lesser General Public License for more details .
2001-07-13 19:08:15 +00:00
*
2011-08-22 01:07:57 +00:00
* You should have received a copy of the GNU Lesser General Public
2001-07-13 19:08:15 +00:00
* License along with this library ; if not , write to the Free Software
2011-08-22 01:07:57 +00:00
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
2000-10-01 12:25:49 +00:00
*
*/
2006-10-15 00:27:52 +00:00
/**
* \ addtogroup rig_internal
* @ {
*/
/**
* \ file misc . c
* \ brief Miscellaneous utility routines
*/
2022-02-04 13:41:36 +00:00
# include <hamlib/config.h>
2001-06-02 17:56:37 +00:00
2000-10-01 12:25:49 +00:00
# include <stdlib.h>
# include <stdarg.h>
# include <stdio.h> /* Standard input/output definitions */
# include <string.h> /* String function definitions */
2017-10-05 02:32:08 +00:00
2008-04-27 09:31:07 +00:00
# ifdef HAVE_SYS_TYPES_H
2017-10-05 02:32:08 +00:00
# include <sys / types.h>
2008-04-27 09:31:07 +00:00
# endif
2017-10-05 02:32:08 +00:00
2010-03-28 16:33:03 +00:00
# ifdef HAVE_SYS_TIME_H
2017-10-05 02:32:08 +00:00
# include <sys / time.h>
2010-03-28 16:33:03 +00:00
# endif
2017-10-05 02:32:08 +00:00
2020-11-07 13:03:54 +00:00
# include <math.h>
2000-10-01 12:25:49 +00:00
2000-10-08 21:43:00 +00:00
# include <hamlib/rig.h>
2020-11-24 19:51:10 +00:00
# include <hamlib/rotator.h>
2019-06-12 20:52:35 +00:00
# include <hamlib/amplifier.h>
2001-06-15 07:08:37 +00:00
2000-10-01 12:25:49 +00:00
# include "misc.h"
2020-06-23 04:54:11 +00:00
# include "serial.h"
# include "network.h"
2023-08-11 15:40:42 +00:00
# include "sprintflst.h"
2023-11-13 16:26:00 +00:00
# include "../rigs/icom/icom.h"
2021-01-26 21:05:43 +00:00
2022-01-03 12:18:49 +00:00
# if defined(_WIN32)
# include <time.h>
# ifndef localtime_r
# define localtime_r(T,Tm) (localtime_s(Tm,T) ? NULL : Tm)
# endif
# endif
2021-01-25 18:23:05 +00:00
# ifdef __APPLE__
2021-01-27 17:00:58 +00:00
# include <time.h>
2021-01-26 21:05:43 +00:00
2021-01-27 17:00:58 +00:00
# if !defined(CLOCK_REALTIME) && !defined(CLOCK_MONOTONIC)
//
// MacOS < 10.12 does not have clock_gettime
//
// Contribution from github user "ra1nb0w"
//
2021-01-26 21:05:43 +00:00
2021-01-27 17:00:58 +00:00
# define CLOCK_REALTIME 0
# define CLOCK_MONOTONIC 6
2021-01-26 21:05:43 +00:00
typedef int clockid_t ;
2021-01-25 18:23:05 +00:00
2021-01-27 17:00:58 +00:00
# include <sys/time.h>
# include <mach/mach_time.h>
2021-01-25 18:23:05 +00:00
2021-01-27 17:00:58 +00:00
static int clock_gettime ( clockid_t clock_id , struct timespec * tp )
2021-01-25 18:23:05 +00:00
{
2021-01-26 21:05:43 +00:00
if ( clock_id = = CLOCK_REALTIME )
{
struct timeval t ;
if ( gettimeofday ( & t , NULL ) ! = 0 )
{
return - 1 ;
}
tp - > tv_sec = t . tv_sec ;
tp - > tv_nsec = t . tv_usec * 1000 ;
}
else if ( clock_id = = CLOCK_MONOTONIC )
{
static mach_timebase_info_data_t info = { 0 , 0 } ;
if ( info . denom = = 0 )
{
mach_timebase_info ( & info ) ;
}
uint64_t t = mach_absolute_time ( ) * info . numer / info . denom ;
tp - > tv_sec = t / 1000000000 ;
tp - > tv_nsec = t % 1000000000 ;
}
else
{
errno = EINVAL ;
return - 1 ;
}
return 0 ;
2021-01-25 18:23:05 +00:00
}
2021-01-26 21:05:43 +00:00
2021-01-25 18:23:05 +00:00
# endif // !HAVE_CLOCK_GETTIME
# endif // __APPLE__
2000-10-01 12:25:49 +00:00
2006-10-15 00:27:52 +00:00
/**
* \ brief Convert from binary to 4 - bit BCD digits , little - endian
* \ param bcd_data
* \ param freq
* \ param bcd_len
* \ return bcd_data
*
2008-01-04 17:30:31 +00:00
* Convert a long long ( e . g . frequency in Hz ) to 4 - bit BCD digits ,
* packed two digits per octet , in little - endian order
* ( e . g . byte order 90 78 56 34 12 for 1234567890 Hz ) .
*
2011-08-22 01:07:57 +00:00
* bcd_len is the number of BCD digits , usually 10 or 8 in 1 - Hz units ,
2008-01-04 17:30:31 +00:00
* and 6 digits in 100 - Hz units for Tx offset data .
2000-10-01 12:25:49 +00:00
*
2008-01-04 17:30:31 +00:00
* Hope the compiler will do a good job optimizing it ( esp . w / the 64 bit freq )
*
* Returns a pointer to ( unsigned char * ) bcd_data .
*
2017-10-05 02:32:08 +00:00
* \ sa to_bcd_be ( )
2000-10-01 12:25:49 +00:00
*/
2019-11-30 16:19:08 +00:00
unsigned char * HAMLIB_API to_bcd ( unsigned char bcd_data [ ] ,
unsigned long long freq ,
unsigned bcd_len )
2000-10-01 12:25:49 +00:00
{
2017-08-05 14:09:12 +00:00
int i ;
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
/* '450'/4-> 5,0;0,4 */
/* '450'/3-> 5,0;x,4 */
2017-10-05 02:32:08 +00:00
for ( i = 0 ; i < bcd_len / 2 ; i + + )
{
2019-12-09 04:29:48 +00:00
unsigned char a = freq % 10 ;
2017-08-05 14:09:12 +00:00
freq / = 10 ;
a | = ( freq % 10 ) < < 4 ;
freq / = 10 ;
bcd_data [ i ] = a ;
}
2017-10-05 02:32:08 +00:00
if ( bcd_len & 1 )
{
2017-08-05 14:09:12 +00:00
bcd_data [ i ] & = 0xf0 ;
bcd_data [ i ] | = freq % 10 ; /* NB: high nibble is left uncleared */
}
return bcd_data ;
2000-10-01 12:25:49 +00:00
}
2017-08-05 14:09:12 +00:00
2006-10-15 00:27:52 +00:00
/**
2008-01-04 17:30:31 +00:00
* \ brief Convert BCD digits , little - endian , to a long long ( e . g . frequency in Hz )
2006-10-15 00:27:52 +00:00
* \ param bcd_data
* \ param bcd_len
* \ return binary result ( e . g . frequency )
*
2008-01-04 17:30:31 +00:00
* Convert BCD digits , little - endian , ( byte order 90 78 56 34 12
* for 1234567890 Hz ) to a long long ( e . g . frequency in Hz )
*
2000-10-01 12:25:49 +00:00
* bcd_len is the number of BCD digits .
*
* Hope the compiler will do a good job optimizing it ( esp . w / the 64 bit freq )
2008-01-04 17:30:31 +00:00
*
* Returns frequency in Hz an unsigned long long integer .
*
2017-10-05 02:32:08 +00:00
* \ sa from_bcd_be ( )
2000-10-01 12:25:49 +00:00
*/
2017-08-05 14:09:12 +00:00
unsigned long long HAMLIB_API from_bcd ( const unsigned char bcd_data [ ] ,
unsigned bcd_len )
2000-10-01 12:25:49 +00:00
{
2017-08-05 14:09:12 +00:00
int i ;
freq_t f = 0 ;
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
2000-10-01 12:25:49 +00:00
2017-10-05 02:32:08 +00:00
if ( bcd_len & 1 )
{
2017-08-05 14:09:12 +00:00
f = bcd_data [ bcd_len / 2 ] & 0x0f ;
}
2000-10-01 12:25:49 +00:00
2017-10-05 02:32:08 +00:00
for ( i = ( bcd_len / 2 ) - 1 ; i > = 0 ; i - - )
{
2017-08-05 14:09:12 +00:00
f * = 10 ;
f + = bcd_data [ i ] > > 4 ;
f * = 10 ;
f + = bcd_data [ i ] & 0x0f ;
}
2011-08-22 01:07:57 +00:00
2017-08-05 14:09:12 +00:00
return f ;
2000-10-01 12:25:49 +00:00
}
2017-08-05 14:09:12 +00:00
2006-10-15 00:27:52 +00:00
/**
2008-01-04 17:30:31 +00:00
* \ brief Convert from binary to 4 - bit BCD digits , big - endian
2006-10-15 00:27:52 +00:00
* \ param bcd_data
* \ param freq
* \ param bcd_len
* \ return bcd_data
*
2008-01-04 17:30:31 +00:00
* Same as to_bcd , but in big - endian order
* ( e . g . byte order 12 34 56 78 90 for 1234567890 Hz )
*
2017-10-05 02:32:08 +00:00
* \ sa to_bcd ( )
2000-10-16 21:53:22 +00:00
*/
2019-11-30 16:19:08 +00:00
unsigned char * HAMLIB_API to_bcd_be ( unsigned char bcd_data [ ] ,
unsigned long long freq ,
unsigned bcd_len )
2000-10-16 21:53:22 +00:00
{
2017-08-05 14:09:12 +00:00
int i ;
/* '450'/4 -> 0,4;5,0 */
/* '450'/3 -> 4,5;0,x */
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
2017-10-05 02:32:08 +00:00
if ( bcd_len & 1 )
{
2017-08-05 14:09:12 +00:00
bcd_data [ bcd_len / 2 ] & = 0x0f ;
bcd_data [ bcd_len / 2 ] | = ( freq % 10 ) < <
4 ; /* NB: low nibble is left uncleared */
freq / = 10 ;
}
2017-10-05 02:32:08 +00:00
for ( i = ( bcd_len / 2 ) - 1 ; i > = 0 ; i - - )
{
2019-12-09 04:29:48 +00:00
unsigned char a = freq % 10 ;
2017-08-05 14:09:12 +00:00
freq / = 10 ;
a | = ( freq % 10 ) < < 4 ;
freq / = 10 ;
bcd_data [ i ] = a ;
}
return bcd_data ;
2000-10-16 21:53:22 +00:00
}
2017-08-05 14:09:12 +00:00
2006-10-15 00:27:52 +00:00
/**
2008-01-04 17:30:31 +00:00
* \ brief Convert 4 - bit BCD digits to binary , big - endian
2006-10-15 00:27:52 +00:00
* \ param bcd_data
* \ param bcd_len
2008-01-04 17:30:31 +00:00
* \ return binary result
*
* Same as from_bcd , but in big - endian order
* ( e . g . byte order 12 34 56 78 90 for 1234567890 Hz )
2006-10-15 00:27:52 +00:00
*
2017-10-05 02:32:08 +00:00
* \ sa from_bcd ( )
2000-10-16 21:53:22 +00:00
*/
2017-08-05 14:09:12 +00:00
unsigned long long HAMLIB_API from_bcd_be ( const unsigned char bcd_data [ ] ,
2019-11-30 16:19:08 +00:00
unsigned bcd_len )
2000-10-16 21:53:22 +00:00
{
2017-08-05 14:09:12 +00:00
int i ;
freq_t f = 0 ;
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
2017-10-05 02:32:08 +00:00
for ( i = 0 ; i < bcd_len / 2 ; i + + )
{
2017-08-05 14:09:12 +00:00
f * = 10 ;
f + = bcd_data [ i ] > > 4 ;
f * = 10 ;
f + = bcd_data [ i ] & 0x0f ;
}
2017-10-05 02:32:08 +00:00
if ( bcd_len & 1 )
{
2017-08-05 14:09:12 +00:00
f * = 10 ;
f + = bcd_data [ bcd_len / 2 ] > > 4 ;
}
return f ;
2000-10-16 21:53:22 +00:00
}
2000-10-01 12:25:49 +00:00
2021-12-29 04:30:53 +00:00
size_t HAMLIB_API to_hex ( size_t source_length , const unsigned char * source_data ,
size_t dest_length , char * dest_data )
2021-11-28 18:52:29 +00:00
{
size_t i ;
size_t length = source_length ;
const unsigned char * source = source_data ;
char * dest = dest_data ;
if ( source_length = = 0 | | dest_length = = 0 )
{
return 0 ;
}
if ( source_length * 2 > dest_length )
{
length = dest_length / 2 - 1 ;
}
for ( i = 0 ; i < length ; i + + )
{
2022-02-05 21:27:43 +00:00
SNPRINTF ( dest , dest_length - 2 * i , " %02X " , source [ 0 ] ) ;
2021-11-28 18:52:29 +00:00
source + + ;
dest + = 2 ;
}
return length ;
}
2020-11-07 13:03:54 +00:00
/**
* \ brief Convert duration of one morse code dot ( element ) to milliseconds at the given speed .
* \ param wpm morse code speed in words per minute
* \ return double duration in milliseconds
*
* The morse code speed is calculated using the standard based on word PARIS .
*
* " If you send PARIS 5 times in a minute (5WPM) you have sent 250 elements (using correct spacing).
* 250 elements into 60 seconds per minute = 240 milliseconds per element . "
*
* Source : http : //kent-engineers.com/codespeed.htm
*/
double morse_code_dot_to_millis ( int wpm )
{
return 240.0 * ( 5.0 / ( double ) wpm ) ;
}
/**
* \ brief Convert duration of tenths of morse code dots to milliseconds at the given speed .
* \ param tenths_of_dots number of 1 / 10 ths of dots
* \ param wpm morse code speed in words per minute
* \ return int duration in milliseconds
*
* The morse code speed is calculated using the standard based on word PARIS .
*/
int dot10ths_to_millis ( int dot10ths , int wpm )
{
return ceil ( morse_code_dot_to_millis ( wpm ) * ( double ) dot10ths / 10.0 ) ;
}
/**
* \ brief Convert duration in milliseconds to tenths of morse code dots at the given speed .
* \ param millis duration in milliseconds
* \ param wpm morse code speed in words per minute
* \ return int number of 1 / 10 ths of dots
*
* The morse code speed is calculated using the standard based on word PARIS .
*/
int millis_to_dot10ths ( int millis , int wpm )
{
return ceil ( millis / morse_code_dot_to_millis ( wpm ) * 10.0 ) ;
}
2005-04-06 21:27:28 +00:00
2020-04-09 22:56:19 +00:00
//! @cond Doxygen_Suppress
2003-01-06 22:08:45 +00:00
# ifndef llabs
2001-05-04 22:41:22 +00:00
# define llabs(a) ((a)<0?-(a):(a))
2003-01-06 22:08:45 +00:00
# endif
2020-04-09 22:56:19 +00:00
//! @endcond
2000-10-01 12:25:49 +00:00
2017-08-05 14:09:12 +00:00
2006-10-15 00:27:52 +00:00
/**
* \ brief Pretty print a frequency
* \ param str for result ( may need up to 17 char )
* \ param freq input in Hz
*
2002-01-27 23:47:41 +00:00
* rig_freq_snprintf ?
2001-04-24 19:52:28 +00:00
* pretty print frequencies
* str must be long enough . max can be as long as 17 chars
*/
2022-01-18 21:03:11 +00:00
int HAMLIB_API sprintf_freq ( char * str , int str_len , freq_t freq )
2001-04-24 19:52:28 +00:00
{
2017-08-05 14:09:12 +00:00
double f ;
char * hz ;
2021-04-15 17:24:29 +00:00
int decplaces = 10 ;
2022-01-18 21:03:11 +00:00
int retval ;
2017-08-05 14:09:12 +00:00
2020-04-03 20:22:07 +00:00
// too verbose
//rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
2017-08-05 14:09:12 +00:00
2017-10-05 02:32:08 +00:00
if ( llabs ( freq ) > = GHz ( 1 ) )
{
2017-08-05 14:09:12 +00:00
hz = " GHz " ;
f = ( double ) freq / GHz ( 1 ) ;
2017-10-05 02:32:08 +00:00
}
else if ( llabs ( freq ) > = MHz ( 1 ) )
{
2017-08-05 14:09:12 +00:00
hz = " MHz " ;
f = ( double ) freq / MHz ( 1 ) ;
2021-04-15 17:24:29 +00:00
decplaces = 7 ;
2017-10-05 02:32:08 +00:00
}
else if ( llabs ( freq ) > = kHz ( 1 ) )
{
2017-08-05 14:09:12 +00:00
hz = " kHz " ;
f = ( double ) freq / kHz ( 1 ) ;
2021-04-15 17:24:29 +00:00
decplaces = 4 ;
2017-10-05 02:32:08 +00:00
}
else
{
2017-08-05 14:09:12 +00:00
hz = " Hz " ;
f = ( double ) freq ;
2021-04-15 17:24:29 +00:00
decplaces = 1 ;
2017-08-05 14:09:12 +00:00
}
2022-01-18 21:03:11 +00:00
SNPRINTF ( str , str_len , " %.*f %s " , decplaces , f , hz ) ;
retval = strlen ( str ) ;
return retval ;
2001-04-24 19:52:28 +00:00
}
2017-08-05 14:09:12 +00:00
2006-10-15 00:27:52 +00:00
/**
* \ brief Convert enum RIG_STATUS_ . . . to printable string
* \ param status RIG_STATUS_ ? ?
* \ return string
*/
2019-11-30 16:19:08 +00:00
const char * HAMLIB_API rig_strstatus ( enum rig_status_e status )
2002-01-27 23:47:41 +00:00
{
2017-10-05 02:32:08 +00:00
switch ( status )
{
2017-08-05 14:09:12 +00:00
case RIG_STATUS_ALPHA :
return " Alpha " ;
case RIG_STATUS_UNTESTED :
return " Untested " ;
2021-09-15 18:50:31 +00:00
case RIG_STATUS_BETA :
2017-08-05 14:09:12 +00:00
return " Beta " ;
case RIG_STATUS_STABLE :
return " Stable " ;
case RIG_STATUS_BUGGY :
return " Buggy " ;
}
return " " ;
2002-01-27 23:47:41 +00:00
}
2002-01-22 00:50:32 +00:00
2021-08-21 20:48:02 +00:00
static const struct
2017-10-05 02:32:08 +00:00
{
2017-08-05 14:09:12 +00:00
rmode_t mode ;
const char * str ;
2017-10-05 02:32:08 +00:00
} mode_str [ ] =
{
2017-08-05 14:09:12 +00:00
{ RIG_MODE_AM , " AM " } ,
2021-10-16 15:14:03 +00:00
{ RIG_MODE_PKTAM , " AM-D " } ,
2017-08-05 14:09:12 +00:00
{ RIG_MODE_CW , " CW " } ,
{ RIG_MODE_USB , " USB " } ,
{ RIG_MODE_LSB , " LSB " } ,
{ RIG_MODE_RTTY , " RTTY " } ,
{ RIG_MODE_FM , " FM " } ,
2021-10-16 15:14:03 +00:00
{ RIG_MODE_PKTFM , " FM-D " } ,
2017-08-05 14:09:12 +00:00
{ RIG_MODE_WFM , " WFM " } ,
{ RIG_MODE_CWR , " CWR " } ,
2021-10-16 15:14:03 +00:00
{ RIG_MODE_CWR , " CW-R " } ,
2017-08-05 14:09:12 +00:00
{ RIG_MODE_RTTYR , " RTTYR " } ,
2021-10-16 15:14:03 +00:00
{ RIG_MODE_RTTYR , " RTTY-R " } ,
2017-08-05 14:09:12 +00:00
{ RIG_MODE_AMS , " AMS " } ,
{ RIG_MODE_PKTLSB , " PKTLSB " } ,
{ RIG_MODE_PKTUSB , " PKTUSB " } ,
2021-10-16 14:27:04 +00:00
{ RIG_MODE_PKTLSB , " LSB-D " } ,
2021-10-16 14:45:24 +00:00
{ RIG_MODE_PKTUSB , " USB-D " } ,
2017-08-05 14:09:12 +00:00
{ RIG_MODE_PKTFM , " PKTFM " } ,
2020-10-23 06:32:37 +00:00
{ RIG_MODE_PKTFMN , " PKTFMN " } ,
2017-08-05 14:09:12 +00:00
{ RIG_MODE_ECSSUSB , " ECSSUSB " } ,
{ RIG_MODE_ECSSLSB , " ECSSLSB " } ,
{ RIG_MODE_FAX , " FAX " } ,
{ RIG_MODE_SAM , " SAM " } ,
{ RIG_MODE_SAL , " SAL " } ,
{ RIG_MODE_SAH , " SAH " } ,
{ RIG_MODE_DSB , " DSB " } ,
2018-12-23 22:37:27 +00:00
{ RIG_MODE_FMN , " FMN " } ,
{ RIG_MODE_PKTAM , " PKTAM " } ,
2018-12-21 07:07:41 +00:00
{ RIG_MODE_P25 , " P25 " } ,
{ RIG_MODE_DSTAR , " D-STAR " } ,
2018-12-23 22:37:27 +00:00
{ RIG_MODE_DPMR , " DPMR " } ,
2018-12-21 07:07:41 +00:00
{ RIG_MODE_NXDNVN , " NXDN-VN " } ,
{ RIG_MODE_NXDN_N , " NXDN-N " } ,
{ RIG_MODE_DCR , " DCR " } ,
2018-12-23 22:37:27 +00:00
{ RIG_MODE_AMN , " AMN " } ,
{ RIG_MODE_PSK , " PSK " } ,
{ RIG_MODE_PSKR , " PSKR " } ,
2020-01-15 14:15:29 +00:00
{ RIG_MODE_C4FM , " C4FM " } ,
2020-12-27 21:33:21 +00:00
{ RIG_MODE_SPEC , " SPEC " } ,
2021-08-28 00:41:38 +00:00
{ RIG_MODE_CWN , " CWN " } ,
2021-10-19 04:01:38 +00:00
{ RIG_MODE_IQ , " IQ " } ,
2022-08-13 13:52:42 +00:00
{ RIG_MODE_ISBUSB , " ISBUSB " } ,
{ RIG_MODE_ISBLSB , " ISBLSB " } ,
2023-01-29 21:50:27 +00:00
{ RIG_MODE_NONE , " None " } , // so we can reutnr None when NONE is requested
{ - 1 , " " } , // need to end list
2002-01-22 00:50:32 +00:00
} ;
2017-08-05 14:09:12 +00:00
2006-10-15 00:27:52 +00:00
/**
* \ brief Convert alpha string to enum RIG_MODE
* \ param s input alpha string
* \ return enum RIG_MODE_ ? ?
2007-11-26 20:54:12 +00:00
*
* \ sa rmode_t
2006-10-15 00:27:52 +00:00
*/
2004-10-02 10:32:09 +00:00
rmode_t HAMLIB_API rig_parse_mode ( const char * s )
2002-01-22 00:50:32 +00:00
{
2017-08-05 14:09:12 +00:00
int i ;
2002-01-22 00:50:32 +00:00
2017-08-05 14:09:12 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
2023-01-29 21:50:27 +00:00
for ( i = 0 ; ( s ! = NULL ) & & ( mode_str [ i ] . str [ 0 ] ! = ' \0 ' ) ; i + + )
2017-10-05 02:32:08 +00:00
{
if ( ! strcmp ( s , mode_str [ i ] . str ) )
{
2017-08-05 14:09:12 +00:00
return mode_str [ i ] . mode ;
}
2017-10-05 02:32:08 +00:00
}
2017-08-05 14:09:12 +00:00
2023-02-10 14:02:48 +00:00
rig_debug ( RIG_DEBUG_WARN , " %s: mode '%s' not found...returning RIG_MODE_NONE \n " ,
__func__ , s ) ;
2017-08-05 14:09:12 +00:00
return RIG_MODE_NONE ;
2002-01-22 00:50:32 +00:00
}
2017-08-05 14:09:12 +00:00
2006-10-15 00:27:52 +00:00
/**
* \ brief Convert enum RIG_MODE to alpha string
* \ param mode RIG_MODE_ . . .
* \ return alpha string
2007-11-26 20:54:12 +00:00
*
* \ sa rmode_t
2006-10-15 00:27:52 +00:00
*/
2019-11-30 16:19:08 +00:00
const char * HAMLIB_API rig_strrmode ( rmode_t mode )
2003-01-06 22:08:45 +00:00
{
2017-08-05 14:09:12 +00:00
int i ;
2003-01-06 22:08:45 +00:00
2019-12-12 15:13:30 +00:00
// only enable if needed for debugging -- too verbose otherwise
2019-11-19 17:32:39 +00:00
//rig_debug(RIG_DEBUG_TRACE, "%s called mode=0x%"PRXll"\n", __func__, mode);
2003-01-06 22:08:45 +00:00
2017-10-05 02:32:08 +00:00
if ( mode = = RIG_MODE_NONE )
{
2017-08-05 14:09:12 +00:00
return " " ;
}
for ( i = 0 ; mode_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
2017-10-05 02:32:08 +00:00
{
if ( mode = = mode_str [ i ] . mode )
{
2017-08-05 14:09:12 +00:00
return mode_str [ i ] . str ;
}
2017-10-05 02:32:08 +00:00
}
2003-01-06 22:08:45 +00:00
2017-08-05 14:09:12 +00:00
return " " ;
2003-01-06 22:08:45 +00:00
}
2019-12-12 15:13:30 +00:00
/**
* \ brief Convert RIG_MODE or ' d value to alpha string of all modes
* \ param modes RIG_MODE or ' d value
* \ param buf char * of result buffer
* \ param buflen length of buffer
* \ return rig status - - RIG_ETRUNC if buffer not big enough
*
* \ sa rmode_t
*/
2019-12-12 15:47:24 +00:00
int HAMLIB_API rig_strrmodes ( rmode_t modes , char * buf , int buflen )
2019-12-12 15:13:30 +00:00
{
int i ;
// only enable if needed for debugging -- too verbose otherwise
//rig_debug(RIG_DEBUG_TRACE, "%s called mode=0x%"PRXll"\n", __func__, mode);
if ( modes = = RIG_MODE_NONE )
{
2022-01-19 15:11:04 +00:00
SNPRINTF ( buf , buflen , " NONE " ) ;
2019-12-12 15:13:30 +00:00
return RIG_OK ;
}
for ( i = 0 ; mode_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
{
if ( modes & mode_str [ i ] . mode )
{
char modebuf [ 16 ] ;
2020-02-23 17:26:09 +00:00
2022-01-19 15:11:04 +00:00
if ( strlen ( buf ) = = 0 ) { SNPRINTF ( modebuf , sizeof ( modebuf ) , " %s " , mode_str [ i ] . str ) ; }
else { SNPRINTF ( modebuf , sizeof ( modebuf ) , " %s " , mode_str [ i ] . str ) ; }
2020-02-23 17:26:09 +00:00
strncat ( buf , modebuf , buflen - strlen ( buf ) - 1 ) ;
if ( strlen ( buf ) > buflen - 10 ) { return - RIG_ETRUNC ; }
2019-12-12 15:13:30 +00:00
}
}
return RIG_OK ;
}
2017-08-05 14:09:12 +00:00
2021-08-21 20:48:02 +00:00
static const struct
2017-10-05 02:32:08 +00:00
{
2017-08-05 14:09:12 +00:00
vfo_t vfo ;
const char * str ;
2017-10-05 02:32:08 +00:00
} vfo_str [ ] =
{
2017-08-05 14:09:12 +00:00
{ RIG_VFO_A , " VFOA " } ,
{ RIG_VFO_B , " VFOB " } ,
{ RIG_VFO_C , " VFOC " } ,
{ RIG_VFO_CURR , " currVFO " } ,
{ RIG_VFO_MEM , " MEM " } ,
{ RIG_VFO_VFO , " VFO " } ,
{ RIG_VFO_TX , " TX " } ,
{ RIG_VFO_RX , " RX " } ,
{ RIG_VFO_MAIN , " Main " } ,
2019-12-02 13:50:05 +00:00
{ RIG_VFO_MAIN_A , " MainA " } ,
{ RIG_VFO_MAIN_B , " MainB " } ,
2021-03-22 20:35:12 +00:00
{ RIG_VFO_MAIN_C , " MainC " } ,
2017-08-05 14:09:12 +00:00
{ RIG_VFO_SUB , " Sub " } ,
2019-12-02 13:50:05 +00:00
{ RIG_VFO_SUB_A , " SubA " } ,
{ RIG_VFO_SUB_B , " SubB " } ,
2021-03-15 16:15:41 +00:00
{ RIG_VFO_SUB_C , " SubC " } ,
2020-03-15 14:52:47 +00:00
{ RIG_VFO_NONE , " None " } ,
2021-09-25 16:45:42 +00:00
{ RIG_VFO_OTHER , " otherVFO " } ,
2022-09-02 12:59:07 +00:00
{ RIG_VFO_ALL , " AllVFOs " } ,
2023-08-14 21:15:03 +00:00
{ RIG_VFO_A , " 1 " } , // to make gpredict happy in set_toggle
2021-11-20 22:26:47 +00:00
{ 0xffffffff , " " } ,
2002-01-22 00:50:32 +00:00
} ;
2017-08-05 14:09:12 +00:00
2006-10-15 00:27:52 +00:00
/**
* \ brief Convert alpha string to enum RIG_VFO_ . . .
* \ param s input alpha string
* \ return RIG_VFO_ . . .
2007-11-26 20:54:12 +00:00
*
2019-12-02 13:50:05 +00:00
* \ sa RIG_VFO_A RIG_VFO_B RIG_VFO_C RIG_VFO_MAIN RIG_VFO_MAIN_A RIG_VFO_MAIN_B RIG_VFO_SUB RIG_VFO_SUB_A RIG_VFO_SUB_B RIG_VFO_VFO RIG_VFO_CURR RIG_VFO_MEM RIG_VFO_TX RIG_VFO_RX RIG_VFO_NONE
2006-10-15 00:27:52 +00:00
*/
2004-10-02 10:32:09 +00:00
vfo_t HAMLIB_API rig_parse_vfo ( const char * s )
2002-01-22 00:50:32 +00:00
{
2017-08-05 14:09:12 +00:00
int i ;
2002-01-22 00:50:32 +00:00
2017-08-05 14:09:12 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
for ( i = 0 ; vfo_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
2017-10-05 02:32:08 +00:00
{
if ( ! strcmp ( s , vfo_str [ i ] . str ) )
{
2021-11-28 18:41:10 +00:00
rig_debug ( RIG_DEBUG_CACHE , " %s: str='%s' vfo='%s' \n " , __func__ , vfo_str [ i ] . str ,
rig_strvfo ( vfo_str [ i ] . vfo ) ) ;
2017-08-05 14:09:12 +00:00
return vfo_str [ i ] . vfo ;
}
2017-10-05 02:32:08 +00:00
}
2017-08-05 14:09:12 +00:00
2021-11-28 18:41:10 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: '%s' not found so vfo='%s' \n " , __func__ , s ,
rig_strvfo ( RIG_VFO_NONE ) ) ;
2017-08-05 14:09:12 +00:00
return RIG_VFO_NONE ;
2002-01-22 00:50:32 +00:00
}
2017-08-05 14:09:12 +00:00
2006-10-15 00:27:52 +00:00
/**
* \ brief Convert enum RIG_VFO_ . . . to alpha string
* \ param vfo RIG_VFO_ . . .
* \ return alpha string
2007-11-26 20:54:12 +00:00
*
* \ sa RIG_VFO_A RIG_VFO_B RIG_VFO_C RIG_VFO_MAIN RIG_VFO_SUB RIG_VFO_VFO RIG_VFO_CURR RIG_VFO_MEM RIG_VFO_TX RIG_VFO_RX RIG_VFO_NONE
2006-10-15 00:27:52 +00:00
*/
2019-11-30 16:19:08 +00:00
const char * HAMLIB_API rig_strvfo ( vfo_t vfo )
2003-01-06 22:08:45 +00:00
{
2017-08-05 14:09:12 +00:00
int i ;
2003-01-06 22:08:45 +00:00
2020-03-15 14:52:47 +00:00
//a bit too verbose
2020-05-02 12:57:16 +00:00
//rig_debug(RIG_DEBUG_TRACE, "%s called\n", __func__);
2003-01-06 22:08:45 +00:00
2017-08-05 14:09:12 +00:00
for ( i = 0 ; vfo_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
2017-10-05 02:32:08 +00:00
{
if ( vfo = = vfo_str [ i ] . vfo )
{
2020-05-02 12:57:16 +00:00
//rig_debug(RIG_DEBUG_TRACE, "%s returning %s\n", __func__, vfo_str[i].str);
2017-08-05 14:09:12 +00:00
return vfo_str [ i ] . str ;
}
2017-10-05 02:32:08 +00:00
}
2003-01-06 22:08:45 +00:00
2017-08-05 14:09:12 +00:00
return " " ;
2003-01-06 22:08:45 +00:00
}
2017-08-05 14:09:12 +00:00
2021-08-21 20:48:02 +00:00
static const struct
2017-10-05 02:32:08 +00:00
{
2017-08-05 14:09:12 +00:00
setting_t func ;
const char * str ;
2020-11-24 19:51:10 +00:00
} rig_func_str [ ] =
2017-10-05 02:32:08 +00:00
{
2017-08-05 14:09:12 +00:00
{ RIG_FUNC_FAGC , " FAGC " } ,
{ RIG_FUNC_NB , " NB " } ,
{ RIG_FUNC_COMP , " COMP " } ,
{ RIG_FUNC_VOX , " VOX " } ,
{ RIG_FUNC_TONE , " TONE " } ,
{ RIG_FUNC_TSQL , " TSQL " } ,
{ RIG_FUNC_SBKIN , " SBKIN " } ,
{ RIG_FUNC_FBKIN , " FBKIN " } ,
{ RIG_FUNC_ANF , " ANF " } ,
{ RIG_FUNC_NR , " NR " } ,
{ RIG_FUNC_AIP , " AIP " } ,
{ RIG_FUNC_APF , " APF " } ,
{ RIG_FUNC_MON , " MON " } ,
{ RIG_FUNC_MN , " MN " } ,
{ RIG_FUNC_RF , " RF " } ,
{ RIG_FUNC_ARO , " ARO " } ,
{ RIG_FUNC_LOCK , " LOCK " } ,
{ RIG_FUNC_MUTE , " MUTE " } ,
{ RIG_FUNC_VSC , " VSC " } ,
{ RIG_FUNC_REV , " REV " } ,
{ RIG_FUNC_SQL , " SQL " } ,
{ RIG_FUNC_ABM , " ABM " } ,
{ RIG_FUNC_BC , " BC " } ,
{ RIG_FUNC_MBC , " MBC " } ,
{ RIG_FUNC_RIT , " RIT " } ,
{ RIG_FUNC_AFC , " AFC " } ,
{ RIG_FUNC_SATMODE , " SATMODE " } ,
{ RIG_FUNC_SCOPE , " SCOPE " } ,
{ RIG_FUNC_RESUME , " RESUME " } ,
{ RIG_FUNC_TBURST , " TBURST " } ,
{ RIG_FUNC_TUNER , " TUNER " } ,
{ RIG_FUNC_XIT , " XIT " } ,
2019-01-01 18:33:22 +00:00
{ RIG_FUNC_NB2 , " NB2 " } ,
2018-12-24 11:00:12 +00:00
{ RIG_FUNC_DSQL , " DSQL " } ,
{ RIG_FUNC_AFLT , " AFLT " } ,
2018-12-26 08:25:38 +00:00
{ RIG_FUNC_ANL , " ANL " } ,
2019-01-01 18:33:22 +00:00
{ RIG_FUNC_BC2 , " BC2 " } ,
2019-05-30 06:37:49 +00:00
{ RIG_FUNC_DUAL_WATCH , " DUAL_WATCH " } ,
{ RIG_FUNC_DIVERSITY , " DIVERSITY " } ,
2019-12-09 05:33:20 +00:00
{ RIG_FUNC_CSQL , " CSQL " } ,
{ RIG_FUNC_SCEN , " SCEN " } ,
2021-05-26 20:40:53 +00:00
{ RIG_FUNC_TRANSCEIVE , " TRANSCEIVE " } ,
{ RIG_FUNC_SPECTRUM , " SPECTRUM " } ,
{ RIG_FUNC_SPECTRUM_HOLD , " SPECTRUM_HOLD " } ,
2021-12-19 23:30:24 +00:00
{ RIG_FUNC_SEND_MORSE , " SEND_MORSE " } ,
{ RIG_FUNC_SEND_VOICE_MEM , " SEND_VOICE_MEM " } ,
2022-11-05 04:31:51 +00:00
{ RIG_FUNC_OVF_STATUS , " OVF_STATUS " } ,
2024-01-18 15:18:49 +00:00
{ RIG_FUNC_SYNC , " SYNC " } ,
2017-08-05 14:09:12 +00:00
{ RIG_FUNC_NONE , " " } ,
2002-01-22 00:50:32 +00:00
} ;
2023-08-11 15:40:42 +00:00
static const struct
{
setting_t bandselect ;
const char * str ;
2023-12-16 17:37:58 +00:00
double start , stop ;
2023-08-11 15:40:42 +00:00
} rig_bandselect_str [ ] =
{
2023-08-11 17:12:17 +00:00
{ RIG_BANDSELECT_2200M , " BAND2200M " , 135700 , 137799 } ,
2023-12-16 17:37:58 +00:00
{ RIG_BANDSELECT_600M , " BAND600M " , 472000 , 478999 } ,
{ RIG_BANDSELECT_160M , " BAND160M " , 1800000 , 1899999 } ,
{ RIG_BANDSELECT_80M , " BAND80M " , 3400000 , 4099999 } ,
{ RIG_BANDSELECT_60M , " BAND60M " , 5250000 , 5449999 } ,
{ RIG_BANDSELECT_40M , " BAND40M " , 6900000 , 7499999 } ,
{ RIG_BANDSELECT_30M , " BAND30M " , 9900000 , 10499999 } ,
{ RIG_BANDSELECT_20M , " BAND20M " , 13900000 , 14499999 } ,
{ RIG_BANDSELECT_17M , " BAND17M " , 17900000 , 18499999 } ,
{ RIG_BANDSELECT_15M , " BAND15M " , 20900000 , 21499999 } ,
2024-01-26 22:58:51 +00:00
{ RIG_BANDSELECT_12M , " BAND12M " , 24400000 , 25099999 } ,
2023-12-16 17:37:58 +00:00
{ RIG_BANDSELECT_10M , " BAND10M " , 28000000 , 29999999 } ,
{ RIG_BANDSELECT_6M , " BAND6M " , 50000000 , 53999999 } ,
{ RIG_BANDSELECT_WFM , " BANDWFM " , 74800000 , 107999999 } ,
{ RIG_BANDSELECT_MW , " BANDMW " , 530000000 , 1700999999 } ,
{ RIG_BANDSELECT_AIR , " BANDAIR " , 108000000 , 136999999 } ,
{ RIG_BANDSELECT_2M , " BAND2M " , 144000000 , 145999999 } ,
{ RIG_BANDSELECT_1_25M , " BAND1_25M " , 219000000 , 224999999 } ,
{ RIG_BANDSELECT_70CM , " BAND70CM " , 420000000 , 449999999 } ,
{ RIG_BANDSELECT_33CM , " BAND33CM " , 902000000 , 927999999 } ,
{ RIG_BANDSELECT_23CM , " BAND23CM " , 1240000000 , 1324999999 } ,
{ RIG_BANDSELECT_13CM , " BAND13CM " , 2300000000 , 2449999999 } ,
{ RIG_BANDSELECT_9CM , " BAND9CM " , 3300000000 , 3474999999 } ,
{ RIG_BANDSELECT_5CM , " BAND5CM " , 5650000000 , 5924999999 } ,
2023-08-11 17:12:17 +00:00
{ RIG_BANDSELECT_3CM , " BAND3CM " , 10000000000 , 10499999999 } ,
2023-12-16 17:37:58 +00:00
{ RIG_BANDSELECT_GEN , " BANDGEN " , 0 , 1000000000000 } ,
2023-08-11 15:40:42 +00:00
{ 0 , NULL , 0 , 0 }
} ;
2020-11-24 19:51:10 +00:00
2021-08-21 20:48:02 +00:00
static const struct
2020-11-24 19:51:10 +00:00
{
setting_t func ;
const char * str ;
} rot_func_str [ ] =
{
{ ROT_FUNC_NONE , " " } ,
} ;
2018-12-31 21:39:49 +00:00
/**
* utility function to convert index to bit value
*
*/
uint64_t rig_idx2setting ( int i )
{
2020-03-23 12:52:01 +00:00
return ( ( uint64_t ) 1 ) < < i ;
2018-12-31 21:39:49 +00:00
}
2017-08-05 14:09:12 +00:00
2006-10-15 00:27:52 +00:00
/**
* \ brief Convert alpha string to enum RIG_FUNC_ . . .
* \ param s input alpha string
* \ return RIG_FUNC_ . . .
2007-11-26 20:54:12 +00:00
*
2017-10-05 02:32:08 +00:00
* \ sa rig_func_e ( )
2006-10-15 00:27:52 +00:00
*/
2004-10-02 10:32:09 +00:00
setting_t HAMLIB_API rig_parse_func ( const char * s )
2002-01-22 00:50:32 +00:00
{
2017-08-05 14:09:12 +00:00
int i ;
2002-01-22 00:50:32 +00:00
2017-08-05 14:09:12 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
2005-04-04 18:31:00 +00:00
2020-11-24 19:51:10 +00:00
for ( i = 0 ; rig_func_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
2017-10-05 02:32:08 +00:00
{
2020-11-24 19:51:10 +00:00
if ( ! strcmp ( s , rig_func_str [ i ] . str ) )
2017-10-05 02:32:08 +00:00
{
2020-11-24 19:51:10 +00:00
return rig_func_str [ i ] . func ;
2017-08-05 14:09:12 +00:00
}
2017-10-05 02:32:08 +00:00
}
2017-08-05 14:09:12 +00:00
return RIG_FUNC_NONE ;
2002-01-22 00:50:32 +00:00
}
2023-08-11 15:40:42 +00:00
/**
* \ brief Convert alpha string to enum band_select_t . . .
* \ param s input alpha string
* \ return RIG_FUNC_ . . .
*
* \ sa rig_func_e ( )
*/
2023-10-13 22:36:29 +00:00
// cppcheck-suppress unusedFunction
2023-08-11 15:40:42 +00:00
setting_t HAMLIB_API rig_parse_band ( const char * s )
{
int i ;
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
2024-01-11 13:03:16 +00:00
for ( i = 0 ; rig_bandselect_str [ i ] . str ! = NULL ; i + + )
2023-08-11 15:40:42 +00:00
{
if ( ! strcmp ( s , rig_bandselect_str [ i ] . str ) )
{
return rig_bandselect_str [ i ] . bandselect ;
}
}
return RIG_FUNC_NONE ;
}
2017-08-05 14:09:12 +00:00
2020-11-24 19:51:10 +00:00
/**
* \ brief Convert alpha string to enum ROT_FUNC_ . . .
* \ param s input alpha string
* \ return ROT_FUNC_ . . .
*
* \ sa rot_func_e ( )
*/
setting_t HAMLIB_API rot_parse_func ( const char * s )
{
int i ;
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
for ( i = 0 ; rot_func_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
{
if ( ! strcmp ( s , rot_func_str [ i ] . str ) )
{
return rot_func_str [ i ] . func ;
}
}
return ROT_FUNC_NONE ;
}
2006-10-15 00:27:52 +00:00
/**
* \ brief Convert enum RIG_FUNC_ . . . to alpha string
* \ param func RIG_FUNC_ . . .
* \ return alpha string
2007-11-26 20:54:12 +00:00
*
2017-10-05 02:32:08 +00:00
* \ sa rig_func_e ( )
2006-10-15 00:27:52 +00:00
*/
2019-11-30 16:19:08 +00:00
const char * HAMLIB_API rig_strfunc ( setting_t func )
2003-01-06 22:08:45 +00:00
{
2017-08-05 14:09:12 +00:00
int i ;
2019-11-19 17:32:39 +00:00
// too verbose to keep on unless debugging this in particular
//rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
2003-01-06 22:08:45 +00:00
2017-10-05 02:32:08 +00:00
if ( func = = RIG_FUNC_NONE )
{
2017-08-05 14:09:12 +00:00
return " " ;
}
2003-01-06 22:08:45 +00:00
2020-11-24 19:51:10 +00:00
for ( i = 0 ; rig_func_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
{
if ( func = = rig_func_str [ i ] . func )
{
return rig_func_str [ i ] . str ;
}
}
return " " ;
}
/**
* \ brief Convert enum ROT_FUNC_ . . . to alpha string
* \ param func ROT_FUNC_ . . .
* \ return alpha string
*
* \ sa rot_func_e ( )
*/
const char * HAMLIB_API rot_strfunc ( setting_t func )
{
int i ;
// too verbose to keep on unless debugging this in particular
//rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
if ( func = = ROT_FUNC_NONE )
{
return " " ;
}
for ( i = 0 ; rot_func_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
2017-10-05 02:32:08 +00:00
{
2020-11-24 19:51:10 +00:00
if ( func = = rot_func_str [ i ] . func )
2017-10-05 02:32:08 +00:00
{
2020-11-24 19:51:10 +00:00
return rot_func_str [ i ] . str ;
2017-08-05 14:09:12 +00:00
}
2017-10-05 02:32:08 +00:00
}
2003-01-06 22:08:45 +00:00
2017-08-05 14:09:12 +00:00
return " " ;
2003-01-06 22:08:45 +00:00
}
2017-08-05 14:09:12 +00:00
2021-08-21 20:48:02 +00:00
static const struct
2017-10-05 02:32:08 +00:00
{
2017-08-05 14:09:12 +00:00
setting_t level ;
const char * str ;
2020-11-24 19:51:10 +00:00
} rig_level_str [ ] =
2017-10-05 02:32:08 +00:00
{
2017-08-05 14:09:12 +00:00
{ RIG_LEVEL_PREAMP , " PREAMP " } ,
{ RIG_LEVEL_ATT , " ATT " } ,
2020-03-24 14:59:18 +00:00
{ RIG_LEVEL_VOXDELAY , " VOXDELAY " } ,
2017-08-05 14:09:12 +00:00
{ RIG_LEVEL_AF , " AF " } ,
{ RIG_LEVEL_RF , " RF " } ,
{ RIG_LEVEL_SQL , " SQL " } ,
{ RIG_LEVEL_IF , " IF " } ,
{ RIG_LEVEL_APF , " APF " } ,
{ RIG_LEVEL_NR , " NR " } ,
{ RIG_LEVEL_PBT_IN , " PBT_IN " } ,
{ RIG_LEVEL_PBT_OUT , " PBT_OUT " } ,
{ RIG_LEVEL_CWPITCH , " CWPITCH " } ,
{ RIG_LEVEL_RFPOWER , " RFPOWER " } ,
{ RIG_LEVEL_MICGAIN , " MICGAIN " } ,
{ RIG_LEVEL_KEYSPD , " KEYSPD " } ,
{ RIG_LEVEL_NOTCHF , " NOTCHF " } ,
{ RIG_LEVEL_COMP , " COMP " } ,
{ RIG_LEVEL_AGC , " AGC " } ,
{ RIG_LEVEL_BKINDL , " BKINDL " } ,
{ RIG_LEVEL_BALANCE , " BAL " } ,
{ RIG_LEVEL_METER , " METER " } ,
{ RIG_LEVEL_VOXGAIN , " VOXGAIN " } ,
{ RIG_LEVEL_ANTIVOX , " ANTIVOX " } ,
{ RIG_LEVEL_SLOPE_LOW , " SLOPE_LOW " } ,
{ RIG_LEVEL_SLOPE_HIGH , " SLOPE_HIGH " } ,
{ RIG_LEVEL_BKIN_DLYMS , " BKIN_DLYMS " } ,
{ RIG_LEVEL_RAWSTR , " RAWSTR " } ,
{ RIG_LEVEL_SWR , " SWR " } ,
{ RIG_LEVEL_ALC , " ALC " } ,
{ RIG_LEVEL_STRENGTH , " STRENGTH " } ,
2019-05-30 06:37:49 +00:00
{ RIG_LEVEL_RFPOWER_METER , " RFPOWER_METER " } ,
{ RIG_LEVEL_COMP_METER , " COMP_METER " } ,
{ RIG_LEVEL_VD_METER , " VD_METER " } ,
{ RIG_LEVEL_ID_METER , " ID_METER " } ,
{ RIG_LEVEL_NOTCHF_RAW , " NOTCHF_RAW " } ,
{ RIG_LEVEL_MONITOR_GAIN , " MONITOR_GAIN " } ,
2019-06-01 06:51:17 +00:00
{ RIG_LEVEL_NB , " NB " } ,
2020-12-16 23:47:49 +00:00
{ RIG_LEVEL_RFPOWER_METER_WATTS , " RFPOWER_METER_WATTS " } ,
2021-05-26 20:40:53 +00:00
{ RIG_LEVEL_SPECTRUM_MODE , " SPECTRUM_MODE " } ,
{ RIG_LEVEL_SPECTRUM_SPAN , " SPECTRUM_SPAN " } ,
{ RIG_LEVEL_SPECTRUM_EDGE_LOW , " SPECTRUM_EDGE_LOW " } ,
{ RIG_LEVEL_SPECTRUM_EDGE_HIGH , " SPECTRUM_EDGE_HIGH " } ,
{ RIG_LEVEL_SPECTRUM_SPEED , " SPECTRUM_SPEED " } ,
{ RIG_LEVEL_SPECTRUM_REF , " SPECTRUM_REF " } ,
{ RIG_LEVEL_SPECTRUM_AVG , " SPECTRUM_AVG " } ,
2021-05-27 07:12:01 +00:00
{ RIG_LEVEL_SPECTRUM_ATT , " SPECTRUM_ATT " } ,
2021-08-03 04:55:24 +00:00
{ RIG_LEVEL_TEMP_METER , " TEMP_METER " } ,
2022-01-29 22:25:18 +00:00
{ RIG_LEVEL_BAND_SELECT , " BAND_SELECT " } ,
2022-11-01 14:14:19 +00:00
{ RIG_LEVEL_USB_AF , " USB_AF " } ,
2023-10-18 21:47:29 +00:00
{ RIG_LEVEL_USB_AF_INPUT , " USB_AF_INPUT " } ,
2022-11-04 15:49:14 +00:00
{ RIG_LEVEL_AGC_TIME , " AGC_TIME " } ,
2017-08-05 14:09:12 +00:00
{ RIG_LEVEL_NONE , " " } ,
2002-01-22 00:50:32 +00:00
} ;
2020-11-24 19:51:10 +00:00
2021-08-21 20:48:02 +00:00
static const struct
2019-06-12 20:52:35 +00:00
{
setting_t level ;
const char * str ;
2020-11-24 19:51:10 +00:00
} rot_level_str [ ] =
{
{ ROT_LEVEL_SPEED , " SPEED " } ,
{ ROT_LEVEL_NONE , " " } ,
} ;
2021-08-21 20:48:02 +00:00
static const struct
2020-11-24 19:51:10 +00:00
{
setting_t level ;
const char * str ;
} amp_level_str [ ] =
2019-06-12 20:52:35 +00:00
{
{ AMP_LEVEL_SWR , " SWR " } ,
{ AMP_LEVEL_NH , " NH " } ,
{ AMP_LEVEL_PF , " PF " } ,
{ AMP_LEVEL_PWR_INPUT , " PWRINPUT " } ,
{ AMP_LEVEL_PWR_FWD , " PWRFORWARD " } ,
{ AMP_LEVEL_PWR_REFLECTED , " PWRREFLECTED " } ,
{ AMP_LEVEL_PWR_PEAK , " PWRPEAK " } ,
{ AMP_LEVEL_FAULT , " FAULT " } ,
{ AMP_LEVEL_NONE , " " } ,
} ;
2023-02-22 20:57:20 +00:00
/*
* \ brief check input to set_level
* \ param rig Pointer to rig data
* \ param level RIG_LEVEL_ * trying to set
* \ param val Raw input from the caller
* \ param gran If not NULL , set to location of level_gran data
*
* \ return RIG_OK if value is in range for this level , - RIG_EINVAL if not
*/
int check_level_param ( RIG * rig , setting_t level , value_t val , gran_t * * gran )
{
gran_t * this_gran ;
this_gran = & rig - > caps - > level_gran [ rig_setting2idx ( level ) ] ;
2023-05-08 12:37:13 +00:00
2023-02-22 20:57:20 +00:00
if ( gran )
2023-05-08 12:37:13 +00:00
{
* gran = this_gran ;
}
2023-02-22 20:57:20 +00:00
if ( RIG_LEVEL_IS_FLOAT ( level ) )
2023-05-08 12:37:13 +00:00
{
2023-10-12 04:22:42 +00:00
float maxval ;
2023-05-13 18:36:03 +00:00
/* If min==max==step==0, all values are OK here */
maxval = this_gran - > max . f ;
2023-05-22 13:47:01 +00:00
2023-05-13 18:36:03 +00:00
if ( this_gran - > min . f = = 0.0f & & maxval = = 0.0f )
2023-05-08 12:37:13 +00:00
{
2023-05-22 13:47:01 +00:00
/* if step==0 also, we're good */
if ( this_gran - > step . f = = 0.0f )
{
return RIG_OK ;
}
/* non-zero step, check for max of 1.0 */
maxval = 1.0f ;
2023-05-08 12:37:13 +00:00
}
2023-05-13 18:36:03 +00:00
if ( val . f < this_gran - > min . f | | val . f > maxval )
2023-02-22 20:57:20 +00:00
{
2023-05-08 12:37:13 +00:00
return - RIG_EINVAL ;
}
}
2023-02-22 20:57:20 +00:00
else
2023-05-08 12:37:13 +00:00
{
/* If min==max==0, all values are OK here but may be checked later */
if ( this_gran - > min . i = = 0 & & this_gran - > max . i = = 0 )
2023-02-22 20:57:20 +00:00
{
2023-05-08 12:37:13 +00:00
return RIG_OK ;
}
if ( val . i < this_gran - > min . i | | val . i > this_gran - > max . i )
{
return - RIG_EINVAL ;
}
}
2023-02-22 20:57:20 +00:00
return RIG_OK ;
}
2017-08-05 14:09:12 +00:00
2006-10-15 00:27:52 +00:00
/**
* \ brief Convert alpha string to enum RIG_LEVEL_ . . .
* \ param s input alpha string
* \ return RIG_LEVEL_ . . .
2007-11-26 20:54:12 +00:00
*
2017-10-05 02:32:08 +00:00
* \ sa rig_level_e ( )
2006-10-15 00:27:52 +00:00
*/
2004-10-02 10:32:09 +00:00
setting_t HAMLIB_API rig_parse_level ( const char * s )
2002-01-22 00:50:32 +00:00
{
2017-08-05 14:09:12 +00:00
int i ;
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
2002-01-22 00:50:32 +00:00
2020-11-24 19:51:10 +00:00
for ( i = 0 ; rig_level_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
2017-10-05 02:32:08 +00:00
{
2020-11-24 19:51:10 +00:00
if ( ! strcmp ( s , rig_level_str [ i ] . str ) )
2017-10-05 02:32:08 +00:00
{
2020-11-24 19:51:10 +00:00
return rig_level_str [ i ] . level ;
2017-08-05 14:09:12 +00:00
}
2017-10-05 02:32:08 +00:00
}
2005-04-04 18:31:00 +00:00
2017-08-05 14:09:12 +00:00
return RIG_LEVEL_NONE ;
2002-01-22 00:50:32 +00:00
}
2020-11-24 19:51:10 +00:00
/**
* \ brief Convert alpha string to enum ROT_LEVEL_ . . .
* \ param s input alpha string
* \ return ROT_LEVEL_ . . .
*
* \ sa rot_level_e ( )
*/
setting_t HAMLIB_API rot_parse_level ( const char * s )
{
int i ;
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
for ( i = 0 ; rot_level_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
{
if ( ! strcmp ( s , rot_level_str [ i ] . str ) )
{
return rot_level_str [ i ] . level ;
}
}
return ROT_LEVEL_NONE ;
}
2019-06-12 20:52:35 +00:00
/**
* \ brief Convert alpha string to enum AMP_LEVEL_ . . .
* \ param s input alpha string
* \ return AMP_LEVEL_ . . .
*
* \ sa amp_level_e ( )
*/
setting_t HAMLIB_API amp_parse_level ( const char * s )
{
int i ;
rig_debug ( RIG_DEBUG_VERBOSE , " %s called level=%s \n " , __func__ , s ) ;
2019-11-30 16:19:08 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s called str=%s \n " , __func__ ,
2020-11-24 19:51:10 +00:00
amp_level_str [ 0 ] . str ) ;
2019-11-30 16:19:08 +00:00
2020-11-24 19:51:10 +00:00
for ( i = 0 ; amp_level_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
2019-06-12 20:52:35 +00:00
{
2019-11-30 16:19:08 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s called checking=%s \n " , __func__ ,
2020-11-24 19:51:10 +00:00
amp_level_str [ i ] . str ) ;
2019-11-30 16:19:08 +00:00
2020-11-24 19:51:10 +00:00
if ( ! strcmp ( s , amp_level_str [ i ] . str ) )
2019-06-12 20:52:35 +00:00
{
2020-11-24 19:51:10 +00:00
return amp_level_str [ i ] . level ;
2019-06-12 20:52:35 +00:00
}
}
2020-11-24 19:51:10 +00:00
return AMP_LEVEL_NONE ;
2019-06-12 20:52:35 +00:00
}
2017-08-05 14:09:12 +00:00
2006-10-15 00:27:52 +00:00
/**
* \ brief Convert enum RIG_LEVEL_ . . . to alpha string
* \ param level RIG_LEVEL_ . . .
* \ return alpha string
2007-11-26 20:54:12 +00:00
*
2017-10-05 02:32:08 +00:00
* \ sa rig_level_e ( )
2006-10-15 00:27:52 +00:00
*/
2019-11-30 16:19:08 +00:00
const char * HAMLIB_API rig_strlevel ( setting_t level )
2003-01-06 22:08:45 +00:00
{
2017-08-05 14:09:12 +00:00
int i ;
2023-07-20 22:38:05 +00:00
rig_debug ( RIG_DEBUG_CACHE , " %s called \n " , __func__ ) ;
2003-01-06 22:08:45 +00:00
2017-10-05 02:32:08 +00:00
if ( level = = RIG_LEVEL_NONE )
{
2017-08-05 14:09:12 +00:00
return " " ;
}
2003-01-06 22:08:45 +00:00
2020-11-24 19:51:10 +00:00
for ( i = 0 ; rig_level_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
2017-10-05 02:32:08 +00:00
{
2020-11-24 19:51:10 +00:00
if ( level = = rig_level_str [ i ] . level )
2017-10-05 02:32:08 +00:00
{
2020-11-24 19:51:10 +00:00
return rig_level_str [ i ] . str ;
2017-08-05 14:09:12 +00:00
}
2017-10-05 02:32:08 +00:00
}
2003-01-06 22:08:45 +00:00
2017-08-05 14:09:12 +00:00
return " " ;
2003-01-06 22:08:45 +00:00
}
2020-11-24 19:51:10 +00:00
/**
* \ brief Convert enum ROT_LEVEL_ . . . to alpha string
* \ param level ROT_LEVEL_ . . .
* \ return alpha string
*
* \ sa rot_level_e ( )
*/
const char * HAMLIB_API rot_strlevel ( setting_t level )
{
int i ;
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
if ( level = = ROT_LEVEL_NONE )
{
return " " ;
}
for ( i = 0 ; rot_level_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
{
if ( level = = rot_level_str [ i ] . level )
{
return rot_level_str [ i ] . str ;
}
}
return " " ;
}
2019-06-12 20:52:35 +00:00
/**
* \ brief Convert enum AMP_LEVEL_ . . . to alpha string
* \ param level AMP_LEVEL_ . . .
* \ return alpha string
*
* \ sa amp_level_e ( )
*/
2019-11-30 16:19:08 +00:00
const char * HAMLIB_API amp_strlevel ( setting_t level )
2019-06-12 20:52:35 +00:00
{
int i ;
//rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
if ( level = = AMP_LEVEL_NONE )
{
return " " ;
}
2020-11-24 19:51:10 +00:00
for ( i = 0 ; amp_level_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
2019-06-12 20:52:35 +00:00
{
2020-11-24 19:51:10 +00:00
if ( level = = amp_level_str [ i ] . level )
2019-06-12 20:52:35 +00:00
{
2020-11-24 19:51:10 +00:00
return amp_level_str [ i ] . str ;
2019-06-12 20:52:35 +00:00
}
}
return " " ;
}
2017-08-05 14:09:12 +00:00
2021-08-21 20:48:02 +00:00
static const struct
2017-10-05 02:32:08 +00:00
{
2017-08-05 14:09:12 +00:00
setting_t parm ;
const char * str ;
2020-11-24 19:51:10 +00:00
} rig_parm_str [ ] =
2017-10-05 02:32:08 +00:00
{
2017-08-05 14:09:12 +00:00
{ RIG_PARM_ANN , " ANN " } ,
{ RIG_PARM_APO , " APO " } ,
{ RIG_PARM_BACKLIGHT , " BACKLIGHT " } ,
{ RIG_PARM_BEEP , " BEEP " } ,
{ RIG_PARM_TIME , " TIME " } ,
{ RIG_PARM_BAT , " BAT " } ,
{ RIG_PARM_KEYLIGHT , " KEYLIGHT " } ,
2020-02-23 15:48:21 +00:00
{ RIG_PARM_SCREENSAVER , " SCREENSAVER " } ,
2023-08-11 15:40:42 +00:00
{ RIG_PARM_BANDSELECT , " BANDSELECT " } ,
2023-08-17 22:52:03 +00:00
{ RIG_PARM_KEYERTYPE , " KEYERTYPE " } ,
2017-08-05 14:09:12 +00:00
{ RIG_PARM_NONE , " " } ,
2002-01-22 00:50:32 +00:00
} ;
2017-08-05 14:09:12 +00:00
2021-08-21 20:48:02 +00:00
static const struct
2020-11-24 19:51:10 +00:00
{
setting_t parm ;
const char * str ;
} rot_parm_str [ ] =
{
{ ROT_PARM_NONE , " " } ,
} ;
2006-10-15 00:27:52 +00:00
/**
* \ brief Convert alpha string to RIG_PARM_ . . .
* \ param s input alpha string
* \ return RIG_PARM_ . . .
2007-11-26 20:54:12 +00:00
*
2017-10-05 02:32:08 +00:00
* \ sa rig_parm_e ( )
2006-10-15 00:27:52 +00:00
*/
2004-10-02 10:32:09 +00:00
setting_t HAMLIB_API rig_parse_parm ( const char * s )
2002-01-22 00:50:32 +00:00
{
2017-08-05 14:09:12 +00:00
int i ;
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
2002-01-22 00:50:32 +00:00
2020-11-24 19:51:10 +00:00
for ( i = 0 ; rig_parm_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
2017-10-05 02:32:08 +00:00
{
2020-11-24 19:51:10 +00:00
if ( ! strcmp ( s , rig_parm_str [ i ] . str ) )
2017-10-05 02:32:08 +00:00
{
2020-11-24 19:51:10 +00:00
return rig_parm_str [ i ] . parm ;
2017-08-05 14:09:12 +00:00
}
2017-10-05 02:32:08 +00:00
}
2005-04-04 18:31:00 +00:00
2017-08-05 14:09:12 +00:00
return RIG_PARM_NONE ;
2005-04-04 21:24:51 +00:00
}
2005-04-04 18:31:00 +00:00
2017-08-05 14:09:12 +00:00
2020-11-24 19:51:10 +00:00
/**
* \ brief Convert alpha string to ROT_PARM_ . . .
* \ param s input alpha string
* \ return ROT_PARM_ . . .
*
* \ sa rot_parm_e ( )
*/
setting_t HAMLIB_API rot_parse_parm ( const char * s )
{
int i ;
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
for ( i = 0 ; rot_parm_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
{
if ( ! strcmp ( s , rot_parm_str [ i ] . str ) )
{
return rot_parm_str [ i ] . parm ;
}
}
return ROT_PARM_NONE ;
}
2006-10-15 00:27:52 +00:00
/**
* \ brief Convert enum RIG_PARM_ . . . to alpha string
* \ param parm RIG_PARM_ . . .
* \ return alpha string
2007-11-26 20:54:12 +00:00
*
2017-10-05 02:32:08 +00:00
* \ sa rig_parm_e ( )
2006-10-15 00:27:52 +00:00
*/
2019-11-30 16:19:08 +00:00
const char * HAMLIB_API rig_strparm ( setting_t parm )
2003-01-06 22:08:45 +00:00
{
2017-08-05 14:09:12 +00:00
int i ;
2003-01-06 22:08:45 +00:00
2017-08-05 14:09:12 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
2003-01-06 22:08:45 +00:00
2017-10-05 02:32:08 +00:00
if ( parm = = RIG_PARM_NONE )
{
2017-08-05 14:09:12 +00:00
return " " ;
}
2003-01-06 22:08:45 +00:00
2020-11-24 19:51:10 +00:00
for ( i = 0 ; rig_parm_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
{
if ( parm = = rig_parm_str [ i ] . parm )
{
return rig_parm_str [ i ] . str ;
}
}
return " " ;
}
/**
* \ brief Convert enum ROT_PARM_ . . . to alpha string
* \ param parm ROT_PARM_ . . .
* \ return alpha string
*
* \ sa rot_parm_e ( )
*/
const char * HAMLIB_API rot_strparm ( setting_t parm )
{
int i ;
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
if ( parm = = ROT_PARM_NONE )
{
return " " ;
}
for ( i = 0 ; rot_parm_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
2017-10-05 02:32:08 +00:00
{
2020-11-24 19:51:10 +00:00
if ( parm = = rot_parm_str [ i ] . parm )
2017-10-05 02:32:08 +00:00
{
2020-11-24 19:51:10 +00:00
return rot_parm_str [ i ] . str ;
2017-08-05 14:09:12 +00:00
}
2017-10-05 02:32:08 +00:00
}
2017-08-05 14:09:12 +00:00
return " " ;
2003-01-06 22:08:45 +00:00
}
2021-08-21 20:48:02 +00:00
static const struct
2021-05-26 20:40:53 +00:00
{
enum agc_level_e level ;
const char * str ;
} rig_agc_level_str [ ] =
{
{ RIG_AGC_OFF , " OFF " } ,
{ RIG_AGC_SUPERFAST , " SUPERFAST " } ,
{ RIG_AGC_FAST , " FAST " } ,
{ RIG_AGC_SLOW , " SLOW " } ,
{ RIG_AGC_USER , " USER " } ,
{ RIG_AGC_MEDIUM , " MEDIUM " } ,
{ RIG_AGC_AUTO , " AUTO " } ,
2022-11-24 15:47:12 +00:00
{ RIG_AGC_LONG , " LONG " } ,
{ RIG_AGC_ON , " ON " } ,
2023-01-06 22:21:58 +00:00
{ RIG_AGC_NONE , " NONE " } ,
2021-05-26 20:40:53 +00:00
{ - 1 , " " } ,
} ;
/**
* \ brief Convert enum RIG_AGC_ . . . to alpha string
2023-03-19 20:23:35 +00:00
* \ param level RIG_AGC_ . . .
2021-05-26 20:40:53 +00:00
* \ return alpha string
*/
const char * HAMLIB_API rig_stragclevel ( enum agc_level_e level )
{
int i ;
if ( level < 0 )
{
return " " ;
}
for ( i = 0 ; rig_agc_level_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
{
if ( level = = rig_agc_level_str [ i ] . level )
{
return rig_agc_level_str [ i ] . str ;
}
}
return " " ;
}
2021-12-13 22:15:26 +00:00
/**
* \ brief Convert a enum agc_level_e to value
* \ param integer . . .
* \ return agc_level_e value
*/
2021-12-29 04:30:53 +00:00
value_t rig_valueagclevel ( enum agc_level_e agcLevel )
2021-12-13 22:15:26 +00:00
{
value_t value ;
2021-12-29 04:30:53 +00:00
if ( agcLevel = = RIG_AGC_OFF ) { value . i = 0 ; }
else if ( agcLevel = = RIG_AGC_SUPERFAST ) { value . i = 1 ; }
else if ( agcLevel = = RIG_AGC_FAST ) { value . i = 2 ; }
else if ( agcLevel = = RIG_AGC_SLOW ) { value . i = 3 ; }
else if ( agcLevel = = RIG_AGC_USER ) { value . i = 4 ; }
else if ( agcLevel = = RIG_AGC_MEDIUM ) { value . i = 5 ; }
else { value . i = 6 ; } //RIG_AGC_AUTO
2021-12-13 22:15:26 +00:00
return value ;
}
2021-12-10 14:39:16 +00:00
/**
* \ brief Convert a value to agc_level_e - - constrains the range
* \ param integer . . .
* \ return agc_level_e
*/
2021-12-13 22:15:26 +00:00
enum agc_level_e rig_levelagcvalue ( int agcValue )
2021-12-10 14:39:16 +00:00
{
enum agc_level_e agcLevel ;
switch ( agcValue )
{
case 0 : agcLevel = RIG_AGC_OFF ; break ;
case 1 : agcLevel = RIG_AGC_SUPERFAST ; break ;
case 2 : agcLevel = RIG_AGC_FAST ; break ;
case 3 : agcLevel = RIG_AGC_SLOW ; break ;
case 4 : agcLevel = RIG_AGC_USER ; break ;
case 5 : agcLevel = RIG_AGC_MEDIUM ; break ;
case 6 : agcLevel = RIG_AGC_AUTO ; break ;
default : agcLevel = RIG_AGC_AUTO ; break ;
}
return agcLevel ;
}
/**
* \ brief Convert AGC string . . . to agc_level_e
* \ param mode AGC string . . .
* \ return agc_level_e
*/
2023-10-12 04:22:42 +00:00
enum agc_level_e rig_levelagcstr ( const char * agcString )
2021-12-10 14:39:16 +00:00
{
enum agc_level_e agcLevel ;
if ( strcmp ( agcString , " OFF " ) = = 0 ) { agcLevel = RIG_AGC_OFF ; }
else if ( strcmp ( agcString , " SUPERFAST " ) = = 0 ) { agcLevel = RIG_AGC_SUPERFAST ; }
else if ( strcmp ( agcString , " FAST " ) = = 0 ) { agcLevel = RIG_AGC_FAST ; }
else if ( strcmp ( agcString , " SLOW " ) = = 0 ) { agcLevel = RIG_AGC_SLOW ; }
else if ( strcmp ( agcString , " USER " ) = = 0 ) { agcLevel = RIG_AGC_USER ; }
else if ( strcmp ( agcString , " MEDIUM " ) = = 0 ) { agcLevel = RIG_AGC_MEDIUM ; }
else { agcLevel = RIG_AGC_AUTO ; }
return agcLevel ;
}
2017-08-05 14:09:12 +00:00
2021-08-21 20:48:02 +00:00
static const struct
2017-10-05 02:32:08 +00:00
{
2017-08-05 14:09:12 +00:00
vfo_op_t vfo_op ;
const char * str ;
2017-10-05 02:32:08 +00:00
} vfo_op_str [ ] =
{
2017-08-05 14:09:12 +00:00
{ RIG_OP_CPY , " CPY " } ,
{ RIG_OP_XCHG , " XCHG " } ,
{ RIG_OP_FROM_VFO , " FROM_VFO " } ,
{ RIG_OP_TO_VFO , " TO_VFO " } ,
{ RIG_OP_MCL , " MCL " } ,
{ RIG_OP_UP , " UP " } ,
{ RIG_OP_DOWN , " DOWN " } ,
{ RIG_OP_BAND_UP , " BAND_UP " } ,
{ RIG_OP_BAND_DOWN , " BAND_DOWN " } ,
{ RIG_OP_LEFT , " LEFT " } ,
{ RIG_OP_RIGHT , " RIGHT " } ,
{ RIG_OP_TUNE , " TUNE " } ,
{ RIG_OP_TOGGLE , " TOGGLE " } ,
{ RIG_OP_NONE , " " } ,
2002-01-22 00:50:32 +00:00
} ;
2017-08-05 14:09:12 +00:00
2006-10-15 00:27:52 +00:00
/**
* \ brief Convert alpha string to enum RIG_OP_ . . .
* \ param s alpha string
* \ return RIG_OP_ . . .
2007-11-26 20:54:12 +00:00
*
2017-10-05 02:32:08 +00:00
* \ sa vfo_op_t ( )
2006-10-15 00:27:52 +00:00
*/
2004-10-02 10:32:09 +00:00
vfo_op_t HAMLIB_API rig_parse_vfo_op ( const char * s )
2002-01-22 00:50:32 +00:00
{
2017-08-05 14:09:12 +00:00
int i ;
2002-01-22 00:50:32 +00:00
2017-08-05 14:09:12 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
2005-04-04 18:31:00 +00:00
2017-08-05 14:09:12 +00:00
for ( i = 0 ; vfo_op_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
2017-10-05 02:32:08 +00:00
{
if ( ! strcmp ( s , vfo_op_str [ i ] . str ) )
{
2017-08-05 14:09:12 +00:00
return vfo_op_str [ i ] . vfo_op ;
}
2017-10-05 02:32:08 +00:00
}
2017-08-05 14:09:12 +00:00
return RIG_OP_NONE ;
2002-01-22 00:50:32 +00:00
}
2017-08-05 14:09:12 +00:00
2006-10-15 00:27:52 +00:00
/**
* \ brief Convert enum RIG_OP_ . . . to alpha string
* \ param op RIG_OP_ . . .
* \ return alpha string
2007-11-26 20:54:12 +00:00
*
2017-10-05 02:32:08 +00:00
* \ sa vfo_op_t ( )
2006-10-15 00:27:52 +00:00
*/
2019-11-30 16:19:08 +00:00
const char * HAMLIB_API rig_strvfop ( vfo_op_t op )
2003-01-06 22:08:45 +00:00
{
2017-08-05 14:09:12 +00:00
int i ;
2003-01-06 22:08:45 +00:00
2020-03-31 20:40:54 +00:00
// too verbose
// rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
2017-08-05 14:09:12 +00:00
for ( i = 0 ; vfo_op_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
2019-11-30 16:19:08 +00:00
{
if ( op = = vfo_op_str [ i ] . vfo_op )
2017-10-05 02:32:08 +00:00
{
2017-08-05 14:09:12 +00:00
return vfo_op_str [ i ] . str ;
}
2017-10-05 02:32:08 +00:00
}
2003-01-06 22:08:45 +00:00
2017-08-05 14:09:12 +00:00
return " " ;
2003-01-06 22:08:45 +00:00
}
2017-08-05 14:09:12 +00:00
2021-08-21 20:48:02 +00:00
static const struct
2017-10-05 02:32:08 +00:00
{
2017-08-05 14:09:12 +00:00
scan_t rscan ;
const char * str ;
2017-10-05 02:32:08 +00:00
} scan_str [ ] =
{
2017-08-05 14:09:12 +00:00
{ RIG_SCAN_STOP , " STOP " } ,
{ RIG_SCAN_MEM , " MEM " } ,
{ RIG_SCAN_SLCT , " SLCT " } ,
{ RIG_SCAN_PRIO , " PRIO " } ,
{ RIG_SCAN_PROG , " PROG " } ,
{ RIG_SCAN_DELTA , " DELTA " } ,
{ RIG_SCAN_VFO , " VFO " } ,
{ RIG_SCAN_PLT , " PLT " } ,
{ RIG_SCAN_NONE , " " } ,
{ - 1 , NULL }
2002-01-22 00:50:32 +00:00
} ;
2017-08-05 14:09:12 +00:00
2006-10-15 00:27:52 +00:00
/**
* \ brief Convert alpha string to enum RIG_SCAN_ . . .
* \ param s alpha string
* \ return RIG_SCAN_ . . .
2007-11-26 20:54:12 +00:00
*
2017-10-05 02:32:08 +00:00
* \ sa scan_t ( )
2006-10-15 00:27:52 +00:00
*/
2004-10-02 10:32:09 +00:00
scan_t HAMLIB_API rig_parse_scan ( const char * s )
2002-01-22 00:50:32 +00:00
{
2017-08-05 14:09:12 +00:00
int i ;
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
2017-10-05 02:32:08 +00:00
for ( i = 0 ; scan_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
{
if ( strcmp ( s , scan_str [ i ] . str ) = = 0 )
{
2017-08-05 14:09:12 +00:00
return scan_str [ i ] . rscan ;
}
}
return RIG_SCAN_NONE ;
2002-01-22 00:50:32 +00:00
}
2017-08-05 14:09:12 +00:00
2006-10-15 00:27:52 +00:00
/**
* \ brief Convert enum RIG_SCAN_ . . . to alpha string
* \ param rscan RIG_SCAN_ . . .
* \ return alpha string
2007-11-26 20:54:12 +00:00
*
2017-10-05 02:32:08 +00:00
* \ sa scan_t ( )
2006-10-15 00:27:52 +00:00
*/
2019-11-30 16:19:08 +00:00
const char * HAMLIB_API rig_strscan ( scan_t rscan )
2003-01-06 22:08:45 +00:00
{
2017-08-05 14:09:12 +00:00
int i ;
2020-03-31 21:10:43 +00:00
// too verbose
// rig_debug(RIG_DEBUG_VERBOSE, "%s called\n", __func__);
2017-08-05 14:09:12 +00:00
2017-10-05 02:32:08 +00:00
if ( rscan = = RIG_SCAN_NONE )
{
2017-08-05 14:09:12 +00:00
return " " ;
}
2003-01-06 22:08:45 +00:00
2017-08-05 14:09:12 +00:00
for ( i = 0 ; scan_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
2019-11-30 16:19:08 +00:00
{
if ( rscan = = scan_str [ i ] . rscan )
2017-10-05 02:32:08 +00:00
{
2017-08-05 14:09:12 +00:00
return scan_str [ i ] . str ;
}
2017-10-05 02:32:08 +00:00
}
2003-01-06 22:08:45 +00:00
2017-08-05 14:09:12 +00:00
return " " ;
2003-01-06 22:08:45 +00:00
}
2017-08-05 14:09:12 +00:00
2006-10-15 00:27:52 +00:00
/**
* \ brief convert enum RIG_RPT_SHIFT_ . . . to printable character
* \ param shift RIG_RPT_SHIFT_ ? ?
* \ return alpha character
*/
2017-10-05 02:32:08 +00:00
const char * HAMLIB_API rig_strptrshift ( rptr_shift_t shift )
2006-10-15 00:27:52 +00:00
{
2017-08-05 14:09:12 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
2017-10-05 02:32:08 +00:00
switch ( shift )
{
2017-08-05 14:09:12 +00:00
case RIG_RPT_SHIFT_MINUS :
return " - " ;
case RIG_RPT_SHIFT_PLUS :
return " + " ;
case RIG_RPT_SHIFT_NONE :
return " None " ;
}
return NULL ;
2006-10-15 00:27:52 +00:00
}
2003-01-06 22:08:45 +00:00
2017-08-05 14:09:12 +00:00
2006-10-15 00:27:52 +00:00
/**
* \ brief Convert alpha char to enum RIG_RPT_SHIFT_ . . .
* \ param s alpha char
* \ return RIG_RPT_SHIFT_ . . .
*/
2004-10-02 10:32:09 +00:00
rptr_shift_t HAMLIB_API rig_parse_rptr_shift ( const char * s )
2002-01-22 00:50:32 +00:00
{
2017-08-05 14:09:12 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
2017-10-05 02:32:08 +00:00
if ( strcmp ( s , " + " ) = = 0 )
{
2017-08-05 14:09:12 +00:00
return RIG_RPT_SHIFT_PLUS ;
2017-10-05 02:32:08 +00:00
}
else if ( strcmp ( s , " - " ) = = 0 )
{
2017-08-05 14:09:12 +00:00
return RIG_RPT_SHIFT_MINUS ;
2017-10-05 02:32:08 +00:00
}
else
{
2017-08-05 14:09:12 +00:00
return RIG_RPT_SHIFT_NONE ;
}
2002-01-22 00:50:32 +00:00
}
2017-08-05 14:09:12 +00:00
2021-08-21 20:48:02 +00:00
static const struct
2017-10-05 02:32:08 +00:00
{
2017-08-05 14:09:12 +00:00
chan_type_t mtype ;
const char * str ;
2017-10-05 02:32:08 +00:00
} mtype_str [ ] =
{
2017-08-05 14:09:12 +00:00
{ RIG_MTYPE_MEM , " MEM " } ,
{ RIG_MTYPE_EDGE , " EDGE " } ,
{ RIG_MTYPE_CALL , " CALL " } ,
{ RIG_MTYPE_MEMOPAD , " MEMOPAD " } ,
{ RIG_MTYPE_SAT , " SAT " } ,
{ RIG_MTYPE_BAND , " BAND " } ,
{ RIG_MTYPE_PRIO , " PRIO " } ,
{ RIG_MTYPE_NONE , " " } ,
2008-04-27 09:48:40 +00:00
} ;
2017-08-05 14:09:12 +00:00
2008-04-27 09:48:40 +00:00
/**
* \ brief Convert alpha string to enum RIG_MTYPE_ . . .
* \ param s alpha string
* \ return RIG_MTYPE_ . . .
*
2017-10-05 02:32:08 +00:00
* \ sa chan_type_t ( )
2008-04-27 09:48:40 +00:00
*/
chan_type_t HAMLIB_API rig_parse_mtype ( const char * s )
{
2017-08-05 14:09:12 +00:00
int i ;
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
2017-10-05 02:32:08 +00:00
for ( i = 0 ; mtype_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
{
if ( strcmp ( s , mtype_str [ i ] . str ) = = 0 )
{
2017-08-05 14:09:12 +00:00
return mtype_str [ i ] . mtype ;
}
}
return RIG_MTYPE_NONE ;
2008-04-27 09:48:40 +00:00
}
2017-08-05 14:09:12 +00:00
2008-04-27 09:48:40 +00:00
/**
* \ brief Convert enum RIG_MTYPE_ . . . to alpha string
* \ param mtype RIG_MTYPE_ . . .
* \ return alpha string
*
2017-10-05 02:32:08 +00:00
* \ sa chan_type_t ( )
2008-04-27 09:48:40 +00:00
*/
2019-11-30 16:19:08 +00:00
const char * HAMLIB_API rig_strmtype ( chan_type_t mtype )
2008-04-27 09:48:40 +00:00
{
2017-08-05 14:09:12 +00:00
int i ;
2008-04-27 09:48:40 +00:00
2017-08-05 14:09:12 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
2008-04-27 09:48:40 +00:00
2017-10-05 02:32:08 +00:00
if ( mtype = = RIG_MTYPE_NONE )
{
2017-08-05 14:09:12 +00:00
return " " ;
}
for ( i = 0 ; mtype_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
2017-10-05 02:32:08 +00:00
{
if ( mtype = = mtype_str [ i ] . mtype )
{
2017-08-05 14:09:12 +00:00
return mtype_str [ i ] . str ;
}
2017-10-05 02:32:08 +00:00
}
2017-08-05 14:09:12 +00:00
return " " ;
2008-04-27 09:48:40 +00:00
}
2021-08-21 20:48:02 +00:00
static const struct
2021-05-26 20:40:53 +00:00
{
enum rig_spectrum_mode_e mode ;
const char * str ;
} rig_spectrum_mode_str [ ] =
{
{ RIG_SPECTRUM_MODE_CENTER , " CENTER " } ,
{ RIG_SPECTRUM_MODE_FIXED , " FIXED " } ,
{ RIG_SPECTRUM_MODE_CENTER_SCROLL , " CENTER_SCROLL " } ,
{ RIG_SPECTRUM_MODE_FIXED_SCROLL , " FIXED_SCROLL " } ,
{ RIG_SPECTRUM_MODE_NONE , " " } ,
} ;
/**
* \ brief Convert enum RIG_SPECTRUM_MODE_ . . . to alpha string
* \ param mode RIG_SPECTRUM_MODE_ . . .
* \ return alpha string
*/
const char * HAMLIB_API rig_strspectrummode ( enum rig_spectrum_mode_e mode )
{
int i ;
if ( mode = = RIG_SPECTRUM_MODE_NONE )
{
return " " ;
}
for ( i = 0 ; rig_spectrum_mode_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
{
if ( mode = = rig_spectrum_mode_str [ i ] . mode )
{
return rig_spectrum_mode_str [ i ] . str ;
}
}
return " " ;
}
2008-04-27 09:48:40 +00:00
2010-03-28 16:33:03 +00:00
static long timediff ( const struct timeval * tv1 , const struct timeval * tv2 )
{
2017-08-05 14:09:12 +00:00
struct timeval tv ;
2010-03-28 16:33:03 +00:00
2017-08-05 14:09:12 +00:00
tv . tv_usec = tv1 - > tv_usec - tv2 - > tv_usec ;
tv . tv_sec = tv1 - > tv_sec - tv2 - > tv_sec ;
2010-03-28 16:33:03 +00:00
2017-08-05 14:09:12 +00:00
return ( ( tv . tv_sec * 1000L ) + ( tv . tv_usec / 1000L ) ) ;
2010-03-28 16:33:03 +00:00
}
2017-08-05 14:09:12 +00:00
2010-03-28 16:33:03 +00:00
/**
* \ brief Helper for checking cache timeout
* \ param tv pointer to timeval , date of cache
* \ param timeout duration of cache validity , in millisec
* \ return 1 when timed out , 0 when cache shall be used
*/
int HAMLIB_API rig_check_cache_timeout ( const struct timeval * tv , int timeout )
{
struct timeval curr ;
long t ;
2017-08-05 14:09:12 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
2017-10-05 02:32:08 +00:00
if ( tv - > tv_sec = = 0 & & tv - > tv_usec = = 0 )
{
2017-08-05 14:09:12 +00:00
rig_debug ( RIG_DEBUG_VERBOSE ,
" %s: forced cache timeout \n " ,
__func__ ) ;
2010-03-28 16:33:03 +00:00
return 1 ;
}
gettimeofday ( & curr , NULL ) ;
t = timediff ( & curr , tv ) ;
2017-08-05 14:09:12 +00:00
2017-10-05 02:32:08 +00:00
if ( t < timeout )
{
2017-08-05 14:09:12 +00:00
rig_debug ( RIG_DEBUG_VERBOSE ,
" %s: using cache (%ld ms) \n " ,
__func__ ,
t ) ;
2010-03-28 16:33:03 +00:00
return 0 ;
2017-10-05 02:32:08 +00:00
}
else
{
2017-08-05 14:09:12 +00:00
rig_debug ( RIG_DEBUG_VERBOSE ,
" %s: cache timed out (%ld ms) \n " ,
__func__ ,
t ) ;
2010-03-28 16:33:03 +00:00
return 1 ;
}
}
2017-08-05 14:09:12 +00:00
2010-03-28 16:33:03 +00:00
/**
* \ brief Helper for forcing cache timeout next call
*
* This function is typically to be called in backend_set_ * functions ,
* so that a sequence :
*
\ code
rig_get_freq ( ) ;
rig_set_freq ( ) ;
rig_get_freq ( ) ;
\ endcode
*
* doesn ' t return a bogus ( cached ) value in the last rig_get_freq ( ) .
*
* \ param tv pointer to timeval to be reset
*/
void HAMLIB_API rig_force_cache_timeout ( struct timeval * tv )
{
2017-08-05 14:09:12 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
2010-03-28 16:33:03 +00:00
tv - > tv_sec = 0 ;
tv - > tv_usec = 0 ;
}
2017-08-05 14:09:12 +00:00
2020-04-09 22:56:19 +00:00
//! @cond Doxygen_Suppress
2015-12-04 00:04:51 +00:00
int no_restore_ai ;
2020-04-09 22:56:19 +00:00
//! @endcond
2015-12-04 00:04:51 +00:00
2017-08-05 14:09:12 +00:00
2020-04-09 22:56:19 +00:00
//! @cond Doxygen_Suppress
2015-12-04 00:04:51 +00:00
void HAMLIB_API rig_no_restore_ai ( )
{
2017-08-05 14:09:12 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
no_restore_ai = - 1 ;
2015-12-04 00:04:51 +00:00
}
2023-03-19 17:31:02 +00:00
//! @endcond
2020-04-26 20:44:38 +00:00
//! @cond Doxygen_Suppress
2020-05-16 19:32:34 +00:00
double HAMLIB_API elapsed_ms ( struct timespec * start , int option )
2020-04-26 20:44:38 +00:00
{
2020-05-02 16:19:44 +00:00
// If option then we are starting the timing, else we get elapsed
2020-04-26 20:44:38 +00:00
struct timespec stop ;
2020-05-02 16:19:44 +00:00
double elapsed_msec ;
2020-04-26 20:44:38 +00:00
2020-07-02 03:33:32 +00:00
if ( option = = HAMLIB_ELAPSED_SET )
2020-05-03 22:24:42 +00:00
{
2020-05-03 04:10:55 +00:00
start - > tv_sec = start - > tv_nsec = 0 ;
}
2021-03-11 19:14:42 +00:00
stop = * start ; // just to suppress some compiler warnings
2020-05-03 04:10:55 +00:00
2021-03-11 14:44:29 +00:00
//rig_debug(RIG_DEBUG_TRACE, "%s: start = %ld,%ld\n", __func__,
// (long)start->tv_sec, (long)start->tv_nsec);
2020-05-01 17:03:54 +00:00
2020-05-02 16:19:44 +00:00
switch ( option )
2020-04-26 20:44:38 +00:00
{
2020-07-02 03:33:32 +00:00
case HAMLIB_ELAPSED_GET :
2020-05-03 22:24:42 +00:00
if ( start - > tv_nsec = = 0 ) // if we haven't done SET yet
{
2020-05-02 22:32:37 +00:00
clock_gettime ( CLOCK_REALTIME , start ) ;
2020-05-03 22:24:42 +00:00
return 1000 * 1000 ;
2020-05-02 22:32:37 +00:00
}
2020-05-03 22:24:42 +00:00
2020-04-26 20:44:38 +00:00
clock_gettime ( CLOCK_REALTIME , & stop ) ;
2020-05-02 16:19:44 +00:00
break ;
2020-07-02 03:33:32 +00:00
case HAMLIB_ELAPSED_SET :
2020-05-02 16:19:44 +00:00
clock_gettime ( CLOCK_REALTIME , start ) ;
2021-03-11 14:44:29 +00:00
//rig_debug(RIG_DEBUG_TRACE, "%s: after gettime, start = %ld,%ld\n", __func__,
// (long)start->tv_sec, (long)start->tv_nsec);
2020-05-02 22:32:37 +00:00
return 999 * 1000 ; // so we can tell the difference in debug where we came from
2020-05-02 16:19:44 +00:00
break ;
2020-07-02 03:33:32 +00:00
case HAMLIB_ELAPSED_INVALIDATE :
2020-05-16 19:32:34 +00:00
clock_gettime ( CLOCK_REALTIME , start ) ;
2020-07-03 13:05:13 +00:00
stop = * start ;
start - > tv_sec - = 10 ; // ten seconds should be more than enough
2020-05-02 16:19:44 +00:00
break ;
2020-04-26 20:44:38 +00:00
}
2020-05-03 22:24:42 +00:00
elapsed_msec = ( ( stop . tv_sec - start - > tv_sec ) + ( stop . tv_nsec / 1e9 -
start - > tv_nsec / 1e9 ) ) * 1e3 ;
2020-04-26 20:44:38 +00:00
2021-03-11 14:44:29 +00:00
//rig_debug(RIG_DEBUG_TRACE, "%s: elapsed_msecs=%.0f\n", __func__, elapsed_msec);
2020-05-01 17:03:54 +00:00
2020-07-02 03:33:32 +00:00
if ( elapsed_msec < 0 | | option = = HAMLIB_ELAPSED_INVALIDATE ) { return 1000000 ; }
2020-05-01 17:03:54 +00:00
2020-05-02 16:19:44 +00:00
return elapsed_msec ;
2020-04-26 20:44:38 +00:00
}
2023-03-19 17:31:02 +00:00
//! @endcond
2020-04-26 20:44:38 +00:00
2020-07-02 03:33:32 +00:00
int HAMLIB_API rig_get_cache_timeout_ms ( RIG * rig , hamlib_cache_t selection )
2020-05-01 17:03:54 +00:00
{
rig_debug ( RIG_DEBUG_TRACE , " %s: called selection=%d \n " , __func__ , selection ) ;
2024-01-17 16:52:23 +00:00
return CACHE ( rig ) - > timeout_ms ;
2020-05-01 17:03:54 +00:00
}
2020-07-07 16:39:26 +00:00
int HAMLIB_API rig_set_cache_timeout_ms ( RIG * rig , hamlib_cache_t selection ,
int ms )
2020-05-01 17:03:54 +00:00
{
2020-05-02 16:19:44 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: called selection=%d, ms=%d \n " , __func__ ,
selection , ms ) ;
2024-01-17 16:52:23 +00:00
CACHE ( rig ) - > timeout_ms = ms ;
2020-05-01 17:03:54 +00:00
return RIG_OK ;
}
2021-11-08 16:19:12 +00:00
static char * funcname = " Unknown " ;
static int linenum = 0 ;
# undef vfo_fixup
2021-11-28 18:41:10 +00:00
vfo_t HAMLIB_API vfo_fixup2a ( RIG * rig , vfo_t vfo , split_t split ,
const char * func , int line )
2021-11-08 16:19:12 +00:00
{
2021-11-28 18:41:10 +00:00
funcname = ( char * ) func ;
2021-11-08 16:28:28 +00:00
linenum = ( int ) line ;
2021-11-28 18:41:10 +00:00
return vfo_fixup ( rig , vfo , split ) ;
2021-11-08 16:19:12 +00:00
}
Fix spelling errors
Fixed with:
codespell --summary --skip=.git,extra,,lib,macros,security --ignore-words-list="ans,ba,cant,develope,fo,get's,nin,numer,parm,parms,setts,som,statics,ths,ue,vektor,objext" --write-changes --interactive=2
and manual editing.
2022-07-07 19:25:58 +00:00
// we're mapping our VFO here to work with either VFO A/B rigs or Main/Sub
2021-04-13 13:19:48 +00:00
// Hamlib uses VFO_A and VFO_B as TX/RX as of 2021-04-13
// So we map these to Main/Sub as required
2023-02-10 14:02:48 +00:00
// We need to add some exceptions to this like the ID-5100
2021-08-03 04:37:31 +00:00
vfo_t HAMLIB_API vfo_fixup ( RIG * rig , vfo_t vfo , split_t split )
2020-06-12 13:28:05 +00:00
{
2024-01-11 13:03:16 +00:00
vfo_t currvfo = rig - > state . current_vfo ;
2021-11-28 18:41:10 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s:(from %s:%d) vfo=%s, vfo_curr=%s, split=%d \n " ,
__func__ , funcname , linenum ,
2024-01-11 13:03:16 +00:00
rig_strvfo ( vfo ) , rig_strvfo ( currvfo ) , split ) ;
2020-06-12 13:28:05 +00:00
2023-07-18 15:20:53 +00:00
if ( rig - > caps - > rig_model = = RIG_MODEL_ID5100
2023-12-16 17:37:58 +00:00
| | rig - > caps - > rig_model = = RIG_MODEL_IC9700 )
2023-02-10 14:02:48 +00:00
{
2023-11-23 21:00:05 +00:00
struct rig_state * rs = & rig - > state ;
2023-12-16 17:37:58 +00:00
2023-11-13 16:26:00 +00:00
// dualwatch on ID5100 is TX=Main, RX=Sub
2023-11-23 21:00:05 +00:00
if ( rig - > caps - > rig_model = = RIG_MODEL_ID5100 & & rs - > dual_watch )
2023-11-13 16:26:00 +00:00
{
2023-12-16 17:37:58 +00:00
if ( vfo = = RIG_VFO_TX | | vfo = = RIG_VFO_MAIN ) { return RIG_VFO_MAIN ; }
2023-11-13 16:26:00 +00:00
return RIG_VFO_SUB ;
}
2023-12-16 17:37:58 +00:00
2023-02-10 14:02:48 +00:00
return vfo ; // no change to requested vfo
}
2024-01-11 13:03:16 +00:00
else if ( RIG_IS_IC9700 )
{
if ( vfo = = RIG_VFO_A & & ( currvfo = = RIG_VFO_MAIN | | currvfo = = RIG_VFO_MAIN_A ) )
{
vfo = RIG_VFO_MAIN_A ;
2024-02-07 18:27:12 +00:00
// only have Main/Sub when in satmode
if ( rig - > state . cache . satmode ) vfo = RIG_VFO_MAIN ;
2024-01-11 13:03:16 +00:00
}
else if ( vfo = = RIG_VFO_B & & ( currvfo = = RIG_VFO_MAIN
| | currvfo = = RIG_VFO_MAIN_A ) )
{
vfo = RIG_VFO_MAIN_B ;
}
else if ( vfo = = RIG_VFO_A & & ( currvfo = = RIG_VFO_SUB
| | currvfo = = RIG_VFO_SUB_A | | currvfo = = RIG_VFO_SUB_B ) )
{
vfo = RIG_VFO_SUB_A ;
}
else if ( vfo = = RIG_VFO_B & & ( currvfo = = RIG_VFO_SUB
| | currvfo = = RIG_VFO_SUB_A | | currvfo = = RIG_VFO_SUB_B ) )
{
vfo = RIG_VFO_SUB_B ;
}
}
2023-02-10 14:02:48 +00:00
2022-02-05 21:27:43 +00:00
if ( vfo = = RIG_VFO_NONE ) { vfo = RIG_VFO_A ; }
2022-01-26 05:14:39 +00:00
if ( vfo = = RIG_VFO_CURR | | vfo = = RIG_VFO_VFO )
2020-06-12 13:28:05 +00:00
{
rig_debug ( RIG_DEBUG_TRACE , " %s: Leaving currVFO alone \n " , __func__ ) ;
return vfo ; // don't modify vfo for RIG_VFO_CURR
}
2021-11-28 18:41:10 +00:00
2021-11-10 23:39:08 +00:00
if ( vfo = = RIG_VFO_OTHER )
{
2021-11-28 18:41:10 +00:00
switch ( rig - > state . current_vfo )
2021-11-10 23:39:08 +00:00
{
2021-11-28 18:41:10 +00:00
case RIG_VFO_A :
return RIG_VFO_B ;
case RIG_VFO_MAIN :
return RIG_VFO_SUB ;
case RIG_VFO_B :
return RIG_VFO_A ;
case RIG_VFO_SUB :
return RIG_VFO_MAIN ;
case RIG_VFO_SUB_A :
return RIG_VFO_SUB_B ;
case RIG_VFO_SUB_B :
return RIG_VFO_SUB_A ;
2021-11-10 23:39:08 +00:00
}
}
2020-06-12 13:28:05 +00:00
2021-11-15 04:52:10 +00:00
if ( vfo = = RIG_VFO_RX )
{
vfo = rig - > state . rx_vfo ;
}
2021-12-29 04:30:53 +00:00
else if ( vfo = = RIG_VFO_A | | vfo = = RIG_VFO_MAIN )
2020-06-12 13:28:05 +00:00
{
2021-08-01 17:11:46 +00:00
vfo = RIG_VFO_A ; // default to mapping VFO_MAIN to VFO_A
2020-06-12 13:28:05 +00:00
if ( VFO_HAS_MAIN_SUB_ONLY ) { vfo = RIG_VFO_MAIN ; }
}
2021-07-15 20:59:28 +00:00
else if ( vfo = = RIG_VFO_TX )
2020-06-12 13:28:05 +00:00
{
2024-01-17 16:52:23 +00:00
int satmode = CACHE ( rig ) - > satmode ;
2021-04-18 03:47:14 +00:00
2021-11-28 18:41:10 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s(%d): split=%d, vfo==%s tx_vfo=%s \n " , __func__ ,
__LINE__ , split , rig_strvfo ( vfo ) , rig_strvfo ( rig - > state . tx_vfo ) ) ;
2021-04-17 04:18:13 +00:00
if ( VFO_HAS_MAIN_SUB_ONLY & & ! split & & ! satmode & & vfo ! = RIG_VFO_B ) { vfo = RIG_VFO_MAIN ; }
2020-06-12 13:28:05 +00:00
2021-04-17 04:18:13 +00:00
else if ( VFO_HAS_MAIN_SUB_ONLY & & ( split | | satmode | | vfo = = RIG_VFO_B ) ) { vfo = RIG_VFO_SUB ; }
2020-06-12 13:28:05 +00:00
2021-04-17 04:18:13 +00:00
else if ( VFO_HAS_MAIN_SUB_A_B_ONLY & & split ) { vfo = RIG_VFO_B ; }
2020-06-12 13:28:05 +00:00
2021-04-17 04:18:13 +00:00
else if ( VFO_HAS_MAIN_SUB_A_B_ONLY & & satmode ) { vfo = RIG_VFO_SUB ; }
2020-06-12 13:28:05 +00:00
2022-02-06 19:05:40 +00:00
else if ( VFO_HAS_A_B_ONLY ) { vfo = split ? RIG_VFO_B : RIG_VFO_A ; }
2020-06-12 13:28:05 +00:00
rig_debug ( RIG_DEBUG_TRACE ,
" %s: RIG_VFO_TX changed to %s, split=%d, satmode=%d \n " , __func__ ,
rig_strvfo ( vfo ) , split , satmode ) ;
}
2021-12-29 04:30:53 +00:00
else if ( vfo = = RIG_VFO_B | | vfo = = RIG_VFO_SUB )
2021-04-18 03:47:14 +00:00
{
2021-12-29 04:30:53 +00:00
vfo = RIG_VFO_B ; // default to VFO_B
2021-08-01 17:11:46 +00:00
if ( VFO_HAS_MAIN_SUB_ONLY ) { vfo = RIG_VFO_SUB ; }
2021-04-18 03:47:14 +00:00
}
2023-11-14 21:00:37 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: final vfo=%s \n " , __func__ , rig_strvfo ( vfo ) ) ;
2020-06-12 13:28:05 +00:00
return vfo ;
}
2022-02-05 21:27:43 +00:00
int HAMLIB_API parse_hoststr ( char * hoststr , int hoststr_len , char host [ 256 ] ,
char port [ 6 ] )
2020-06-21 22:47:04 +00:00
{
2020-06-22 04:16:05 +00:00
unsigned int net1 , net2 , net3 , net4 , net5 , net6 , net7 , net8 ;
2020-07-03 21:20:23 +00:00
char dummy [ 6 ] , link [ 32 ] , * p ;
2020-06-21 22:47:04 +00:00
host [ 0 ] = 0 ;
port [ 0 ] = 0 ;
dummy [ 0 ] = 0 ;
2021-01-17 14:22:07 +00:00
// Exclude any names that aren't a host:port format
2020-06-22 12:10:43 +00:00
// Handle device names 1st
2020-06-23 04:54:11 +00:00
if ( strstr ( hoststr , " /dev " ) ) { return - 1 ; }
2021-01-15 22:48:32 +00:00
2021-01-22 16:41:30 +00:00
if ( strstr ( hoststr , " / " ) ) { return - 1 ; } // probably a path so not a hoststr
2020-06-23 04:54:11 +00:00
if ( strncasecmp ( hoststr , " com " , 3 ) = = 0 ) { return - 1 ; }
2020-06-22 12:10:43 +00:00
2022-02-12 23:06:24 +00:00
// escaped COM port like \\.\COM3 or \.\COM3
if ( strstr ( hoststr , " \\ . \\ " ) ) { return - 1 ; }
2020-07-04 17:37:26 +00:00
2021-01-17 14:22:07 +00:00
// Now let's try and parse a host:port thing
2020-06-21 22:47:04 +00:00
// bracketed IPV6 with optional port
2020-06-22 03:31:31 +00:00
int n = sscanf ( hoststr , " [%255[^]]]:%5s " , host , port ) ;
2020-06-21 22:47:04 +00:00
if ( n > = 1 )
{
return RIG_OK ;
}
2020-06-22 04:16:05 +00:00
// non-bracketed full IPV6 with optional link addr
2020-06-22 12:10:43 +00:00
n = sscanf ( hoststr , " %x:%x:%x:%x:%x:%x:%x:%x%%%31[^:]:%5s " , & net1 , & net2 , & net3 ,
2020-06-22 04:16:05 +00:00
& net4 , & net5 , & net6 , & net7 , & net8 , link , port ) ;
2020-06-23 04:54:11 +00:00
2020-06-22 04:16:05 +00:00
if ( n = = 8 | | n = = 9 )
{
strcpy ( host , hoststr ) ;
return RIG_OK ;
}
else if ( n = = 10 )
{
strcpy ( host , hoststr ) ;
p = strrchr ( host , ' : ' ) ; // remove port from host
* p = 0 ;
return RIG_OK ;
}
2020-06-23 04:54:11 +00:00
2020-06-22 12:10:43 +00:00
// non-bracketed IPV6 with optional link addr and optional port
n = sscanf ( hoststr , " %x::%x:%x:%x:%x%%%31[^:]:%5s " , & net1 , & net2 , & net3 ,
2020-06-21 22:47:04 +00:00
& net4 , & net5 , link , port ) ;
if ( strchr ( hoststr , ' % ' ) & & ( n = = 5 | | n = = 6 ) )
{
strcpy ( host , hoststr ) ;
return RIG_OK ;
}
else if ( n = = 7 )
{
strcpy ( host , hoststr ) ;
p = strrchr ( host , ' : ' ) ; // remove port from host
* p = 0 ;
return RIG_OK ;
}
// non-bracketed IPV6 short form with optional port
n = sscanf ( hoststr , " %x::%x:%x:%x:%x:%5[0-9]%1s " , & net1 , & net2 , & net3 , & net4 ,
& net5 , port , dummy ) ;
if ( n = = 5 )
{
strcpy ( host , hoststr ) ;
return RIG_OK ;
}
else if ( n = = 6 )
{
strcpy ( host , hoststr ) ;
p = strrchr ( host , ' : ' ) ;
* p = 0 ;
return RIG_OK ;
}
else if ( n = = 7 )
{
return - RIG_EINVAL ;
}
// bracketed localhost
if ( strstr ( hoststr , " ::1 " ) )
{
2020-06-22 03:31:31 +00:00
n = sscanf ( hoststr , " ::1%5s " , dummy ) ;
2020-06-21 22:47:04 +00:00
strcpy ( host , hoststr ) ;
if ( n = = 1 )
{
p = strrchr ( host , ' : ' ) ;
* p = 0 ;
strcpy ( port , p + 1 ) ;
}
return RIG_OK ;
}
2020-07-03 21:20:23 +00:00
if ( sscanf ( hoststr , " :%5[0-9]%1s " , port ,
2020-06-28 17:17:24 +00:00
dummy ) = = 1 ) // just a port if you please
{
2022-01-19 15:11:04 +00:00
SNPRINTF ( hoststr , hoststr_len , " %s:%s \n " , " localhost " , port ) ;
2020-06-28 17:17:24 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s: hoststr=%s \n " , __func__ , hoststr ) ;
return RIG_OK ;
}
2020-06-21 22:47:04 +00:00
// if we're here then we must have a hostname
n = sscanf ( hoststr , " %255[^:]:%5[0-9]%1s " , host , port , dummy ) ;
if ( n > = 1 & & strlen ( dummy ) = = 0 ) { return RIG_OK ; }
printf ( " Unhandled host=%s \n " , hoststr ) ;
return - 1 ;
}
2020-06-12 13:28:05 +00:00
2023-05-12 21:04:37 +00:00
/**
* \ brief Force flush of rig communication data buffers .
* \ param port communication port
* \ param flush_async_data Flushes also asynchronous I / O pipes if non - zero .
* \ return status code
*
* This function should be used only in special cases like after handling raw command data from Hamlib clients .
* When asynchronous I / O is enabled , responses to raw commands may disrupt processing of all commands ,
* because the responses and up in the async I / O pipes .
*/
int HAMLIB_API rig_flush_force ( hamlib_port_t * port , int flush_async_data )
2020-06-23 04:54:11 +00:00
{
2023-05-10 17:53:18 +00:00
if ( port - > type . rig = = RIG_PORT_NONE )
{
return RIG_OK ;
}
2023-05-12 21:04:37 +00:00
// Flush also the async I/O pipes
if ( port - > asyncio & & flush_async_data )
2023-03-08 21:35:08 +00:00
{
2023-05-12 21:04:37 +00:00
port_flush_sync_pipes ( port ) ;
2023-03-08 21:35:08 +00:00
}
2021-05-27 14:01:48 +00:00
# ifndef RIG_FLUSH_REMOVE
2023-06-04 20:56:01 +00:00
// rig_debug(RIG_DEBUG_TRACE, "%s: called for %s device\n", __func__,
// port->type.rig == RIG_PORT_SERIAL ? "serial" : "network");
2020-06-23 13:27:45 +00:00
if ( port - > type . rig = = RIG_PORT_NETWORK
| | port - > type . rig = = RIG_PORT_UDP_NETWORK )
2020-06-23 04:54:11 +00:00
{
2020-06-23 13:27:45 +00:00
network_flush ( port ) ;
2020-06-23 04:54:11 +00:00
return RIG_OK ;
}
2020-06-23 13:27:45 +00:00
2020-06-23 14:01:46 +00:00
if ( port - > type . rig ! = RIG_PORT_SERIAL )
{
2020-06-28 17:17:24 +00:00
rig_debug ( RIG_DEBUG_WARN ,
" %s: Expected serial port type!! \n What is this rig? \n " , __func__ ) ;
2020-06-23 14:01:46 +00:00
}
2020-06-28 17:17:24 +00:00
2020-06-23 14:01:46 +00:00
return serial_flush ( port ) ; // we must be on serial port
2021-05-27 12:35:46 +00:00
# else
return RIG_OK ;
# endif
2020-06-23 04:54:11 +00:00
}
2023-05-12 21:04:37 +00:00
int HAMLIB_API rig_flush ( hamlib_port_t * port )
{
// Data should never be flushed when using async I/O
if ( port - > asyncio )
{
return RIG_OK ;
}
return rig_flush_force ( port , 0 ) ;
}
2020-12-03 19:40:34 +00:00
2021-08-21 20:48:02 +00:00
static const struct
2020-12-03 19:40:34 +00:00
{
rot_status_t status ;
const char * str ;
} rot_status_str [ ] =
{
{ ROT_STATUS_BUSY , " BUSY " } ,
{ ROT_STATUS_MOVING , " MOVING " } ,
{ ROT_STATUS_MOVING_AZ , " MOVING_AZ " } ,
{ ROT_STATUS_MOVING_LEFT , " MOVING_LEFT " } ,
{ ROT_STATUS_MOVING_RIGHT , " MOVING_RIGHT " } ,
{ ROT_STATUS_MOVING_EL , " MOVING_EL " } ,
{ ROT_STATUS_MOVING_UP , " MOVING_UP " } ,
{ ROT_STATUS_MOVING_DOWN , " MOVING_DOWN " } ,
{ ROT_STATUS_LIMIT_UP , " LIMIT_UP " } ,
{ ROT_STATUS_LIMIT_DOWN , " LIMIT_DOWN " } ,
{ ROT_STATUS_LIMIT_LEFT , " LIMIT_LEFT " } ,
{ ROT_STATUS_LIMIT_RIGHT , " LIMIT_RIGHT " } ,
{ ROT_STATUS_OVERLAP_UP , " OVERLAP_UP " } ,
{ ROT_STATUS_OVERLAP_DOWN , " OVERLAP_DOWN " } ,
{ ROT_STATUS_OVERLAP_LEFT , " OVERLAP_LEFT " } ,
{ ROT_STATUS_OVERLAP_RIGHT , " OVERLAP_RIGHT " } ,
{ 0xffffff , " " } ,
} ;
/**
* \ brief Convert enum ROT_STATUS_ . . . to a string
* \ param status ROT_STATUS_ . . .
* \ return the corresponding string value
*/
const char * HAMLIB_API rot_strstatus ( rot_status_t status )
{
int i ;
for ( i = 0 ; rot_status_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
{
if ( status = = rot_status_str [ i ] . status )
{
return rot_status_str [ i ] . str ;
}
}
return " " ;
}
2021-01-01 05:05:54 +00:00
/**
* \ brief Get pointer to rig function instead of using rig - > caps
* \ param RIG * and rig_function_e
* \ return the corresponding function pointer
*/
2021-04-13 13:19:48 +00:00
void * HAMLIB_API rig_get_function_ptr ( rig_model_t rig_model ,
enum rig_function_e rig_function )
2021-01-01 05:05:54 +00:00
{
2021-01-02 15:22:02 +00:00
const struct rig_caps * caps = rig_get_caps ( rig_model ) ;
2023-11-12 04:21:38 +00:00
if ( caps = = NULL )
{
2023-12-16 17:37:58 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: caps == null for model %d?? \n " , __func__ ,
rig_model ) ;
2023-11-12 04:21:38 +00:00
return NULL ;
}
2021-01-01 05:05:54 +00:00
switch ( rig_function )
{
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_INIT :
2021-01-02 15:22:02 +00:00
return caps - > rig_init ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_CLEANUP :
2021-01-02 15:22:02 +00:00
return caps - > rig_cleanup ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_OPEN :
2021-01-02 15:22:02 +00:00
return caps - > rig_open ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_CLOSE :
2021-01-02 15:22:02 +00:00
return caps - > rig_close ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_FREQ :
2021-01-02 15:22:02 +00:00
return caps - > set_freq ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_FREQ :
2021-01-02 15:22:02 +00:00
return caps - > get_freq ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_MODE :
2021-01-02 15:22:02 +00:00
return caps - > set_mode ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_MODE :
2021-01-02 15:22:02 +00:00
return caps - > get_mode ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_VFO :
2021-01-02 15:22:02 +00:00
return caps - > set_vfo ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_VFO :
2021-01-02 15:22:02 +00:00
return caps - > get_vfo ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_PTT :
2021-01-02 15:22:02 +00:00
return caps - > set_ptt ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_PTT :
2021-01-02 15:22:02 +00:00
return caps - > get_ptt ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_DCD :
2021-01-02 15:22:02 +00:00
return caps - > get_dcd ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_RPTR_SHIFT :
2021-01-02 15:22:02 +00:00
return caps - > set_rptr_shift ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_RPTR_SHIFT :
2021-01-02 15:22:02 +00:00
return caps - > get_rptr_shift ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_RPTR_OFFS :
2021-01-02 15:22:02 +00:00
return caps - > set_rptr_offs ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_RPTR_OFFS :
2021-01-02 15:22:02 +00:00
return caps - > get_rptr_offs ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_SPLIT_FREQ :
2021-01-02 15:22:02 +00:00
return caps - > set_split_freq ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_SPLIT_FREQ :
2021-01-02 15:22:02 +00:00
return caps - > get_split_freq ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_SPLIT_MODE :
2021-01-02 15:22:02 +00:00
return caps - > set_split_mode ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_SPLIT_FREQ_MODE :
2021-01-02 15:22:02 +00:00
return caps - > set_split_freq_mode ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_SPLIT_FREQ_MODE :
2021-01-02 15:22:02 +00:00
return caps - > get_split_freq_mode ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_SPLIT_VFO :
2021-01-02 15:22:02 +00:00
return caps - > set_split_vfo ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_SPLIT_VFO :
2021-01-02 15:22:02 +00:00
return caps - > get_split_vfo ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_RIT :
2021-01-02 15:22:02 +00:00
return caps - > set_rit ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_RIT :
2021-01-02 15:22:02 +00:00
return caps - > get_rit ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_XIT :
2021-01-02 15:22:02 +00:00
return caps - > set_xit ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_XIT :
2021-01-02 15:22:02 +00:00
return caps - > get_xit ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_TS :
2021-01-02 15:22:02 +00:00
return caps - > set_ts ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_TS :
2021-01-02 15:22:02 +00:00
return caps - > get_ts ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_DCS_CODE :
2021-01-02 15:22:02 +00:00
return caps - > set_dcs_code ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_DCS_CODE :
2021-01-02 15:22:02 +00:00
return caps - > get_dcs_code ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_TONE :
2021-01-02 15:22:02 +00:00
return caps - > set_tone ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_TONE :
2021-01-02 15:22:02 +00:00
return caps - > get_tone ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_CTCSS_TONE :
2021-01-02 15:22:02 +00:00
return caps - > set_ctcss_tone ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_CTCSS_TONE :
2021-01-02 15:22:02 +00:00
return caps - > get_ctcss_tone ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_DCS_SQL :
2021-01-02 15:22:02 +00:00
return caps - > set_dcs_sql ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_DCS_SQL :
2021-01-02 15:22:02 +00:00
return caps - > get_dcs_sql ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_TONE_SQL :
2021-01-02 15:22:02 +00:00
return caps - > set_tone_sql ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_TONE_SQL :
2021-01-02 15:22:02 +00:00
return caps - > get_tone_sql ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_CTCSS_SQL :
2021-01-02 15:22:02 +00:00
return caps - > set_ctcss_sql ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_CTCSS_SQL :
2021-01-02 15:22:02 +00:00
return caps - > get_ctcss_sql ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_POWER2MW :
2021-01-02 15:22:02 +00:00
return caps - > power2mW ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_MW2POWER :
2021-01-02 15:22:02 +00:00
return caps - > mW2power ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_POWERSTAT :
2021-01-02 15:22:02 +00:00
return caps - > set_powerstat ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_POWERSTAT :
2021-01-02 15:22:02 +00:00
return caps - > get_powerstat ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_RESET :
2021-01-02 15:22:02 +00:00
return caps - > reset ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_ANT :
2021-01-02 15:22:02 +00:00
return caps - > set_ant ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_ANT :
2021-01-02 15:22:02 +00:00
return caps - > get_ant ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_LEVEL :
2021-01-02 15:22:02 +00:00
return caps - > set_level ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_LEVEL :
2021-01-02 15:22:02 +00:00
return caps - > get_level ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_FUNC :
2021-01-02 15:22:02 +00:00
return caps - > set_func ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_FUNC :
2021-01-02 15:22:02 +00:00
return caps - > get_func ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_PARM :
2021-01-02 15:22:02 +00:00
return caps - > set_parm ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_PARM :
2021-01-02 15:22:02 +00:00
return caps - > get_parm ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_EXT_LEVEL :
2021-01-02 15:22:02 +00:00
return caps - > set_ext_level ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_EXT_LEVEL :
2021-01-02 15:22:02 +00:00
return caps - > get_ext_level ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_EXT_FUNC :
2021-01-02 15:22:02 +00:00
return caps - > set_ext_func ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_EXT_FUNC :
2021-01-02 15:22:02 +00:00
return caps - > get_ext_func ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_EXT_PARM :
2021-01-02 15:22:02 +00:00
return caps - > set_ext_parm ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_EXT_PARM :
2021-01-02 15:22:02 +00:00
return caps - > get_ext_parm ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_CONF :
2021-01-02 15:22:02 +00:00
return caps - > set_conf ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_CONF :
2021-01-02 15:22:02 +00:00
return caps - > get_conf ;
2021-01-01 05:05:54 +00:00
2022-01-10 14:48:08 +00:00
case RIG_FUNCTION_GET_CONF2 :
return caps - > get_conf2 ;
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SEND_DTMF :
2021-01-02 15:22:02 +00:00
return caps - > send_dtmf ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SEND_MORSE :
2021-01-02 15:22:02 +00:00
return caps - > send_morse ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_STOP_MORSE :
2021-01-02 15:22:02 +00:00
return caps - > stop_morse ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_WAIT_MORSE :
2021-01-02 15:22:02 +00:00
return caps - > wait_morse ;
2021-01-01 05:05:54 +00:00
2021-12-19 23:30:24 +00:00
case RIG_FUNCTION_SEND_VOICE_MEM :
return caps - > send_voice_mem ;
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_BANK :
2021-01-02 15:22:02 +00:00
return caps - > set_bank ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_MEM :
2021-01-02 15:22:02 +00:00
return caps - > set_mem ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_MEM :
2021-01-02 15:22:02 +00:00
return caps - > get_mem ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_VFO_OP :
2021-01-02 15:22:02 +00:00
return caps - > vfo_op ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SCAN :
2021-01-02 15:22:02 +00:00
return caps - > scan ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_TRN :
2021-01-02 15:22:02 +00:00
return caps - > set_trn ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_TRN :
2021-01-02 15:22:02 +00:00
return caps - > get_trn ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_DECODE_EVENT :
2021-01-02 15:22:02 +00:00
return caps - > decode_event ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_CHANNEL :
2021-01-02 15:22:02 +00:00
return caps - > set_channel ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_CHANNEL :
2021-01-02 15:22:02 +00:00
return caps - > get_channel ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_INFO :
2021-01-02 15:22:02 +00:00
return caps - > get_info ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_CHAN_ALL_CB :
2021-01-02 15:22:02 +00:00
return caps - > set_chan_all_cb ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_CHAN_ALL_CB :
2021-01-02 15:22:02 +00:00
return caps - > get_chan_all_cb ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_MEM_ALL_CB :
2021-01-02 15:22:02 +00:00
return caps - > set_mem_all_cb ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_GET_MEM_ALL_CB :
2021-01-02 15:22:02 +00:00
return caps - > get_mem_all_cb ;
2021-01-01 05:05:54 +00:00
2021-01-01 05:39:05 +00:00
case RIG_FUNCTION_SET_VFO_OPT :
2021-01-02 15:22:02 +00:00
return caps - > set_vfo_opt ;
2021-01-01 05:05:54 +00:00
2021-11-28 18:52:29 +00:00
case RIG_FUNCTION_READ_FRAME_DIRECT :
return caps - > read_frame_direct ;
case RIG_FUNCTION_IS_ASYNC_FRAME :
return caps - > is_async_frame ;
case RIG_FUNCTION_PROCESS_ASYNC_FRAME :
return caps - > process_async_frame ;
2021-01-01 05:05:54 +00:00
default :
rig_debug ( RIG_DEBUG_ERR , " Unknown function?? function=%d \n " , rig_function ) ;
}
2021-01-10 20:39:39 +00:00
return NULL ;
2021-01-01 05:05:54 +00:00
}
2021-01-10 20:39:39 +00:00
// negative return indicates error
2021-02-07 18:45:59 +00:00
/**
* \ brief Get integer / long instead of using rig - > caps
* watch out for integer values that may be negative - - if needed must change hamlib
* \ param RIG * and rig_caps_int_e
* \ return the corresponding long value - - - RIG_EINVAL is the only error possible
*/
2023-11-16 15:05:29 +00:00
uint64_t HAMLIB_API rig_get_caps_int ( rig_model_t rig_model ,
2023-12-16 17:37:58 +00:00
enum rig_caps_int_e rig_caps )
2021-01-01 16:59:36 +00:00
{
2021-01-02 15:22:02 +00:00
const struct rig_caps * caps = rig_get_caps ( rig_model ) ;
2023-05-22 14:10:42 +00:00
#if 0
2023-05-22 13:47:01 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: getting rig_caps for model=%d, rig_caps=%d \n " ,
__func__ , rig_model , rig_caps ) ;
2023-05-22 14:10:42 +00:00
# endif
2023-05-22 13:47:01 +00:00
if ( caps = = NULL )
{
2023-05-22 14:10:42 +00:00
#if 0
2023-05-22 13:47:01 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: called with NULL caps...returning -1 \n " ,
__func__ ) ;
2023-05-22 14:10:42 +00:00
# endif
2023-05-22 13:47:01 +00:00
return - 1 ;
}
2021-01-02 15:22:02 +00:00
2021-01-01 16:59:36 +00:00
switch ( rig_caps )
{
case RIG_CAPS_TARGETABLE_VFO :
2021-01-02 15:22:02 +00:00
return caps - > targetable_vfo ;
2021-01-01 16:59:36 +00:00
case RIG_CAPS_RIG_MODEL :
2021-01-02 15:22:02 +00:00
return caps - > rig_model ;
2021-01-01 16:59:36 +00:00
case RIG_CAPS_PTT_TYPE :
2023-05-22 14:10:42 +00:00
#if 0
2023-05-21 14:45:57 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s: return %u \n " , __func__ , caps - > ptt_type ) ;
2023-05-22 14:10:42 +00:00
# endif
2021-01-02 15:22:02 +00:00
return caps - > ptt_type ;
2021-01-01 16:59:36 +00:00
case RIG_CAPS_PORT_TYPE :
2021-01-02 15:22:02 +00:00
return caps - > port_type ;
2021-01-01 16:59:36 +00:00
2021-02-07 12:56:48 +00:00
case RIG_CAPS_HAS_GET_LEVEL :
2023-12-16 17:37:58 +00:00
rig_debug ( RIG_DEBUG_TRACE , " %s(%d): return %08 " PRIll " \n " , __func__ , __LINE__ ,
caps - > has_get_level ) ;
2021-02-07 12:56:48 +00:00
return caps - > has_get_level ;
2021-01-01 16:59:36 +00:00
default :
2023-05-22 14:10:42 +00:00
#if 0
2023-05-21 15:15:22 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: Unknown rig_caps value=%d \n " , __func__ , rig_caps ) ;
2023-05-22 14:10:42 +00:00
# endif
2022-02-05 21:27:43 +00:00
return ( - RIG_EINVAL ) ;
2021-01-01 16:59:36 +00:00
}
}
2021-04-13 13:19:48 +00:00
const char * HAMLIB_API rig_get_caps_cptr ( rig_model_t rig_model ,
enum rig_caps_cptr_e rig_caps )
2021-01-01 16:59:36 +00:00
{
2021-01-02 15:22:02 +00:00
const struct rig_caps * caps = rig_get_caps ( rig_model ) ;
2023-05-22 13:47:01 +00:00
if ( caps = = NULL )
{
2023-05-22 14:10:42 +00:00
// rig_debug(RIG_DEBUG_ERR, "%s: called with NULL caps...returning NULL\n",
// __func__);
2023-05-22 13:47:01 +00:00
return NULL ;
}
2021-01-01 16:59:36 +00:00
switch ( rig_caps )
{
2021-01-01 21:12:31 +00:00
case RIG_CAPS_VERSION_CPTR :
2021-01-02 15:22:02 +00:00
return caps - > version ;
2021-01-01 05:05:54 +00:00
2021-01-01 21:12:31 +00:00
case RIG_CAPS_MFG_NAME_CPTR :
2021-01-02 15:22:02 +00:00
return caps - > mfg_name ;
2021-01-01 16:59:36 +00:00
2021-01-01 21:12:31 +00:00
case RIG_CAPS_MODEL_NAME_CPTR :
2021-01-02 15:22:02 +00:00
return caps - > model_name ;
2021-01-01 16:59:36 +00:00
2021-01-03 15:16:20 +00:00
case RIG_CAPS_STATUS_CPTR :
return rig_strstatus ( caps - > status ) ;
2021-01-01 16:59:36 +00:00
default :
2023-05-22 14:10:42 +00:00
#if 0
2021-01-09 16:13:17 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: Unknown requested rig_caps value=%d \n " , __func__ ,
rig_caps ) ;
2023-05-22 14:10:42 +00:00
# endif
2021-01-01 16:59:36 +00:00
return " Unknown caps value " ;
}
}
2020-12-03 19:40:34 +00:00
2023-11-05 22:42:02 +00:00
static const struct
{
rig_comm_status_t status ;
const char * str ;
} comm_status_str [ ] =
{
{ RIG_COMM_STATUS_OK , " OK " } ,
{ RIG_COMM_STATUS_CONNECTING , " CONNECTING " } ,
{ RIG_COMM_STATUS_DISCONNECTED , " DISCONNECTED " } ,
{ RIG_COMM_STATUS_TERMINATED , " TERMINATIED " } ,
{ RIG_COMM_STATUS_WARNING , " WARNING " } ,
{ RIG_COMM_STATUS_ERROR , " ERROR " } ,
{ 0xffffffff , " " } ,
} ;
/**
* \ brief Convert enum RIG_COMM_STATUS . . . to alpha string
* \ param vfo RIG_COMM_STATUS_ . . .
* \ return alpha string
*/
const char * HAMLIB_API rig_strcommstatus ( rig_comm_status_t status )
{
int i ;
for ( i = 0 ; comm_status_str [ i ] . str [ 0 ] ! = ' \0 ' ; i + + )
{
if ( status = = comm_status_str [ i ] . status )
{
return comm_status_str [ i ] . str ;
}
}
return " " ;
}
2021-01-17 13:25:28 +00:00
void errmsg ( int err , char * s , const char * func , const char * file , int line )
{
rig_debug ( RIG_DEBUG_ERR , " %s(%s:%d): %s: %s \b " , __func__ , file , line , s ,
rigerror ( err ) ) ;
}
2021-04-18 03:47:14 +00:00
uint32_t CRC32_function ( uint8_t * buf , uint32_t len )
{
2021-09-11 16:04:13 +00:00
uint32_t crc ;
2021-04-18 03:47:14 +00:00
uint8_t i ;
crc = 0xFFFFFFFF ;
while ( len - - )
{
2021-09-11 16:04:13 +00:00
uint32_t val ;
2021-04-18 03:47:14 +00:00
val = ( crc ^ * buf + + ) & 0xFF ;
for ( i = 0 ; i < 8 ; i + + )
{
val = val & 1 ? ( val > > 1 ) ^ 0xEDB88320 : val > > 1 ;
}
crc = val ^ crc > > 8 ;
}
return crc ^ 0xFFFFFFFF ;
}
2021-09-02 22:08:10 +00:00
# if defined(_WIN32)
// gmtime_r can be defined by mingw
# ifndef gmtime_r
static struct tm * gmtime_r ( const time_t * t , struct tm * r )
{
// gmtime is threadsafe in windows because it uses TLS
2023-10-12 04:22:42 +00:00
const struct tm * theTm = gmtime ( t ) ;
2021-09-02 22:08:10 +00:00
if ( theTm )
{
* r = * theTm ;
return r ;
}
else
{
return 0 ;
}
}
# endif // gmtime_r
# endif // _WIN32
2021-05-21 17:33:42 +00:00
//! @cond Doxygen_Suppress
2021-12-06 16:23:18 +00:00
char * date_strget ( char * buf , int buflen , int localtime )
2021-05-21 17:33:42 +00:00
{
2021-12-06 16:23:18 +00:00
char tmpbuf [ 64 ] ;
2021-05-21 17:33:42 +00:00
struct tm * mytm ;
time_t t ;
struct timeval tv ;
2023-12-16 17:37:58 +00:00
struct tm result = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 } ;
2021-12-06 17:57:45 +00:00
int mytimezone ;
2021-12-06 17:43:22 +00:00
2021-05-21 17:33:42 +00:00
t = time ( NULL ) ;
2021-12-06 16:23:18 +00:00
if ( localtime )
{
mytm = localtime_r ( & t , & result ) ;
2021-12-06 17:57:45 +00:00
mytimezone = timezone ;
2021-12-06 16:23:18 +00:00
}
else
{
mytm = gmtime_r ( & t , & result ) ;
2021-12-06 17:57:45 +00:00
mytimezone = 0 ;
2021-12-06 16:23:18 +00:00
}
2021-12-06 17:50:30 +00:00
strftime ( buf , buflen , " %Y-%m-%dT%H:%M:%S. " , mytm ) ;
2021-05-21 17:33:42 +00:00
gettimeofday ( & tv , NULL ) ;
2022-01-19 15:11:04 +00:00
SNPRINTF ( tmpbuf , sizeof ( tmpbuf ) , " %06ld " , ( long ) tv . tv_usec ) ;
2021-12-06 16:23:18 +00:00
strcat ( buf , tmpbuf ) ;
2022-01-19 15:11:04 +00:00
SNPRINTF ( tmpbuf , sizeof ( tmpbuf ) , " %s%04d " , mytimezone > = 0 ? " - " : " + " ,
2021-12-10 14:39:16 +00:00
( ( int ) abs ( mytimezone ) / 3600 ) * 100 ) ;
2021-12-06 16:23:18 +00:00
strcat ( buf , tmpbuf ) ;
2021-05-21 17:33:42 +00:00
return buf ;
}
2023-05-22 14:32:04 +00:00
char * rig_date_strget ( char * buf , int buflen , int localtime )
{
2023-12-16 17:37:58 +00:00
return date_strget ( buf , buflen , localtime ) ;
2023-05-22 14:32:04 +00:00
}
2024-01-11 13:03:16 +00:00
const char * spaces ( int len )
2022-01-31 05:37:01 +00:00
{
2024-01-11 13:03:16 +00:00
static char s [ 256 ] ;
memset ( s , ' * ' , sizeof ( s ) ) ;
if ( len > 255 )
{
len = 0 ;
}
if ( len > 0 )
{
s [ len + 1 ] = 0 ;
}
else
{
s [ 1 ] = 0 ;
}
2022-01-31 05:37:01 +00:00
return s ;
}
2023-08-11 15:40:42 +00:00
// if which==0 rig_band_select str will be returned
// if which!=0 the rig_parm_gran band str will be returne
2023-12-16 17:37:58 +00:00
const char * rig_get_band_str ( RIG * rig , hamlib_band_t band , int which )
2023-08-11 15:40:42 +00:00
{
int i ;
if ( which = = 0 )
{
2024-01-11 13:03:16 +00:00
for ( i = 0 ; rig_bandselect_str [ i ] . str ! = NULL ; i + + )
2023-08-11 15:40:42 +00:00
{
2023-12-16 17:37:58 +00:00
if ( rig_bandselect_str [ i ] . bandselect = = band )
{
return rig_bandselect_str [ i ] . str ;
}
2023-08-11 15:40:42 +00:00
}
}
else
{
char bandlist [ 512 ] ;
2023-12-16 17:37:58 +00:00
rig_sprintf_parm_gran ( bandlist , sizeof ( bandlist ) - 1 , RIG_PARM_BANDSELECT ,
rig - > caps - > parm_gran ) ;
2023-08-11 15:40:42 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s: bandlist=%s \n " , __func__ , bandlist ) ;
int n = 0 ;
2023-12-16 17:37:58 +00:00
char * p = strchr ( bandlist , ' ( ' ) + 1 ;
2023-08-11 15:40:42 +00:00
char * token ;
2023-12-16 17:37:58 +00:00
2023-08-11 15:40:42 +00:00
if ( p = = NULL )
{
2023-12-16 17:37:58 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: unable to find open paren in '%s' \n " , __func__ ,
bandlist ) ;
2023-08-11 15:40:42 +00:00
return 0 ;
}
2023-12-16 17:37:58 +00:00
while ( ( token = strtok_r ( p , " , " , & p ) ) )
2023-08-11 15:40:42 +00:00
{
2023-12-16 17:37:58 +00:00
if ( n = = band )
2023-08-11 15:40:42 +00:00
{
2024-01-11 13:03:16 +00:00
for ( i = 0 ; rig_bandselect_str [ i ] . str ! = NULL ; i + + )
2023-08-11 15:40:42 +00:00
{
2023-12-16 17:37:58 +00:00
if ( strcmp ( rig_bandselect_str [ i ] . str , token ) = = 0 )
2023-08-11 15:40:42 +00:00
{
return rig_bandselect_str [ i ] . str ;
}
}
}
2023-12-16 17:37:58 +00:00
2023-08-11 15:40:42 +00:00
n + + ;
}
}
2023-12-16 17:37:58 +00:00
2023-08-11 15:40:42 +00:00
return " BANDGEN " ;
}
// If freq==0 looks up using the band index (which is the rig's band reference index)
// So you call for the rigs' band select value, pass it in and get back the hamlib_band_t
// Then use rig_get_band_str to get the abstract band name
// returns the rig's backend hamlib_band_t that can used to lookup the band str
hamlib_band_t rig_get_band ( RIG * rig , freq_t freq , int band )
{
int i ;
rig_debug ( RIG_DEBUG_VERBOSE , " %s called \n " , __func__ ) ;
2023-12-16 17:37:58 +00:00
if ( freq = = 0 )
2023-08-11 15:40:42 +00:00
{
char bandlist [ 512 ] ;
2023-12-16 17:37:58 +00:00
rig_sprintf_parm_gran ( bandlist , sizeof ( bandlist ) - 1 , RIG_PARM_BANDSELECT ,
rig - > caps - > parm_gran ) ;
2023-08-11 15:40:42 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s: bandlist=%s \n " , __func__ , bandlist ) ;
// e.g. BANDSELECT(BAND160M,BAND80M,BANDUNUSED,BAND40M)
2023-12-16 17:37:58 +00:00
char * p = strchr ( bandlist , ' ( ' ) + 1 ;
2023-08-11 15:40:42 +00:00
char * token ;
2023-12-16 17:37:58 +00:00
2023-08-11 15:40:42 +00:00
if ( p = = NULL )
{
2023-12-16 17:37:58 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: unable to find open paren in '%s' \n " , __func__ ,
bandlist ) ;
2023-08-11 15:40:42 +00:00
return 0 ;
}
2023-12-16 17:37:58 +00:00
2023-08-11 15:40:42 +00:00
int n = 0 ;
2023-12-16 17:37:58 +00:00
while ( ( token = strtok_r ( p , " , " , & p ) ) )
2023-08-11 15:40:42 +00:00
{
2023-12-16 17:37:58 +00:00
if ( n = = band ) { return rig_bandselect_str [ n ] . bandselect ; }
2023-08-11 15:40:42 +00:00
n + + ;
}
2023-12-12 18:11:31 +00:00
return RIG_BAND_UNUSED ;
2023-08-11 15:40:42 +00:00
}
2023-12-16 17:37:58 +00:00
2024-01-11 13:03:16 +00:00
for ( i = 0 ; rig_bandselect_str [ i ] . str ! = NULL ; i + + )
2023-08-11 15:40:42 +00:00
{
if ( freq > = rig_bandselect_str [ i ] . start & & freq < = rig_bandselect_str [ i ] . stop )
{
return rig_bandselect_str [ i ] . bandselect ;
}
}
2023-12-12 18:11:31 +00:00
return RIG_BAND_UNUSED ;
2023-08-11 15:40:42 +00:00
}
2022-01-31 05:37:01 +00:00
2023-08-11 15:40:42 +00:00
// Gets the rig's band index from the hamlib_band_t
int rig_get_band_rig ( RIG * rig , freq_t freq , const char * band )
{
char bandlist [ 512 ] ;
int i ;
2023-12-16 17:37:58 +00:00
2024-01-11 13:03:16 +00:00
if ( freq = = 0 & & band = = NULL )
{
rig_debug ( RIG_DEBUG_ERR , " %s: bad combo of freq==0 && band==NULL \n " , __func__ ) ;
return RIG_BAND_GEN ;
}
2023-08-11 15:40:42 +00:00
if ( freq = = 0 )
{
2024-02-04 05:23:25 +00:00
bandlist [ 0 ] = 0 ;
2023-12-16 17:37:58 +00:00
rig_sprintf_parm_gran ( bandlist , sizeof ( bandlist ) - 1 , RIG_PARM_BANDSELECT ,
rig - > caps - > parm_gran ) ;
2023-08-11 15:40:42 +00:00
rig_debug ( RIG_DEBUG_VERBOSE , " %s: bandlist=%s \n " , __func__ , bandlist ) ;
2024-01-11 13:03:16 +00:00
2023-08-11 15:40:42 +00:00
// e.g. BANDSELECT(BAND160M,BAND80M,BANDUNUSED,BAND40M)
2024-01-11 13:03:16 +00:00
if ( strlen ( bandlist ) = = 0 )
{
rig_debug ( RIG_DEBUG_ERR , " %s: rig does not have bandlist \n " , __func__ ) ;
2024-01-11 13:15:19 +00:00
return RIG_BAND_GEN ;
2024-01-11 13:03:16 +00:00
}
2023-12-16 17:37:58 +00:00
char * p = strchr ( bandlist , ' ( ' ) + 1 ;
2023-08-11 15:40:42 +00:00
char * token ;
2023-12-16 17:37:58 +00:00
2023-08-11 15:40:42 +00:00
if ( p = = NULL )
{
2023-12-16 17:37:58 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: unable to find open paren in '%s' \n " , __func__ ,
bandlist ) ;
2023-08-11 15:40:42 +00:00
return 0 ;
}
2023-12-16 17:37:58 +00:00
2023-08-11 15:40:42 +00:00
int n = 0 ;
2023-12-16 17:37:58 +00:00
while ( ( token = strtok_r ( p , " , " , & p ) ) )
2023-08-11 15:40:42 +00:00
{
2023-12-16 17:37:58 +00:00
if ( strcmp ( token , band ) = = 0 ) { return n ; }
2023-08-11 15:40:42 +00:00
n + + ;
}
2023-12-16 17:37:58 +00:00
2023-08-11 15:40:42 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: unknown band %s \n " , __func__ , band ) ;
return 0 ;
}
2023-12-16 17:37:58 +00:00
2024-01-11 13:03:16 +00:00
for ( i = 0 ; rig_bandselect_str [ i ] . str ! = NULL ; i + + )
2023-08-11 15:40:42 +00:00
{
if ( freq > = rig_bandselect_str [ i ] . start & & freq < = rig_bandselect_str [ i ] . stop )
{
// now we know the hamlib_band_t so we can look it up now
// this is 1-time recursive
return rig_get_band_rig ( rig , 0.0 , rig_bandselect_str [ i ] . str ) ;
}
}
2023-12-16 17:37:58 +00:00
rig_debug ( RIG_DEBUG_ERR , " %s: unable to find band=%s, freq=%f \n " , __func__ ,
band , freq ) ;
2023-08-11 15:40:42 +00:00
return 0 ; // just give a value for now of the 1st band -- this should be an error
}
2021-01-17 13:25:28 +00:00
2024-01-24 21:48:05 +00:00
// Returns RIG_OK if 2038 time routines pass tests
int rig_test_2038 ( RIG * rig )
{
time_t x ;
2024-02-12 16:48:07 +00:00
# if defined(_TIME_BITS)
# if defined(__GLIBC_MINOR__)
rig_debug ( RIG_DEBUG_TRACE , " %s: enter _TIME_BITS=%d, __TIMESIZE=%d testing enabled for GLIBC %d.%d \n " , __func__ , _TIME_BITS , __TIMESIZE , __GLIBC__ , __GLIBC_MINOR__ ) ;
# else
rig_debug ( RIG_DEBUG_TRACE , " %s: enter _TIME_BITS=64 testing enabled for unknown libc \n " , __func__ ) ;
# endif
2024-02-07 18:27:12 +00:00
# else
rig_debug ( RIG_DEBUG_TRACE , " %s: enter _TIME_BITS=64 testing not enabled \n " , __func__ ) ;
# endif
2024-01-29 13:52:56 +00:00
if ( sizeof ( time_t ) = = 4 )
{
rig_debug ( RIG_DEBUG_TRACE , " %s: ctime is null, 2038 test failed \n " , __func__ ) ;
2024-01-30 17:02:05 +00:00
return 1 ;
2024-01-29 13:52:56 +00:00
}
2024-01-24 21:48:05 +00:00
x = ( time_t ) ( ( 1U < < 31 ) - 1 ) ;
char * s = ctime ( & x ) ;
2024-01-28 15:46:09 +00:00
if ( s = = NULL )
{
rig_debug ( RIG_DEBUG_TRACE , " %s: ctime is null, 2038 test failed \n " , __func__ ) ;
return 1 ;
}
2024-01-29 13:52:56 +00:00
2024-01-24 21:48:05 +00:00
if ( ! strstr ( s , " 2038 " ) ) { return 1 ; }
x + = 1 ;
s = ctime ( & x ) ;
if ( ! strstr ( s , " 2038 " ) ) { return 1 ; }
x + = 1 ;
s = ctime ( & x ) ;
if ( ! strstr ( s , " 2038 " ) ) { return 1 ; }
return 0 ;
}
2020-04-09 22:56:19 +00:00
//! @endcond
2013-09-08 13:56:28 +00:00
2020-06-23 13:27:45 +00:00
/** @} */