1 /* 2 * Hamlib Interface - API header 3 * Copyright (c) 2000-2003 by Frank Singleton 4 * Copyright (c) 2000-2012 by Stephane Fillod 5 * 6 * 7 * This library is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation; either 10 * version 2.1 of the License, or (at your option) any later version. 11 * 12 * This library is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with this library; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 * 21 */ 22 23 24 #ifndef _RIG_H 25 #define _RIG_H 1 26 27 #define __FILENAME__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__) 28 29 #include <stdio.h> 30 #include <stdarg.h> 31 #include <string.h> 32 #include <inttypes.h> 33 #include <time.h> 34 35 /* Rig list is in a separate file so as not to mess up w/ this one */ 36 #include <hamlib/riglist.h> 37 38 /** 39 * \addtogroup rig 40 * @{ 41 */ 42 43 /*! \file rig.h 44 * \brief Hamlib rig data structures. 45 * 46 * This file contains the data structures and definitions for the Hamlib rig API. 47 * see the rig.c file for more details on the rig API. 48 */ 49 50 51 /* __BEGIN_DECLS should be used at the beginning of your declarations, 52 * so that C++ compilers don't mangle their names. Use __END_DECLS at 53 * the end of C declarations. */ 54 //! @cond Doxygen_Suppress 55 #undef __BEGIN_DECLS 56 #undef __END_DECLS 57 #ifdef __cplusplus 58 # define __BEGIN_DECLS extern "C" { 59 # define __END_DECLS } 60 #else 61 # define __BEGIN_DECLS /* empty */ 62 # define __END_DECLS /* empty */ 63 #endif 64 //! @endcond 65 66 /* HAMLIB_PARAMS is a macro used to wrap function prototypes, so that compilers 67 * that don't understand ANSI C prototypes still work, and ANSI C 68 * compilers can issue warnings about type mismatches. */ 69 //! @cond Doxygen_Suppress 70 #undef HAMLIB_PARAMS 71 #if defined (__STDC__) \ 72 || defined (_AIX) \ 73 || (defined (__mips) && defined (_SYSTYPE_SVR4)) \ 74 || defined(__CYGWIN__) \ 75 || defined(_WIN32) \ 76 || defined(__cplusplus) 77 # define HAMLIB_PARAMS(protos) protos 78 # define rig_ptr_t void * 79 # define amp_ptr_t void * 80 #else 81 # define HAMLIB_PARAMS(protos) () 82 # define rig_ptr_t char * 83 # define amp_ptr_t char * 84 #endif 85 //! @endcond 86 87 #include <hamlib/rig_dll.h> 88 89 #ifndef SWIGLUA 90 //! @cond Doxygen_Suppress 91 #define CONSTANT_64BIT_FLAG(BIT) (1ull << (BIT)) 92 //! @endcond 93 #else 94 /* SWIG's older Lua generator doesn't grok ull due to Lua using a 95 double-precision floating point type internally for number 96 representations (max 53 bits of precision) so makes a string 97 constant from a constant number literal using ull */ 98 // #define CONSTANT_64BIT_FLAG(BIT) (1 << (BIT)) 99 // #define SWIGLUAHIDE 100 /* But this appears to have been fixed so we'll use the correct one now 101 If you have the older version of SWIG comment out this line and use 102 the two above */ 103 // This 1ul definition works on swig 4.0.1 and lua 5.3.5 104 #define CONSTANT_64BIT_FLAG(BIT) (1ul << (BIT)) 105 #endif 106 107 __BEGIN_DECLS 108 109 //! @cond Doxygen_Suppress 110 extern HAMLIB_EXPORT_VAR(const char) hamlib_version[]; 111 extern HAMLIB_EXPORT_VAR(const char) hamlib_copyright[]; 112 extern HAMLIB_EXPORT_VAR(const char *) hamlib_version2; 113 extern HAMLIB_EXPORT_VAR(const char *) hamlib_copyright2; 114 //! @endcond 115 116 /** 117 * \brief Hamlib error codes 118 * Error code definition that can be returned by the Hamlib functions. 119 * Unless stated otherwise, Hamlib functions return the negative value 120 * of rig_errcode_e definitions in case of error, or 0 when successful. 121 */ 122 enum rig_errcode_e { 123 RIG_OK = 0, /*!< 0 No error, operation completed successfully */ 124 RIG_EINVAL, /*!< 1 invalid parameter */ 125 RIG_ECONF, /*!< 2 invalid configuration (serial,..) */ 126 RIG_ENOMEM, /*!< 3 memory shortage */ 127 RIG_ENIMPL, /*!< 4 function not implemented, but will be */ 128 RIG_ETIMEOUT, /*!< 5 communication timed out */ 129 RIG_EIO, /*!< 6 IO error, including open failed */ 130 RIG_EINTERNAL, /*!< 7 Internal Hamlib error, huh! */ 131 RIG_EPROTO, /*!< 8 Protocol error */ 132 RIG_ERJCTED, /*!< 9 Command rejected by the rig */ 133 RIG_ETRUNC, /*!< 10 Command performed, but arg truncated */ 134 RIG_ENAVAIL, /*!< 11 Function not available */ 135 RIG_ENTARGET, /*!< 12 VFO not targetable */ 136 RIG_BUSERROR, /*!< 13 Error talking on the bus */ 137 RIG_BUSBUSY, /*!< 14 Collision on the bus */ 138 RIG_EARG, /*!< 15 NULL RIG handle or any invalid pointer parameter in get arg */ 139 RIG_EVFO, /*!< 16 Invalid VFO */ 140 RIG_EDOM /*!< 17 Argument out of domain of func */ 141 }; 142 143 /** 144 * \brief Determines if the given error code indicates a "soft" error 145 * Soft errors are caused by invalid parameters and software/hardware features 146 * and cannot be fixed by retries or by re-initializing hardware. 147 */ 148 #define RIG_IS_SOFT_ERRCODE(errcode) (errcode == RIG_EINVAL || errcode == RIG_ENIMPL || errcode == RIG_ERJCTED \ 149 || errcode == RIG_ETRUNC || errcode == RIG_ENAVAIL || errcode == RIG_ENTARGET \ 150 || errcode == RIG_EVFO || errcode == RIG_EDOM) 151 152 /** 153 * \brief Token in the netrigctl protocol for returning error code 154 */ 155 #define NETRIGCTL_RET "RPRT " 156 157 158 /** 159 *\brief Hamlib debug levels 160 * 161 * NOTE: Numeric order matters for debug level 162 * 163 * \sa rig_set_debug() 164 */ 165 enum rig_debug_level_e { 166 RIG_DEBUG_NONE = 0, /*!< no bug reporting */ 167 RIG_DEBUG_BUG, /*!< serious bug */ 168 RIG_DEBUG_ERR, /*!< error case (e.g. protocol, memory allocation) */ 169 RIG_DEBUG_WARN, /*!< warning */ 170 RIG_DEBUG_VERBOSE, /*!< verbose */ 171 RIG_DEBUG_TRACE, /*!< tracing */ 172 RIG_DEBUG_CACHE /*!< caching */ 173 }; 174 175 176 /* --------------- Rig capabilities -----------------*/ 177 178 /* Forward struct references */ 179 180 struct rig; 181 struct rig_state; 182 183 /** 184 * \brief Rig structure definition (see rig for details). 185 */ 186 typedef struct s_rig RIG; 187 188 //! @cond Doxygen_Suppress 189 #define HAMLIB_RIGNAMSIZ 30 190 #define HAMLIB_RIGVERSIZ 8 191 #define HAMLIB_FILPATHLEN 512 192 #define HAMLIB_FRQRANGESIZ 30 193 #define HAMLIB_MAXCHANDESC 30 /* describe channel eg: "WWV 5Mhz" */ 194 #define HAMLIB_TSLSTSIZ 20 /* max tuning step list size, zero ended */ 195 #define HAMLIB_FLTLSTSIZ 60 /* max mode/filter list size, zero ended */ 196 #define HAMLIB_MAXDBLSTSIZ 8 /* max preamp/att levels supported, zero ended */ 197 #define HAMLIB_CHANLSTSIZ 16 /* max mem_list size, zero ended */ 198 #define HAMLIB_MAX_CAL_LENGTH 32 /* max calibration plots in cal_table_t */ 199 #define HAMLIB_MAX_MODES 63 200 #define HAMLIB_MAX_VFOS 31 201 #define HAMLIB_MAX_ROTORS 63 202 #define HAMLIB_MAX_VFO_OPS 31 203 #define HAMLIB_MAX_RSCANS 31 204 //! @endcond 205 206 207 /** 208 * \brief CTCSS and DCS type definition. 209 * 210 * Continuous Tone Controlled Squelch System (CTCSS) 211 * sub-audible tone frequency are expressed in \em tenth of Hz. 212 * For example, the subaudible tone of 88.5 Hz is represented within 213 * Hamlib by 885. 214 * 215 * Digitally-Coded Squelch codes are simple direct integers. 216 */ 217 #define CTCSS_LIST_SIZE 60 218 #define DCS_LIST_SIZE 128 219 typedef unsigned int tone_t; 220 221 222 /** 223 * \brief Port type 224 */ 225 typedef enum rig_port_e { 226 RIG_PORT_NONE = 0, /*!< No port */ 227 RIG_PORT_SERIAL, /*!< Serial */ 228 RIG_PORT_NETWORK, /*!< Network socket type */ 229 RIG_PORT_DEVICE, /*!< Device driver, like the WiNRADiO */ 230 RIG_PORT_PACKET, /*!< AX.25 network type, e.g. SV8CS protocol */ 231 RIG_PORT_DTMF, /*!< DTMF protocol bridge via another rig, eg. Kenwood Sky Cmd System */ 232 RIG_PORT_ULTRA, /*!< IrDA Ultra protocol! */ 233 RIG_PORT_RPC, /*!< RPC wrapper */ 234 RIG_PORT_PARALLEL, /*!< Parallel port */ 235 RIG_PORT_USB, /*!< USB port */ 236 RIG_PORT_UDP_NETWORK, /*!< UDP Network socket type */ 237 RIG_PORT_CM108, /*!< CM108 GPIO */ 238 RIG_PORT_GPIO, /*!< GPIO */ 239 RIG_PORT_GPION, /*!< GPIO inverted */ 240 } rig_port_t; 241 242 243 /** 244 * \brief Serial parity 245 */ 246 enum serial_parity_e { 247 RIG_PARITY_NONE = 0, /*!< No parity */ 248 RIG_PARITY_ODD, /*!< Odd */ 249 RIG_PARITY_EVEN, /*!< Even */ 250 RIG_PARITY_MARK, /*!< Mark */ 251 RIG_PARITY_SPACE /*!< Space */ 252 }; 253 254 255 /** 256 * \brief Serial handshake 257 */ 258 enum serial_handshake_e { 259 RIG_HANDSHAKE_NONE = 0, /*!< No handshake */ 260 RIG_HANDSHAKE_XONXOFF, /*!< Software XON/XOFF */ 261 RIG_HANDSHAKE_HARDWARE /*!< Hardware CTS/RTS */ 262 }; 263 264 265 /** 266 * \brief Serial control state 267 */ 268 enum serial_control_state_e { 269 RIG_SIGNAL_UNSET = 0, /*!< Unset or tri-state */ 270 RIG_SIGNAL_ON, /*!< ON */ 271 RIG_SIGNAL_OFF /*!< OFF */ 272 }; 273 274 275 /** 276 * \brief Rig type flags 277 */ 278 typedef enum { 279 RIG_FLAG_RECEIVER = (1 << 1), /*!< Receiver */ 280 RIG_FLAG_TRANSMITTER = (1 << 2), /*!< Transmitter */ 281 RIG_FLAG_SCANNER = (1 << 3), /*!< Scanner */ 282 RIG_FLAG_MOBILE = (1 << 4), /*!< mobile sized */ 283 RIG_FLAG_HANDHELD = (1 << 5), /*!< handheld sized */ 284 RIG_FLAG_COMPUTER = (1 << 6), /*!< "Computer" rig */ 285 RIG_FLAG_TRUNKING = (1 << 7), /*!< has trunking */ 286 RIG_FLAG_APRS = (1 << 8), /*!< has APRS */ 287 RIG_FLAG_TNC = (1 << 9), /*!< has TNC */ 288 RIG_FLAG_DXCLUSTER = (1 << 10), /*!< has DXCluster */ 289 RIG_FLAG_TUNER = (1 << 11) /*!< dumb tuner */ 290 } rig_type_t; 291 292 //! @cond Doxygen_Suppress 293 #define RIG_FLAG_TRANSCEIVER (RIG_FLAG_RECEIVER|RIG_FLAG_TRANSMITTER) 294 #define RIG_TYPE_MASK (RIG_FLAG_TRANSCEIVER|RIG_FLAG_SCANNER|RIG_FLAG_MOBILE|RIG_FLAG_HANDHELD|RIG_FLAG_COMPUTER|RIG_FLAG_TRUNKING|RIG_FLAG_TUNER) 295 296 #define RIG_TYPE_OTHER 0 297 #define RIG_TYPE_TRANSCEIVER RIG_FLAG_TRANSCEIVER 298 #define RIG_TYPE_HANDHELD (RIG_FLAG_TRANSCEIVER|RIG_FLAG_HANDHELD) 299 #define RIG_TYPE_MOBILE (RIG_FLAG_TRANSCEIVER|RIG_FLAG_MOBILE) 300 #define RIG_TYPE_RECEIVER RIG_FLAG_RECEIVER 301 #define RIG_TYPE_PCRECEIVER (RIG_FLAG_COMPUTER|RIG_FLAG_RECEIVER) 302 #define RIG_TYPE_SCANNER (RIG_FLAG_SCANNER|RIG_FLAG_RECEIVER) 303 #define RIG_TYPE_TRUNKSCANNER (RIG_TYPE_SCANNER|RIG_FLAG_TRUNKING) 304 #define RIG_TYPE_COMPUTER (RIG_FLAG_TRANSCEIVER|RIG_FLAG_COMPUTER) 305 #define RIG_TYPE_TUNER RIG_FLAG_TUNER 306 //! @endcond 307 308 309 /** 310 * \brief Development status of the backend 311 */ 312 enum rig_status_e { 313 RIG_STATUS_ALPHA = 0, /*!< Alpha quality, i.e. development */ 314 RIG_STATUS_UNTESTED, /*!< Written from available specs, rig unavailable for test, feedback wanted! */ 315 RIG_STATUS_BETA, /*!< Beta quality */ 316 RIG_STATUS_STABLE, /*!< Stable */ 317 RIG_STATUS_BUGGY /*!< Was stable, but something broke it! */ 318 /* RIG_STATUS_NEW * *!< Initial release of code 319 * !! Use of RIG_STATUS_NEW is deprecated. Do not use it anymore */ 320 }; 321 322 /** 323 * \brief Map all deprecated RIG_STATUS_NEW references to 324 * RIG_STATUS_UNTESTED for backward compatibility 325 */ 326 #define RIG_STATUS_NEW RIG_STATUS_UNTESTED 327 328 329 /** 330 * \brief Repeater shift type 331 */ 332 typedef enum { 333 RIG_RPT_SHIFT_NONE = 0, /*!< No repeater shift */ 334 RIG_RPT_SHIFT_MINUS, /*!< "-" shift */ 335 RIG_RPT_SHIFT_PLUS /*!< "+" shift */ 336 } rptr_shift_t; 337 338 339 /** 340 * \brief Split mode 341 */ 342 typedef enum { 343 RIG_SPLIT_OFF = 0, /*!< Split mode disabled */ 344 RIG_SPLIT_ON /*!< Split mode enabled */ 345 } split_t; 346 347 348 /** 349 * \brief Frequency type, 350 * 351 * Frequency type unit in Hz, able to hold SHF frequencies. 352 */ 353 typedef double freq_t; 354 355 /** 356 * \brief printf(3) format to be used for freq_t type 357 */ 358 #define PRIfreq ".0f" 359 360 /** 361 * \brief scanf(3) format to be used for freq_t type 362 */ 363 #define SCNfreq "lf" 364 /** 365 * \brief printf(3) format to be used for freq_t type 366 */ 367 #define FREQFMT SCNfreq 368 369 370 /** 371 * \brief Short frequency type 372 * 373 * Frequency in Hz restricted to 31bits, suitable for offsets, shifts, etc.. 374 */ 375 typedef signed long shortfreq_t; 376 377 /** \brief \c Macro to return Hz when f=Hz */ 378 #define Hz(f) ((freq_t)(f)) 379 /** \brief \c Macro to return Hz when f=kHz */ 380 #define kHz(f) ((freq_t)((f)*(freq_t)1000)) 381 /** \brief \c Macro to return Hz when f=MHz */ 382 #define MHz(f) ((freq_t)((f)*(freq_t)1000000)) 383 /** \brief \c Macro to return Hz when f=GHz */ 384 #define GHz(f) ((freq_t)((f)*(freq_t)1000000000)) 385 386 /** \brief \c Macro to return short Hz when f=Hz */ 387 #define s_Hz(f) ((shortfreq_t)(f)) 388 /** \brief \c Macro to return short Hz when f=kHz */ 389 #define s_kHz(f) ((shortfreq_t)((f)*(shortfreq_t)1000)) 390 /** \brief \c Macro to return short Hz when f=MHz */ 391 #define s_MHz(f) ((shortfreq_t)((f)*(shortfreq_t)1000000)) 392 /** \brief \c Macro to return short Hz when f=GHz */ 393 #define s_GHz(f) ((shortfreq_t)((f)*(shortfreq_t)1000000000)) 394 395 /** \brief \c Frequency none -- used as default value for checking */ 396 #define RIG_FREQ_NONE Hz(0) 397 398 399 /** 400 * \brief VFO definition 401 * 402 * There are several ways of using a vfo_t. For most cases, using RIG_VFO_A, 403 * RIG_VFO_B, RIG_VFO_CURR, etc., as opaque macros should suffice. 404 * 405 * Strictly speaking a VFO is Variable Frequency Oscillator. 406 * Here, it is referred as a tunable channel, from the radio operator's 407 * point of view. The channel can be designated individually by its real 408 * number, or by using an alias. 409 * 410 * Aliases may or may not be honored by a backend and are defined using 411 * high significant bits, i.e. RIG_VFO_MEM, RIG_VFO_MAIN, etc. 412 */ 413 typedef unsigned int vfo_t; 414 415 /** \brief '' -- used in caps */ 416 417 #define RIG_VFO_N(n) ((vfo_t)(1u<<(n))) 418 419 /** \brief \c VFONone -- vfo unknown */ 420 #define RIG_VFO_NONE 0 421 422 /** \brief \c VFOA -- VFO A */ 423 #define RIG_VFO_A RIG_VFO_N(0) 424 425 /** \brief \c VFOB -- VFO B */ 426 #define RIG_VFO_B RIG_VFO_N(1) 427 428 /** \brief \c VFOC -- VFO C */ 429 #define RIG_VFO_C RIG_VFO_N(2) 430 431 // Any addition VFOS need to go from 3-20 432 // To maintain backward compatibility these values cannot change 433 434 /** \brief \c SubA -- alias for SUB_A */ 435 #define RIG_VFO_SUB_A RIG_VFO_N(21) 436 437 /** \brief \c SubB -- alias for SUB_B */ 438 #define RIG_VFO_SUB_B RIG_VFO_N(22) 439 440 /** \brief \c SubC -- alias for SUB_B */ 441 #define RIG_VFO_SUB_C RIG_VFO_N(3) 442 443 /** \brief \c MainA -- alias for MAIN_A */ 444 #define RIG_VFO_MAIN_A RIG_VFO_N(23) 445 446 /** \brief \c MainB -- alias for MAIN_B */ 447 #define RIG_VFO_MAIN_B RIG_VFO_N(24) 448 449 /** \brief \c MainC -- alias for MAIN_C */ 450 #define RIG_VFO_MAIN_C RIG_VFO_N(4) 451 452 /** \brief \c Sub -- alias for SUB */ 453 #define RIG_VFO_SUB RIG_VFO_N(25) 454 455 /** \brief \c Main -- alias for MAIN */ 456 #define RIG_VFO_MAIN RIG_VFO_N(26) 457 458 /** \brief \c VFO -- means (last or any)VFO mode, with set_vfo */ 459 #define RIG_VFO_VFO RIG_VFO_N(27) 460 461 /** \brief \c MEM -- means Memory mode, to be used with set_vfo */ 462 #define RIG_VFO_MEM RIG_VFO_N(28) 463 464 /** \brief \c currVFO -- current "tunable channel"/VFO */ 465 #define RIG_VFO_CURR RIG_VFO_N(29) 466 467 /** \brief \c Flag to set if VFO can transmit */ 468 #define RIG_VFO_TX_FLAG RIG_VFO_N(30) 469 470 /** \brief \c Flag to set all VFOS */ 471 #define RIG_VFO_ALL RIG_VFO_N(31) 472 473 // we can also use RIG_VFO_N(31) if needed 474 475 // Misc VFO Macros 476 477 /** \brief \c Macro to tell you if VFO can transmit */ 478 #define RIG_VFO_TX_VFO(v) ((v)|RIG_VFO_TX_FLAG) 479 480 /** \brief \c TX -- alias for split tx or uplink, of VFO_CURR */ 481 #define RIG_VFO_TX RIG_VFO_TX_VFO(RIG_VFO_CURR) 482 483 /** \brief \c RX -- alias for split rx or downlink */ 484 #define RIG_VFO_RX RIG_VFO_CURR 485 486 487 /* 488 * targetable bitfields, for internal use. 489 * In rig.c lack of a flag will case a VFO change if needed 490 * So setting this flag will mean the backend handles any VFO needs 491 * For many rigs RITXIT, PTT, MEM, and BANK are non-VFO commands so need these flags to avoid unnecessary VFO swapping 492 */ 493 //! @cond Doxygen_Suppress 494 #define RIG_TARGETABLE_NONE 0 495 #define RIG_TARGETABLE_FREQ (1<<0) 496 #define RIG_TARGETABLE_MODE (1<<1) // mode by vfo or same mode on both vfos 497 #define RIG_TARGETABLE_PURE (1<<2) // deprecated -- not used -- reuse it 498 #define RIG_TARGETABLE_TONE (1<<3) 499 #define RIG_TARGETABLE_FUNC (1<<4) 500 #define RIG_TARGETABLE_LEVEL (1<<5) 501 #define RIG_TARGETABLE_RITXIT (1<<6) 502 #define RIG_TARGETABLE_PTT (1<<7) 503 #define RIG_TARGETABLE_MEM (1<<8) 504 #define RIG_TARGETABLE_BANK (1<<9) 505 #define RIG_TARGETABLE_ANT (1<<10) 506 #define RIG_TARGETABLE_ROOFING (1<<11) // roofing filter targetable by VFO 507 #define RIG_TARGETABLE_COMMON (RIG_TARGETABLE_RITXIT | RIG_TARGETABLE_PTT | RIG_TARGETABLE_MEM | RIG_TARGETABLE_BANK) 508 #define RIG_TARGETABLE_ALL 0x7fffffff 509 //! @endcond 510 // 511 // 512 // Newer Icoms like the 9700 and 910 have VFOA/B on both Main & Sub 513 // Compared to older rigs which have one or the other 514 // So we need to distinguish between them 515 //! @cond Doxygen_Suppress 516 #define VFO_HAS_A_B ((rig->state.vfo_list & (RIG_VFO_A|RIG_VFO_B)) == (RIG_VFO_A|RIG_VFO_B)) 517 #define VFO_HAS_MAIN_SUB ((rig->state.vfo_list & (RIG_VFO_MAIN|RIG_VFO_SUB)) == (RIG_VFO_MAIN|RIG_VFO_SUB)) 518 #define VFO_HAS_MAIN_SUB_ONLY ((!VFO_HAS_A_B) & VFO_HAS_MAIN_SUB) 519 #define VFO_HAS_MAIN_SUB_A_B_ONLY (VFO_HAS_A_B & VFO_HAS_MAIN_SUB) 520 #define VFO_HAS_A_B_ONLY (VFO_HAS_A_B & (!VFO_HAS_MAIN_SUB)) 521 #define VFO_DUAL (RIG_VFO_MAIN_A|RIG_VFO_MAIN_B|RIG_VFO_SUB_A|RIG_VFO_SUB_B) 522 #define VFO_HAS_DUAL ((rig->state.vfo_list & VFO_DUAL) == VFO_DUAL) 523 //! @endcond 524 525 /** 526 * \brief Macro for bandpass to be set to normal 527 * \def RIG_PASSBAND_NORMAL 528 */ 529 #define RIG_PASSBAND_NORMAL s_Hz(0) 530 531 /** 532 * \brief Macro for bandpass to be left alone 533 */ 534 #define RIG_PASSBAND_NOCHANGE s_Hz(-1) 535 536 /** 537 * 538 * \sa rig_passband_normal(), rig_passband_narrow(), rig_passband_wide() 539 */ 540 typedef shortfreq_t pbwidth_t; 541 542 543 /** 544 * \brief DCD status 545 */ 546 typedef enum dcd_e { 547 RIG_DCD_OFF = 0, /*!< Squelch closed */ 548 RIG_DCD_ON /*!< Squelch open */ 549 } dcd_t; 550 551 552 /** 553 * \brief DCD type 554 * 555 * \sa rig_get_dcd() 556 */ 557 typedef enum { 558 RIG_DCD_NONE = 0, /*!< No DCD available */ 559 RIG_DCD_RIG, /*!< Rig has DCD status support, i.e. rig has get_dcd cap */ 560 RIG_DCD_SERIAL_DSR, /*!< DCD status from serial DSR signal */ 561 RIG_DCD_SERIAL_CTS, /*!< DCD status from serial CTS signal */ 562 RIG_DCD_SERIAL_CAR, /*!< DCD status from serial CD signal */ 563 RIG_DCD_PARALLEL, /*!< DCD status from parallel port pin */ 564 RIG_DCD_CM108, /*!< DCD status from CM108 vol dn pin */ 565 RIG_DCD_GPIO, /*!< DCD status from GPIO pin */ 566 RIG_DCD_GPION, /*!< DCD status from inverted GPIO pin */ 567 } dcd_type_t; 568 569 570 /** 571 * \brief PTT status 572 */ 573 typedef enum { 574 RIG_PTT_OFF = 0, /*!< PTT deactivated */ 575 RIG_PTT_ON, /*!< PTT activated */ 576 RIG_PTT_ON_MIC, /*!< PTT Mic only, fallbacks on RIG_PTT_ON if unavailable */ 577 RIG_PTT_ON_DATA /*!< PTT Data (Mic-muted), fallbacks on RIG_PTT_ON if unavailable */ 578 } ptt_t; 579 580 581 /** 582 * \brief PTT type 583 * 584 * \sa rig_get_ptt() 585 */ 586 typedef enum { 587 RIG_PTT_NONE = 0, /*!< No PTT available */ 588 RIG_PTT_RIG, /*!< Legacy PTT (CAT PTT) */ 589 RIG_PTT_SERIAL_DTR, /*!< PTT control through serial DTR signal */ 590 RIG_PTT_SERIAL_RTS, /*!< PTT control through serial RTS signal */ 591 RIG_PTT_PARALLEL, /*!< PTT control through parallel port */ 592 RIG_PTT_RIG_MICDATA, /*!< Legacy PTT (CAT PTT), supports RIG_PTT_ON_MIC/RIG_PTT_ON_DATA */ 593 RIG_PTT_CM108, /*!< PTT control through CM108 GPIO pin */ 594 RIG_PTT_GPIO, /*!< PTT control through GPIO pin */ 595 RIG_PTT_GPION, /*!< PTT control through inverted GPIO pin */ 596 } ptt_type_t; 597 598 599 /** 600 * \brief Radio power state 601 */ 602 typedef enum { 603 RIG_POWER_OFF = 0, /*!< Power off */ 604 RIG_POWER_ON = (1 << 0), /*!< Power on */ 605 RIG_POWER_STANDBY = (1 << 1), /*!< Standby */ 606 RIG_POWER_OPERATE = (1 << 2), /*!< Operate (from Standby) */ 607 RIG_POWER_UNKNOWN = (1 << 3) /*!< Unknown power status */ 608 } powerstat_t; 609 610 611 /** 612 * \brief Reset operation 613 */ 614 typedef enum { 615 RIG_RESET_NONE = 0, /*!< No reset */ 616 RIG_RESET_SOFT = (1 << 0), /*!< Software reset */ 617 RIG_RESET_VFO = (1 << 1), /*!< VFO reset */ 618 RIG_RESET_MCALL = (1 << 2), /*!< Memory clear */ 619 RIG_RESET_MASTER = (1 << 3) /*!< Master reset */ 620 } reset_t; 621 622 623 /** 624 * \brief VFO operation 625 * 626 * A VFO operation is an action on a VFO (or tunable memory). 627 * The difference with a function is that an action has no on/off 628 * status, it is performed at once. 629 * 630 * NOTE: the vfo argument for some vfo operation may be irrelevant, 631 * and thus will be ignored. 632 * 633 * The VFO/MEM "mode" is set by rig_set_vfo.\n 634 * \c STRING used in rigctl 635 * 636 * \sa rig_parse_vfo_op(), rig_strvfop() 637 */ 638 typedef enum { 639 RIG_OP_NONE = 0, /*!< '' No VFO_OP */ 640 RIG_OP_CPY = (1 << 0), /*!< \c CPY -- VFO A = VFO B */ 641 RIG_OP_XCHG = (1 << 1), /*!< \c XCHG -- Exchange VFO A/B */ 642 RIG_OP_FROM_VFO = (1 << 2), /*!< \c FROM_VFO -- VFO->MEM */ 643 RIG_OP_TO_VFO = (1 << 3), /*!< \c TO_VFO -- MEM->VFO */ 644 RIG_OP_MCL = (1 << 4), /*!< \c MCL -- Memory clear */ 645 RIG_OP_UP = (1 << 5), /*!< \c UP -- UP increment VFO freq by tuning step*/ 646 RIG_OP_DOWN = (1 << 6), /*!< \c DOWN -- DOWN decrement VFO freq by tuning step*/ 647 RIG_OP_BAND_UP = (1 << 7), /*!< \c BAND_UP -- Band UP */ 648 RIG_OP_BAND_DOWN = (1 << 8), /*!< \c BAND_DOWN -- Band DOWN */ 649 RIG_OP_LEFT = (1 << 9), /*!< \c LEFT -- LEFT */ 650 RIG_OP_RIGHT = (1 << 10), /*!< \c RIGHT -- RIGHT */ 651 RIG_OP_TUNE = (1 << 11), /*!< \c TUNE -- Start tune */ 652 RIG_OP_TOGGLE = (1 << 12) /*!< \c TOGGLE -- Toggle VFOA and VFOB */ 653 } vfo_op_t; 654 655 656 /** 657 * \brief Rig Scan operation 658 * 659 * Various scan operations supported by a rig.\n 660 * \c STRING used in rigctl 661 * 662 * \sa rig_parse_scan(), rig_strscan() 663 */ 664 typedef enum { 665 RIG_SCAN_NONE = 0, /*!< '' No-op value */ 666 RIG_SCAN_MEM = (1 << 0), /*!< \c MEM -- Scan all memory channels */ 667 RIG_SCAN_SLCT = (1 << 1), /*!< \c SLCT -- Scan all selected memory channels */ 668 RIG_SCAN_PRIO = (1 << 2), /*!< \c PRIO -- Priority watch (mem or call channel) */ 669 RIG_SCAN_PROG = (1 << 3), /*!< \c PROG -- Programmed(edge) scan */ 670 RIG_SCAN_DELTA = (1 << 4), /*!< \c DELTA -- delta-f scan */ 671 RIG_SCAN_VFO = (1 << 5), /*!< \c VFO -- most basic scan */ 672 RIG_SCAN_PLT = (1 << 6), /*!< \c PLT -- Scan using pipelined tuning */ 673 RIG_SCAN_STOP = (1 << 7) /*!< \c STOP -- Stop scanning */ 674 } scan_t; 675 676 677 /** 678 * \brief configuration token 679 */ 680 typedef long token_t; 681 682 683 //! @cond Doxygen_Suppress 684 #define RIG_CONF_END 0 685 //! @endcond 686 687 688 /** 689 * \brief parameter types 690 * 691 * Used with configuration, parameter and extra-parm tables. 692 * 693 * Current internal implementation 694 * NUMERIC: val.f or val.i 695 * COMBO: val.i, starting from 0. Points to a table of strings or asci stored values. 696 * STRING: val.s or val.cs 697 * CHECKBUTTON: val.i 0/1 698 * BINARY: val.b 699 */ 700 701 /* strongly inspired from soundmodem. Thanks Thomas! */ 702 enum rig_conf_e { 703 RIG_CONF_STRING, /*!< String type */ 704 RIG_CONF_COMBO, /*!< Combo type */ 705 RIG_CONF_NUMERIC, /*!< Numeric type integer or real */ 706 RIG_CONF_CHECKBUTTON, /*!< on/off type */ 707 RIG_CONF_BUTTON, /*!< Button type */ 708 RIG_CONF_BINARY /*!< Binary buffer type */ 709 }; 710 711 //! @cond Doxygen_Suppress 712 #define RIG_COMBO_MAX 16 713 #define RIG_BIN_MAX 80 714 //! @endcond 715 716 /** 717 * \brief Configuration parameter structure. 718 */ 719 struct confparams { 720 token_t token; /*!< Conf param token ID */ 721 const char *name; /*!< Param name, no spaces allowed */ 722 const char *label; /*!< Human readable label */ 723 const char *tooltip; /*!< Hint on the parameter */ 724 const char *dflt; /*!< Default value */ 725 enum rig_conf_e type; /*!< Type of the parameter */ 726 union { /*!< */ 727 struct { /*!< */ 728 float min; /*!< Minimum value */ 729 float max; /*!< Maximum value */ 730 float step; /*!< Step */ 731 } n; /*!< Numeric type */ 732 struct { /*!< */ 733 const char *combostr[RIG_COMBO_MAX]; /*!< Combo list */ 734 } c; /*!< Combo type */ 735 } u; /*!< Type union */ 736 }; 737 738 739 /** 740 * \brief Announce 741 * 742 * Designate optional speech synthesizer. 743 */ 744 typedef enum { 745 RIG_ANN_NONE = 0, /*!< None */ 746 RIG_ANN_OFF = RIG_ANN_NONE, /*!< disable announces */ 747 RIG_ANN_FREQ = (1 << 0), /*!< Announce frequency */ 748 RIG_ANN_RXMODE = (1 << 1), /*!< Announce receive mode */ 749 RIG_ANN_CW = (1 << 2), /*!< CW */ 750 RIG_ANN_ENG = (1 << 3), /*!< English */ 751 RIG_ANN_JAP = (1 << 4) /*!< Japan */ 752 } ann_t; 753 754 755 /** 756 * \brief Antenna typedef 757 * \typedef ant_t 758 */ 759 /** 760 * \brief Antenna number 761 * \def RIG_ANT_NONE 762 * No antenna set yet or unknown 763 */ 764 /** 765 * \brief Antenna conversion macro 766 * \def RIG_ANT_N 767 * Convert antenna number to bit mask 768 */ 769 /** 770 * \brief Macro for Ant#1 771 * \def RIG_ANT_1 772 */ 773 /** 774 * \brief Macro for Ant#2 775 * \def RIG_ANT_2 776 */ 777 /** 778 * \brief Macro for Ant#3 779 * \def RIG_ANT_3 780 */ 781 /** 782 * \brief Macro for Ant#4 783 * \def RIG_ANT_4 784 */ 785 /** 786 * \brief Macro for Ant#5 787 * \def RIG_ANT_5 788 */ 789 /** 790 * \brief Antenna is on whatever "current" means 791 * \def RIG_ANT_CURR 792 */ 793 /** 794 * \brief Macro for unknown antenna 795 * \def RIG_ANT_UNKNOWN 796 */ 797 /** 798 * \brief Maximum antenna# 799 * \def RIG_ANT_MAX 800 */ 801 typedef unsigned int ant_t; 802 803 #define RIG_ANT_NONE 0 804 #define RIG_ANT_N(n) ((ant_t)1<<(n)) 805 #define RIG_ANT_1 RIG_ANT_N(0) 806 #define RIG_ANT_2 RIG_ANT_N(1) 807 #define RIG_ANT_3 RIG_ANT_N(2) 808 #define RIG_ANT_4 RIG_ANT_N(3) 809 #define RIG_ANT_5 RIG_ANT_N(4) 810 811 #define RIG_ANT_UNKNOWN RIG_ANT_N(30) 812 #define RIG_ANT_CURR RIG_ANT_N(31) 813 814 #define RIG_ANT_MAX 32 815 816 817 /** 818 * \brief AGC delay settings 819 */ 820 /* TODO: kill me, and replace by real AGC delay */ 821 enum agc_level_e { 822 RIG_AGC_OFF = 0, 823 RIG_AGC_SUPERFAST, 824 RIG_AGC_FAST, 825 RIG_AGC_SLOW, 826 RIG_AGC_USER, /*!< user selectable */ 827 RIG_AGC_MEDIUM, 828 RIG_AGC_AUTO 829 }; 830 831 //! @cond Doxygen_Suppress 832 #define RIG_AGC_LAST RIG_AGC_AUTO 833 //! @endcond 834 835 /** 836 * \brief Level display meters 837 */ 838 enum meter_level_e { 839 RIG_METER_NONE = 0, /*< No display meter */ 840 RIG_METER_SWR = (1 << 0), /*< Stationary Wave Ratio */ 841 RIG_METER_COMP = (1 << 1), /*< Compression level */ 842 RIG_METER_ALC = (1 << 2), /*< ALC */ 843 RIG_METER_IC = (1 << 3), /*< IC */ 844 RIG_METER_DB = (1 << 4), /*< DB */ 845 RIG_METER_PO = (1 << 5), /*< Power Out */ 846 RIG_METER_VDD = (1 << 6), /*< Final Amp Voltage */ 847 RIG_METER_TEMP = (1 << 7) /*< Final Amp Voltage */ 848 }; 849 850 851 /** 852 * \brief Universal approach for passing values 853 * 854 * \sa rig_set_level(), rig_get_level(), rig_set_parm(), rig_get_parm() 855 */ 856 typedef union { 857 signed int i; /*!< Signed integer */ 858 float f; /*!< Single precision float */ 859 char *s; /*!< Pointer to char string */ 860 const char *cs; /*!< Pointer to constant char string */ 861 //! @cond Doxygen_Suppress 862 struct { 863 int l; /*!< Length of data */ 864 unsigned char *d; /* Pointer to data buffer */ 865 } b; 866 //! @endcond 867 } value_t; 868 869 870 /** 871 * \brief Rig Level Settings 872 * 873 * Various operating levels supported by a rig.\n 874 * \c STRING used in rigctl 875 * 876 * \sa rig_parse_level(), rig_strlevel() 877 */ 878 typedef uint64_t rig_level_e; 879 #define RIG_LEVEL_NONE 0 /*!< '' -- No Level */ 880 #define RIG_LEVEL_PREAMP CONSTANT_64BIT_FLAG(0) /*!< \c PREAMP -- Preamp, arg int (dB) */ 881 #define RIG_LEVEL_ATT CONSTANT_64BIT_FLAG(1) /*!< \c ATT -- Attenuator, arg int (dB) */ 882 #define RIG_LEVEL_VOXDELAY CONSTANT_64BIT_FLAG(2) /*!< \c VOXDELAY -- VOX delay, arg int (tenth of seconds) */ 883 #define RIG_LEVEL_AF CONSTANT_64BIT_FLAG(3) /*!< \c AF -- Volume, arg float [0.0 ... 1.0] */ 884 #define RIG_LEVEL_RF CONSTANT_64BIT_FLAG(4) /*!< \c RF -- RF gain (not TX power) arg float [0.0 ... 1.0] */ 885 #define RIG_LEVEL_SQL CONSTANT_64BIT_FLAG(5) /*!< \c SQL -- Squelch, arg float [0.0 ... 1.0] */ 886 #define RIG_LEVEL_IF CONSTANT_64BIT_FLAG(6) /*!< \c IF -- IF, arg int (Hz) */ 887 #define RIG_LEVEL_APF CONSTANT_64BIT_FLAG(7) /*!< \c APF -- Audio Peak Filter, arg float [0.0 ... 1.0] */ 888 #define RIG_LEVEL_NR CONSTANT_64BIT_FLAG(8) /*!< \c NR -- Noise Reduction, arg float [0.0 ... 1.0] */ 889 #define RIG_LEVEL_PBT_IN CONSTANT_64BIT_FLAG(9) /*!< \c PBT_IN -- Twin PBT (inside) arg float [0.0 ... 1.0] */ 890 #define RIG_LEVEL_PBT_OUT CONSTANT_64BIT_FLAG(10) /*!< \c PBT_OUT -- Twin PBT (outside) arg float [0.0 ... 1.0] */ 891 #define RIG_LEVEL_CWPITCH CONSTANT_64BIT_FLAG(11) /*!< \c CWPITCH -- CW pitch, arg int (Hz) */ 892 #define RIG_LEVEL_RFPOWER CONSTANT_64BIT_FLAG(12) /*!< \c RFPOWER -- RF Power, arg float [0.0 ... 1.0] */ 893 #define RIG_LEVEL_MICGAIN CONSTANT_64BIT_FLAG(13) /*!< \c MICGAIN -- MIC Gain, arg float [0.0 ... 1.0] */ 894 #define RIG_LEVEL_KEYSPD CONSTANT_64BIT_FLAG(14) /*!< \c KEYSPD -- Key Speed, arg int (WPM) */ 895 #define RIG_LEVEL_NOTCHF CONSTANT_64BIT_FLAG(15) /*!< \c NOTCHF -- Notch Freq., arg int (Hz) */ 896 #define RIG_LEVEL_COMP CONSTANT_64BIT_FLAG(16) /*!< \c COMP -- Compressor, arg float [0.0 ... 1.0] */ 897 #define RIG_LEVEL_AGC CONSTANT_64BIT_FLAG(17) /*!< \c AGC -- AGC, arg int (see enum agc_level_e) */ 898 #define RIG_LEVEL_BKINDL CONSTANT_64BIT_FLAG(18) /*!< \c BKINDL -- BKin Delay, arg int (tenth of dots) */ 899 #define RIG_LEVEL_BALANCE CONSTANT_64BIT_FLAG(19) /*!< \c BAL -- Balance (Dual Watch) arg float [0.0 ... 1.0] */ 900 #define RIG_LEVEL_METER CONSTANT_64BIT_FLAG(20) /*!< \c METER -- Display meter, arg int (see enum meter_level_e) */ 901 #define RIG_LEVEL_VOXGAIN CONSTANT_64BIT_FLAG(21) /*!< \c VOXGAIN -- VOX gain level, arg float [0.0 ... 1.0] */ 902 #define RIG_LEVEL_ANTIVOX CONSTANT_64BIT_FLAG(22) /*!< \c ANTIVOX -- anti-VOX level, arg float [0.0 ... 1.0] */ 903 #define RIG_LEVEL_SLOPE_LOW CONSTANT_64BIT_FLAG(23) /*!< \c SLOPE_LOW -- Slope tune, low frequency cut, arg int (Hz) */ 904 #define RIG_LEVEL_SLOPE_HIGH CONSTANT_64BIT_FLAG(24) /*!< \c SLOPE_HIGH -- Slope tune, high frequency cut, arg int (Hz) */ 905 #define RIG_LEVEL_BKIN_DLYMS CONSTANT_64BIT_FLAG(25) /*!< \c BKIN_DLYMS -- BKin Delay, arg int Milliseconds */ 906 907 /*!< These are not settable */ 908 #define RIG_LEVEL_RAWSTR CONSTANT_64BIT_FLAG(26) /*!< \c RAWSTR -- Raw (A/D) value for signal strength, specific to each rig, arg int */ 909 //#define RIG_LEVEL_SQLSTAT CONSTANT_64BIT_FLAG(27) /*!< \c SQLSTAT -- SQL status, arg int (open=1/closed=0). Deprecated, use get_dcd instead */ 910 #define RIG_LEVEL_SWR CONSTANT_64BIT_FLAG(28) /*!< \c SWR -- SWR, arg float [0.0 ... infinite] */ 911 #define RIG_LEVEL_ALC CONSTANT_64BIT_FLAG(29) /*!< \c ALC -- ALC, arg float */ 912 #define RIG_LEVEL_STRENGTH CONSTANT_64BIT_FLAG(30) /*!< \c STRENGTH -- Effective (calibrated) signal strength relative to S9, arg int (dB) */ 913 /* RIG_LEVEL_BWC (1<<31) */ /*!< Bandwidth Control, arg int (Hz) */ 914 #define RIG_LEVEL_RFPOWER_METER CONSTANT_64BIT_FLAG(32) /*!< \c RFPOWER_METER -- RF power output meter, arg float [0.0 ... 1.0] (percentage of maximum power) */ 915 #define RIG_LEVEL_COMP_METER CONSTANT_64BIT_FLAG(33) /*!< \c COMP_METER -- Audio output level compression meter, arg float (dB) */ 916 #define RIG_LEVEL_VD_METER CONSTANT_64BIT_FLAG(34) /*!< \c VD_METER -- Input voltage level meter, arg float (V, volts) */ 917 #define RIG_LEVEL_ID_METER CONSTANT_64BIT_FLAG(35) /*!< \c ID_METER -- Current draw meter, arg float (A, amperes) */ 918 919 #define RIG_LEVEL_NOTCHF_RAW CONSTANT_64BIT_FLAG(36) /*!< \c NOTCHF_RAW -- Notch Freq., arg float [0.0 ... 1.0] */ 920 #define RIG_LEVEL_MONITOR_GAIN CONSTANT_64BIT_FLAG(37) /*!< \c MONITOR_GAIN -- Monitor gain (level for monitoring of transmitted audio) arg float [0.0 ... 1.0] */ 921 #define RIG_LEVEL_NB CONSTANT_64BIT_FLAG(38) /*!< \c NB -- Noise Blanker level, arg float [0.0 ... 1.0] */ 922 #define RIG_LEVEL_RFPOWER_METER_WATTS CONSTANT_64BIT_FLAG(39) /*!< \c RFPOWER_METER_WATTS -- RF power output meter, arg float [0.0 ... MAX] (output power in watts) */ 923 #define RIG_LEVEL_40 CONSTANT_64BIT_FLAG(40) /*!< \c Future use */ 924 #define RIG_LEVEL_41 CONSTANT_64BIT_FLAG(41) /*!< \c Future use */ 925 #define RIG_LEVEL_42 CONSTANT_64BIT_FLAG(42) /*!< \c Future use */ 926 #define RIG_LEVEL_43 CONSTANT_64BIT_FLAG(43) /*!< \c Future use */ 927 #define RIG_LEVEL_44 CONSTANT_64BIT_FLAG(44) /*!< \c Future use */ 928 #define RIG_LEVEL_45 CONSTANT_64BIT_FLAG(45) /*!< \c Future use */ 929 #define RIG_LEVEL_46 CONSTANT_64BIT_FLAG(46) /*!< \c Future use */ 930 #define RIG_LEVEL_47 CONSTANT_64BIT_FLAG(47) /*!< \c Future use */ 931 #define RIG_LEVEL_48 CONSTANT_64BIT_FLAG(48) /*!< \c Future use */ 932 #define RIG_LEVEL_49 CONSTANT_64BIT_FLAG(49) /*!< \c Future use */ 933 #define RIG_LEVEL_50 CONSTANT_64BIT_FLAG(50) /*!< \c Future use */ 934 #define RIG_LEVEL_51 CONSTANT_64BIT_FLAG(51) /*!< \c Future use */ 935 #define RIG_LEVEL_52 CONSTANT_64BIT_FLAG(52) /*!< \c Future use */ 936 #define RIG_LEVEL_53 CONSTANT_64BIT_FLAG(53) /*!< \c Future use */ 937 #define RIG_LEVEL_54 CONSTANT_64BIT_FLAG(54) /*!< \c Future use */ 938 #define RIG_LEVEL_55 CONSTANT_64BIT_FLAG(55) /*!< \c Future use */ 939 #define RIG_LEVEL_56 CONSTANT_64BIT_FLAG(56) /*!< \c Future use */ 940 #define RIG_LEVEL_57 CONSTANT_64BIT_FLAG(57) /*!< \c Future use */ 941 #define RIG_LEVEL_58 CONSTANT_64BIT_FLAG(58) /*!< \c Future use */ 942 #define RIG_LEVEL_59 CONSTANT_64BIT_FLAG(59) /*!< \c Future use */ 943 #define RIG_LEVEL_60 CONSTANT_64BIT_FLAG(60) /*!< \c Future use */ 944 #define RIG_LEVEL_61 CONSTANT_64BIT_FLAG(61) /*!< \c Future use */ 945 #define RIG_LEVEL_62 CONSTANT_64BIT_FLAG(62) /*!< \c Future use */ 946 #define RIG_LEVEL_63 CONSTANT_64BIT_FLAG(63) /*!< \c Future use */ 947 948 //! @cond Doxygen_Suppress 949 #define RIG_LEVEL_FLOAT_LIST (RIG_LEVEL_AF|RIG_LEVEL_RF|RIG_LEVEL_SQL|RIG_LEVEL_APF|RIG_LEVEL_NR|RIG_LEVEL_PBT_IN|RIG_LEVEL_PBT_OUT|RIG_LEVEL_RFPOWER|RIG_LEVEL_MICGAIN|RIG_LEVEL_COMP|RIG_LEVEL_BALANCE|RIG_LEVEL_SWR|RIG_LEVEL_ALC|RIG_LEVEL_VOXGAIN|RIG_LEVEL_ANTIVOX|RIG_LEVEL_RFPOWER_METER|RIG_LEVEL_RFPOWER_METER_WATTS|RIG_LEVEL_COMP_METER|RIG_LEVEL_VD_METER|RIG_LEVEL_ID_METER|RIG_LEVEL_NOTCHF_RAW|RIG_LEVEL_MONITOR_GAIN|RIG_LEVEL_NB) 950 951 #define RIG_LEVEL_READONLY_LIST (RIG_LEVEL_SWR|RIG_LEVEL_ALC|RIG_LEVEL_STRENGTH|RIG_LEVEL_RAWSTR|RIG_LEVEL_RFPOWER_METER|RIG_LEVEL_COMP_METER|RIG_LEVEL_VD_METER|RIG_LEVEL_ID_METER) 952 953 #define RIG_LEVEL_IS_FLOAT(l) ((l)&RIG_LEVEL_FLOAT_LIST) 954 #define RIG_LEVEL_SET(l) ((l)&~RIG_LEVEL_READONLY_LIST) 955 //! @endcond 956 957 958 /** 959 * \brief Rig Parameters 960 * 961 * Parameters are settings that are not VFO specific.\n 962 * \c STRING used in rigctl 963 * 964 * \sa rig_parse_parm(), rig_strparm() 965 */ 966 enum rig_parm_e { 967 RIG_PARM_NONE = 0, /*!< '' -- No Parm */ 968 RIG_PARM_ANN = (1 << 0), /*!< \c ANN -- "Announce" level, see ann_t */ 969 RIG_PARM_APO = (1 << 1), /*!< \c APO -- Auto power off, int in minute */ 970 RIG_PARM_BACKLIGHT = (1 << 2), /*!< \c BACKLIGHT -- LCD light, float [0.0 ... 1.0] */ 971 RIG_PARM_BEEP = (1 << 4), /*!< \c BEEP -- Beep on keypressed, int (0,1) */ 972 RIG_PARM_TIME = (1 << 5), /*!< \c TIME -- hh:mm:ss, int in seconds from 00:00:00 */ 973 RIG_PARM_BAT = (1 << 6), /*!< \c BAT -- battery level, float [0.0 ... 1.0] */ 974 RIG_PARM_KEYLIGHT = (1 << 7), /*!< \c KEYLIGHT -- Button backlight, on/off */ 975 RIG_PARM_SCREENSAVER = (1 << 8) /*!< \c SCREENSAVER -- rig specific timeouts */ 976 }; 977 978 //! @cond Doxygen_Suppress 979 #define RIG_PARM_FLOAT_LIST (RIG_PARM_BACKLIGHT|RIG_PARM_BAT|RIG_PARM_KEYLIGHT) 980 #define RIG_PARM_READONLY_LIST (RIG_PARM_BAT) 981 982 #define RIG_PARM_IS_FLOAT(l) ((l)&RIG_PARM_FLOAT_LIST) 983 #define RIG_PARM_SET(l) ((l)&~RIG_PARM_READONLY_LIST) 984 //! @endcond 985 986 /** 987 * \brief Setting 988 * 989 * This can be a func, a level or a parm. 990 * Each bit designates one of them. 991 */ 992 typedef uint64_t setting_t; 993 994 /** 995 * \brief Maximum # of rig settings 996 * 997 */ 998 #define RIG_SETTING_MAX 64 999 1000 /** 1001 * \brief Tranceive mode 1002 * The rig notifies the host of any event, like freq changed, mode changed, etc. 1003 * \def RIG_TRN_OFF 1004 * Turn it off 1005 * \brief Tranceive mode 1006 * \def RIG_TRN_RIG 1007 * RIG_TRN_RIG means the rig acts asynchrousnly 1008 * \brief Tranceive mode 1009 * \def RIG_TRN_POLL 1010 * RIG_TRN_POLL means we have to poll the rig 1011 * 1012 */ 1013 #define RIG_TRN_OFF 0 1014 #define RIG_TRN_RIG 1 1015 #define RIG_TRN_POLL 2 1016 1017 1018 /** 1019 * \brief Rig Function Settings 1020 * 1021 * Various operating functions supported by a rig.\n 1022 * \c STRING used in rigctl/rigctld 1023 * 1024 * \sa rig_parse_func(), rig_strfunc() 1025 */ 1026 /* 1027 * The C standard dictates that an enum constant is a 32 bit signed integer. 1028 * Setting a constant's bit 31 created a negative value that on amd64 had the 1029 * upper 32 bits set as well when assigned to the misc.c:rig_func_str structure. 1030 * This caused misc.c:rig_strfunc() to fail its comparison for RIG_FUNC_XIT 1031 * on amd64 (x86_64). To use bit 31 as an unsigned long, preprocessor macros 1032 * have been used instead as a 'const unsigned long' which cannot be used to 1033 * initialize the rig_func_str.func members. TNX KA6MAL, AC6SL. - N0NB 1034 */ 1035 #define RIG_FUNC_NONE 0 /*!< '' -- No Function */ 1036 #define RIG_FUNC_FAGC CONSTANT_64BIT_FLAG (0) /*!< \c FAGC -- Fast AGC */ 1037 #define RIG_FUNC_NB CONSTANT_64BIT_FLAG (1) /*!< \c NB -- Noise Blanker */ 1038 #define RIG_FUNC_COMP CONSTANT_64BIT_FLAG (2) /*!< \c COMP -- Speech Compression */ 1039 #define RIG_FUNC_VOX CONSTANT_64BIT_FLAG (3) /*!< \c VOX -- Voice Operated Relay */ 1040 #define RIG_FUNC_TONE CONSTANT_64BIT_FLAG (4) /*!< \c TONE -- CTCSS Tone TX */ 1041 #define RIG_FUNC_TSQL CONSTANT_64BIT_FLAG (5) /*!< \c TSQL -- CTCSS Activate/De-activate RX */ 1042 #define RIG_FUNC_SBKIN CONSTANT_64BIT_FLAG (6) /*!< \c SBKIN -- Semi Break-in (CW mode) */ 1043 #define RIG_FUNC_FBKIN CONSTANT_64BIT_FLAG (7) /*!< \c FBKIN -- Full Break-in (CW mode) */ 1044 #define RIG_FUNC_ANF CONSTANT_64BIT_FLAG (8) /*!< \c ANF -- Automatic Notch Filter (DSP) */ 1045 #define RIG_FUNC_NR CONSTANT_64BIT_FLAG (9) /*!< \c NR -- Noise Reduction (DSP) */ 1046 #define RIG_FUNC_AIP CONSTANT_64BIT_FLAG (10) /*!< \c AIP -- RF pre-amp (AIP on Kenwood, IPO on Yaesu, etc.) */ 1047 #define RIG_FUNC_APF CONSTANT_64BIT_FLAG (11) /*!< \c APF -- Auto Passband/Audio Peak Filter */ 1048 #define RIG_FUNC_MON CONSTANT_64BIT_FLAG (12) /*!< \c MON -- Monitor transmitted signal */ 1049 #define RIG_FUNC_MN CONSTANT_64BIT_FLAG (13) /*!< \c MN -- Manual Notch */ 1050 #define RIG_FUNC_RF CONSTANT_64BIT_FLAG (14) /*!< \c RF -- RTTY Filter */ 1051 #define RIG_FUNC_ARO CONSTANT_64BIT_FLAG (15) /*!< \c ARO -- Auto Repeater Offset */ 1052 #define RIG_FUNC_LOCK CONSTANT_64BIT_FLAG (16) /*!< \c LOCK -- Lock */ 1053 #define RIG_FUNC_MUTE CONSTANT_64BIT_FLAG (17) /*!< \c MUTE -- Mute */ 1054 #define RIG_FUNC_VSC CONSTANT_64BIT_FLAG (18) /*!< \c VSC -- Voice Scan Control */ 1055 #define RIG_FUNC_REV CONSTANT_64BIT_FLAG (19) /*!< \c REV -- Reverse transmit and receive frequencies */ 1056 #define RIG_FUNC_SQL CONSTANT_64BIT_FLAG (20) /*!< \c SQL -- Turn Squelch Monitor on/off */ 1057 #define RIG_FUNC_ABM CONSTANT_64BIT_FLAG (21) /*!< \c ABM -- Auto Band Mode */ 1058 #define RIG_FUNC_BC CONSTANT_64BIT_FLAG (22) /*!< \c BC -- Beat Canceller */ 1059 #define RIG_FUNC_MBC CONSTANT_64BIT_FLAG (23) /*!< \c MBC -- Manual Beat Canceller */ 1060 #define RIG_FUNC_RIT CONSTANT_64BIT_FLAG (24) /*!< \c RIT -- Receiver Incremental Tuning */ 1061 #define RIG_FUNC_AFC CONSTANT_64BIT_FLAG (25) /*!< \c AFC -- Auto Frequency Control ON/OFF */ 1062 #define RIG_FUNC_SATMODE CONSTANT_64BIT_FLAG (26) /*!< \c SATMODE -- Satellite mode ON/OFF */ 1063 #define RIG_FUNC_SCOPE CONSTANT_64BIT_FLAG (27) /*!< \c SCOPE -- Simple bandscope ON/OFF */ 1064 #define RIG_FUNC_RESUME CONSTANT_64BIT_FLAG (28) /*!< \c RESUME -- Scan auto-resume */ 1065 #define RIG_FUNC_TBURST CONSTANT_64BIT_FLAG (29) /*!< \c TBURST -- 1750 Hz tone burst */ 1066 #define RIG_FUNC_TUNER CONSTANT_64BIT_FLAG (30) /*!< \c TUNER -- Enable automatic tuner */ 1067 #define RIG_FUNC_XIT CONSTANT_64BIT_FLAG (31) /*!< \c XIT -- Transmitter Incremental Tuning */ 1068 #ifndef SWIGLUAHIDE 1069 /* Hide the top 32 bits from the old Lua binding as they can't be represented */ 1070 #define RIG_FUNC_NB2 CONSTANT_64BIT_FLAG (32) /*!< \c NB2 -- 2nd Noise Blanker */ 1071 #define RIG_FUNC_CSQL CONSTANT_64BIT_FLAG (33) /*!< \c CSQL -- DCS Squelch setting */ 1072 #define RIG_FUNC_AFLT CONSTANT_64BIT_FLAG (34) /*!< \c AFLT -- AF Filter setting */ 1073 #define RIG_FUNC_ANL CONSTANT_64BIT_FLAG (35) /*!< \c ANL -- Noise limiter setting */ 1074 #define RIG_FUNC_BC2 CONSTANT_64BIT_FLAG (36) /*!< \c BC2 -- 2nd Beat Cancel */ 1075 #define RIG_FUNC_DUAL_WATCH CONSTANT_64BIT_FLAG (37) /*!< \c DUAL_WATCH -- Dual Watch / Sub Receiver */ 1076 #define RIG_FUNC_DIVERSITY CONSTANT_64BIT_FLAG (38) /*!< \c DIVERSITY -- Diversity receive */ 1077 #define RIG_FUNC_DSQL CONSTANT_64BIT_FLAG (39) /*!< \c DSQL -- Digital modes squelch */ 1078 #define RIG_FUNC_SCEN CONSTANT_64BIT_FLAG (40) /*!< \c SCEN -- scrambler/encryption */ 1079 #define RIG_FUNC_SLICE CONSTANT_64BIT_FLAG (41) /*!< \c Rig slice selection -- Flex */ 1080 #define RIG_FUNC_BIT42 CONSTANT_64BIT_FLAG (42) /*!< \c available for future RIG_FUNC items */ 1081 #define RIG_FUNC_BIT43 CONSTANT_64BIT_FLAG (43) /*!< \c available for future RIG_FUNC items */ 1082 #define RIG_FUNC_BIT44 CONSTANT_64BIT_FLAG (44) /*!< \c available for future RIG_FUNC items */ 1083 #define RIG_FUNC_BIT45 CONSTANT_64BIT_FLAG (45) /*!< \c available for future RIG_FUNC items */ 1084 #define RIG_FUNC_BIT46 CONSTANT_64BIT_FLAG (46) /*!< \c available for future RIG_FUNC items */ 1085 #define RIG_FUNC_BIT47 CONSTANT_64BIT_FLAG (47) /*!< \c available for future RIG_FUNC items */ 1086 #define RIG_FUNC_BIT48 CONSTANT_64BIT_FLAG (48) /*!< \c available for future RIG_FUNC items */ 1087 #define RIG_FUNC_BIT49 CONSTANT_64BIT_FLAG (49) /*!< \c available for future RIG_FUNC items */ 1088 #define RIG_FUNC_BIT50 CONSTANT_64BIT_FLAG (50) /*!< \c available for future RIG_FUNC items */ 1089 #define RIG_FUNC_BIT51 CONSTANT_64BIT_FLAG (51) /*!< \c available for future RIG_FUNC items */ 1090 #define RIG_FUNC_BIT52 CONSTANT_64BIT_FLAG (52) /*!< \c available for future RIG_FUNC items */ 1091 #define RIG_FUNC_BIT53 CONSTANT_64BIT_FLAG (53) /*!< \c available for future RIG_FUNC items */ 1092 #define RIG_FUNC_BIT54 CONSTANT_64BIT_FLAG (54) /*!< \c available for future RIG_FUNC items */ 1093 #define RIG_FUNC_BIT55 CONSTANT_64BIT_FLAG (55) /*!< \c available for future RIG_FUNC items */ 1094 #define RIG_FUNC_BIT56 CONSTANT_64BIT_FLAG (56) /*!< \c available for future RIG_FUNC items */ 1095 #define RIG_FUNC_BIT57 CONSTANT_64BIT_FLAG (57) /*!< \c available for future RIG_FUNC items */ 1096 #define RIG_FUNC_BIT58 CONSTANT_64BIT_FLAG (58) /*!< \c available for future RIG_FUNC items */ 1097 #define RIG_FUNC_BIT59 CONSTANT_64BIT_FLAG (59) /*!< \c available for future RIG_FUNC items */ 1098 #define RIG_FUNC_BIT60 CONSTANT_64BIT_FLAG (60) /*!< \c available for future RIG_FUNC items */ 1099 #define RIG_FUNC_BIT61 CONSTANT_64BIT_FLAG (61) /*!< \c available for future RIG_FUNC items */ 1100 #define RIG_FUNC_BIT62 CONSTANT_64BIT_FLAG (62) /*!< \c available for future RIG_FUNC items */ 1101 #define RIG_FUNC_BIT63 CONSTANT_64BIT_FLAG (63) /*!< \c available for future RIG_FUNC items */ 1102 /* 63 is this highest bit number that can be used */ 1103 #endif 1104 1105 /** 1106 * \brief power unit macros 1107 * \def mW 1108 * Converts a power level integer to milliwatts. This is limited to 2 1109 * megawatts on 32 bit systems. 1110 */ 1111 #define mW(p) ((int)(p)) 1112 /** 1113 * \brief power unit macros 1114 * \def Watts 1115 * 1116 * Converts a power level integer to watts. This is limited to 2 1117 * gigawatts on 32 bit systems. 1118 */ 1119 #define Watts(p) ((int)((p)*1000)) 1120 /** 1121 * \brief power unit macros 1122 * \def W 1123 * 1124 * Same as Watts for the person who is too lazy to type Watts :-) 1125 */ 1126 #define W(p) Watts(p) 1127 #if 0 // deprecating kW macro as this doesn't make sense 1128 /** 1129 * \brief power unit macros 1130 * \def kW 1131 * 1132 * Same as Watts for the person who is too lazy to type Watts :-) 1133 */ 1134 #define kW(p) ((int)((p)*1000000L)) 1135 #endif 1136 1137 1138 /** 1139 * \brief Radio mode 1140 * 1141 * Various modes supported by a rig.\n 1142 * \c STRING used in rigctl 1143 * 1144 * \sa rig_parse_mode(), rig_strrmode() 1145 * TODO: Add new 8600 modes to rig2icom_mode() and icom2rig_mode() in frame.c 1146 */ 1147 typedef uint64_t rmode_t; 1148 1149 #define RIG_MODE_NONE 0 /*!< '' -- None */ 1150 #define RIG_MODE_AM CONSTANT_64BIT_FLAG (0) /*!< \c AM -- Amplitude Modulation */ 1151 #define RIG_MODE_CW CONSTANT_64BIT_FLAG (1) /*!< \c CW -- CW "normal" sideband */ 1152 #define RIG_MODE_USB CONSTANT_64BIT_FLAG (2) /*!< \c USB -- Upper Side Band */ 1153 #define RIG_MODE_LSB CONSTANT_64BIT_FLAG (3) /*!< \c LSB -- Lower Side Band */ 1154 #define RIG_MODE_RTTY CONSTANT_64BIT_FLAG (4) /*!< \c RTTY -- Radio Teletype */ 1155 #define RIG_MODE_FM CONSTANT_64BIT_FLAG (5) /*!< \c FM -- "narrow" band FM */ 1156 #define RIG_MODE_WFM CONSTANT_64BIT_FLAG (6) /*!< \c WFM -- broadcast wide FM */ 1157 #define RIG_MODE_CWR CONSTANT_64BIT_FLAG (7) /*!< \c CWR -- CW "reverse" sideband */ 1158 #define RIG_MODE_RTTYR CONSTANT_64BIT_FLAG (8) /*!< \c RTTYR -- RTTY "reverse" sideband */ 1159 #define RIG_MODE_AMS CONSTANT_64BIT_FLAG (9) /*!< \c AMS -- Amplitude Modulation Synchronous */ 1160 #define RIG_MODE_PKTLSB CONSTANT_64BIT_FLAG (10) /*!< \c PKTLSB -- Packet/Digital LSB mode (dedicated port) */ 1161 #define RIG_MODE_PKTUSB CONSTANT_64BIT_FLAG (11) /*!< \c PKTUSB -- Packet/Digital USB mode (dedicated port) */ 1162 #define RIG_MODE_PKTFM CONSTANT_64BIT_FLAG (12) /*!< \c PKTFM -- Packet/Digital FM mode (dedicated port) */ 1163 #define RIG_MODE_ECSSUSB CONSTANT_64BIT_FLAG (13) /*!< \c ECSSUSB -- Exalted Carrier Single Sideband USB */ 1164 #define RIG_MODE_ECSSLSB CONSTANT_64BIT_FLAG (14) /*!< \c ECSSLSB -- Exalted Carrier Single Sideband LSB */ 1165 #define RIG_MODE_FAX CONSTANT_64BIT_FLAG (15) /*!< \c FAX -- Facsimile Mode */ 1166 #define RIG_MODE_SAM CONSTANT_64BIT_FLAG (16) /*!< \c SAM -- Synchronous AM double sideband */ 1167 #define RIG_MODE_SAL CONSTANT_64BIT_FLAG (17) /*!< \c SAL -- Synchronous AM lower sideband */ 1168 #define RIG_MODE_SAH CONSTANT_64BIT_FLAG (18) /*!< \c SAH -- Synchronous AM upper (higher) sideband */ 1169 #define RIG_MODE_DSB CONSTANT_64BIT_FLAG (19) /*!< \c DSB -- Double sideband suppressed carrier */ 1170 #define RIG_MODE_FMN CONSTANT_64BIT_FLAG (21) /*!< \c FMN -- FM Narrow Kenwood ts990s */ 1171 #define RIG_MODE_PKTAM CONSTANT_64BIT_FLAG (22) /*!< \c PKTAM -- Packet/Digital AM mode e.g. IC7300 */ 1172 #define RIG_MODE_P25 CONSTANT_64BIT_FLAG (23) /*!< \c P25 -- APCO/P25 VHF,UHF digital mode IC-R8600 */ 1173 #define RIG_MODE_DSTAR CONSTANT_64BIT_FLAG (24) /*!< \c D-Star -- VHF,UHF digital mode IC-R8600 */ 1174 #define RIG_MODE_DPMR CONSTANT_64BIT_FLAG (25) /*!< \c dPMR -- digital PMR, VHF,UHF digital mode IC-R8600 */ 1175 #define RIG_MODE_NXDNVN CONSTANT_64BIT_FLAG (26) /*!< \c NXDN-VN -- VHF,UHF digital mode IC-R8600 */ 1176 #define RIG_MODE_NXDN_N CONSTANT_64BIT_FLAG (27) /*!< \c NXDN-N -- VHF,UHF digital mode IC-R8600 */ 1177 #define RIG_MODE_DCR CONSTANT_64BIT_FLAG (28) /*!< \c DCR -- VHF,UHF digital mode IC-R8600 */ 1178 #define RIG_MODE_AMN CONSTANT_64BIT_FLAG (29) /*!< \c AM-N -- Narrow band AM mode IC-R30 */ 1179 #define RIG_MODE_PSK CONSTANT_64BIT_FLAG (30) /*!< \c PSK - Kenwood PSK and others */ 1180 #define RIG_MODE_PSKR CONSTANT_64BIT_FLAG (31) /*!< \c PSKR - Kenwood PSKR and others */ 1181 #ifndef SWIGLUAHIDE 1182 /* hide the top 32 bits from the Lua binding as they will not work */ 1183 #define RIG_MODE_DD CONSTANT_64BIT_FLAG (32) /*!< \c DD Mode IC-9700 */ 1184 #define RIG_MODE_C4FM CONSTANT_64BIT_FLAG (33) /*!< \c Yaesu C4FM mode */ 1185 #define RIG_MODE_PKTFMN CONSTANT_64BIT_FLAG (34) /*!< \c Yaesu DATA-FM-N */ 1186 #define RIG_MODE_SPEC CONSTANT_64BIT_FLAG (35) /*!< \c Unfiltered as in PowerSDR */ 1187 #define RIG_MODE_BIT36 CONSTANT_64BIT_FLAG (36) /*!< \c reserved for future expansion */ 1188 #define RIG_MODE_BIT37 CONSTANT_64BIT_FLAG (37) /*!< \c reserved for future expansion */ 1189 #define RIG_MODE_BIT38 CONSTANT_64BIT_FLAG (38) /*!< \c reserved for future expansion */ 1190 #define RIG_MODE_BIT39 CONSTANT_64BIT_FLAG (39) /*!< \c reserved for future expansion */ 1191 #define RIG_MODE_BIT40 CONSTANT_64BIT_FLAG (40) /*!< \c reserved for future expansion */ 1192 #define RIG_MODE_BIT41 CONSTANT_64BIT_FLAG (41) /*!< \c reserved for future expansion */ 1193 #define RIG_MODE_BIT42 CONSTANT_64BIT_FLAG (42) /*!< \c reserved for future expansion */ 1194 #define RIG_MODE_BIT43 CONSTANT_64BIT_FLAG (43) /*!< \c reserved for future expansion */ 1195 #define RIG_MODE_BIT44 CONSTANT_64BIT_FLAG (44) /*!< \c reserved for future expansion */ 1196 #define RIG_MODE_BIT45 CONSTANT_64BIT_FLAG (45) /*!< \c reserved for future expansion */ 1197 #define RIG_MODE_BIT46 CONSTANT_64BIT_FLAG (46) /*!< \c reserved for future expansion */ 1198 #define RIG_MODE_BIT47 CONSTANT_64BIT_FLAG (47) /*!< \c reserved for future expansion */ 1199 #define RIG_MODE_BIT48 CONSTANT_64BIT_FLAG (48) /*!< \c reserved for future expansion */ 1200 #define RIG_MODE_BIT49 CONSTANT_64BIT_FLAG (49) /*!< \c reserved for future expansion */ 1201 #define RIG_MODE_BIT50 CONSTANT_64BIT_FLAG (50) /*!< \c reserved for future expansion */ 1202 #define RIG_MODE_BIT51 CONSTANT_64BIT_FLAG (51) /*!< \c reserved for future expansion */ 1203 #define RIG_MODE_BIT52 CONSTANT_64BIT_FLAG (52) /*!< \c reserved for future expansion */ 1204 #define RIG_MODE_BIT53 CONSTANT_64BIT_FLAG (53) /*!< \c reserved for future expansion */ 1205 #define RIG_MODE_BIT54 CONSTANT_64BIT_FLAG (54) /*!< \c reserved for future expansion */ 1206 #define RIG_MODE_BIT55 CONSTANT_64BIT_FLAG (55) /*!< \c reserved for future expansion */ 1207 #define RIG_MODE_BIT56 CONSTANT_64BIT_FLAG (56) /*!< \c reserved for future expansion */ 1208 #define RIG_MODE_BIT57 CONSTANT_64BIT_FLAG (57) /*!< \c reserved for future expansion */ 1209 #define RIG_MODE_BIT58 CONSTANT_64BIT_FLAG (58) /*!< \c reserved for future expansion */ 1210 #define RIG_MODE_BIT59 CONSTANT_64BIT_FLAG (59) /*!< \c reserved for future expansion */ 1211 #define RIG_MODE_BIT60 CONSTANT_64BIT_FLAG (60) /*!< \c reserved for future expansion */ 1212 #define RIG_MODE_BIT61 CONSTANT_64BIT_FLAG (61) /*!< \c reserved for future expansion */ 1213 #define RIG_MODE_BIT62 CONSTANT_64BIT_FLAG (62) /*!< \c reserved for future expansion */ 1214 #define RIG_MODE_TESTS_MAX CONSTANT_64BIT_FLAG (63) /*!< \c last bit available for 64-bit enum MUST ALWAYS BE LAST, Max Count for dumpcaps.c */ 1215 #endif 1216 1217 /** 1218 * \brief macro for backends, not to be used by rig_set_mode et al. 1219 */ 1220 #define RIG_MODE_SSB (RIG_MODE_USB|RIG_MODE_LSB) 1221 1222 /** 1223 * \brief macro for backends, not to be used by rig_set_mode et al. 1224 */ 1225 #define RIG_MODE_ECSS (RIG_MODE_ECSSUSB|RIG_MODE_ECSSLSB) 1226 1227 //! @cond Doxygen_Suppress 1228 #define RIG_DBLST_END 0 /* end marker in a preamp/att level list */ 1229 #define RIG_IS_DBLST_END(d) ((d)==0) 1230 //! @endcond 1231 1232 1233 /** 1234 * \brief Frequency range 1235 * 1236 * Put together a group of this struct in an array to define 1237 * what frequencies your rig has access to. 1238 */ 1239 typedef struct freq_range_list { 1240 freq_t startf; /*!< Start frequency */ 1241 freq_t endf; /*!< End frequency */ 1242 rmode_t modes; /*!< Bit field of RIG_MODE's */ 1243 int low_power; /*!< Lower RF power in mW, -1 for no power (ie. rx list) */ 1244 int high_power; /*!< Higher RF power in mW, -1 for no power (ie. rx list) */ 1245 vfo_t vfo; /*!< VFO list equipped with this range */ 1246 ant_t ant; /*!< Antenna list equipped with this range, 0 means all, RIG_ANT_CURR means dedicated to certain bands and automatically switches, no set_ant command */ 1247 char *label; /*!< Label for this range that explains why. e.g. Icom rigs USA, EUR, ITR, TPE, KOR */ 1248 } freq_range_t; 1249 1250 //! @cond Doxygen_Suppress 1251 #define RIG_FRNG_END {Hz(0),Hz(0),RIG_MODE_NONE,0,0,RIG_VFO_NONE} 1252 #define RIG_IS_FRNG_END(r) ((r).startf == Hz(0) && (r).endf == Hz(0)) 1253 //! @endcond 1254 1255 /** 1256 * \brief Tuning step definition 1257 * 1258 * Lists the tuning steps available for each mode. 1259 * 1260 * If a ts field in the list has RIG_TS_ANY value, this means the rig allows 1261 * its tuning step to be set to any value ranging from the lowest to the 1262 * highest (if any) value in the list for that mode. The tuning step must be 1263 * sorted in the ascending order, and the RIG_TS_ANY value, if present, must 1264 * be the last one in the list. 1265 * 1266 * Note also that the minimum frequency resolution of the rig is determined by 1267 * the lowest value in the Tuning step list. 1268 * 1269 * \sa rig_set_ts(), rig_get_resolution() 1270 */ 1271 struct tuning_step_list { 1272 rmode_t modes; /*!< Bit field of RIG_MODE's */ 1273 shortfreq_t ts; /*!< Tuning step in Hz */ 1274 }; 1275 1276 //! @cond Doxygen_Suppress 1277 #define RIG_TS_ANY 0 1278 #define RIG_TS_END {RIG_MODE_NONE, 0} 1279 #define RIG_IS_TS_END(t) ((t).modes == RIG_MODE_NONE && (t).ts == 0) 1280 //! @endcond 1281 1282 1283 /** 1284 * \brief Filter definition 1285 * 1286 * Lists the filters available for each mode. 1287 * 1288 * If more than one filter is available for a given mode, the first entry in 1289 * the array will be the default filter to use for the normal passband of this 1290 * mode. The first entry in the array below the default normal passband is 1291 * the default narrow passband and the first entry in the array above the 1292 * default normal passband is the default wide passband. Note: if there's no 1293 * lower width or upper width, then narrow or respectively wide passband is 1294 * equal to the default normal passband. 1295 * 1296 * If a width field in the list has RIG_FLT_ANY value, this means the rig 1297 * allows its passband width to be set to any value ranging from the lowest to 1298 * the highest value (if any) in the list for that mode. The RIG_FLT_ANY 1299 * value, if present, must be the last one in the list. 1300 * 1301 * The width field is the narrowest passband in a transmit/receive chain with 1302 * regard to different IF. 1303 * 1304 * \sa rig_set_mode(), rig_passband_normal(), rig_passband_narrow(), rig_passband_wide() 1305 */ 1306 struct filter_list { 1307 rmode_t modes; /*!< Bit field of RIG_MODE's */ 1308 pbwidth_t width; /*!< Passband width in Hz */ 1309 }; 1310 //! @cond Doxygen_Suppress 1311 #define RIG_FLT_ANY 0 1312 #define RIG_FLT_END {RIG_MODE_NONE, 0} 1313 #define RIG_IS_FLT_END(f) ((f).modes == RIG_MODE_NONE) 1314 //! @endcond 1315 1316 1317 /** 1318 * \brief Empty channel_t.flags field 1319 */ 1320 #define RIG_CHFLAG_NONE 0 1321 /** 1322 * \brief skip memory channel during scan (lock out), channel_t.flags 1323 */ 1324 #define RIG_CHFLAG_SKIP (1<<0) 1325 /** 1326 * \brief DATA port mode flag 1327 */ 1328 #define RIG_CHFLAG_DATA (1<<1) 1329 /** 1330 * \brief programmed skip (PSKIP) memory channel during scan (lock out), channel_t.flags 1331 */ 1332 #define RIG_CHFLAG_PSKIP (1<<2) 1333 1334 /** 1335 * \brief Extension attribute definition 1336 * 1337 */ 1338 struct ext_list { 1339 token_t token; /*!< Token ID */ 1340 value_t val; /*!< Value */ 1341 }; 1342 1343 //! @cond Doxygen_Suppress 1344 #define RIG_EXT_END {0, {.i=0}} 1345 #define RIG_IS_EXT_END(x) ((x).token == 0) 1346 //! @endcond 1347 1348 /** 1349 * \brief Channel structure 1350 * 1351 * The channel struct stores all the attributes peculiar to a VFO. 1352 * 1353 * \sa rig_set_channel(), rig_get_channel() 1354 */ 1355 struct channel { 1356 int channel_num; /*!< Channel number */ 1357 int bank_num; /*!< Bank number */ 1358 vfo_t vfo; /*!< VFO */ 1359 ant_t ant; /*!< Selected antenna */ 1360 freq_t freq; /*!< Receive frequency */ 1361 rmode_t mode; /*!< Receive mode */ 1362 pbwidth_t width; /*!< Receive passband width associated with mode */ 1363 1364 freq_t tx_freq; /*!< Transmit frequency */ 1365 rmode_t tx_mode; /*!< Transmit mode */ 1366 pbwidth_t tx_width; /*!< Transmit passband width associated with mode */ 1367 1368 split_t split; /*!< Split mode */ 1369 vfo_t tx_vfo; /*!< Split transmit VFO */ 1370 1371 rptr_shift_t rptr_shift; /*!< Repeater shift */ 1372 shortfreq_t rptr_offs; /*!< Repeater offset */ 1373 shortfreq_t tuning_step; /*!< Tuning step */ 1374 shortfreq_t rit; /*!< RIT */ 1375 shortfreq_t xit; /*!< XIT */ 1376 setting_t funcs; /*!< Function status */ 1377 value_t levels[RIG_SETTING_MAX]; /*!< Level values */ 1378 tone_t ctcss_tone; /*!< CTCSS tone */ 1379 tone_t ctcss_sql; /*!< CTCSS squelch tone */ 1380 tone_t dcs_code; /*!< DCS code */ 1381 tone_t dcs_sql; /*!< DCS squelch code */ 1382 int scan_group; /*!< Scan group */ 1383 unsigned int flags; /*!< Channel flags, see RIG_CHFLAG's */ 1384 char channel_desc[HAMLIB_MAXCHANDESC]; /*!< Name */ 1385 struct ext_list 1386 *ext_levels; /*!< Extension level value list, NULL ended. ext_levels can be NULL */ 1387 }; 1388 1389 /** 1390 * \brief Channel structure typedef 1391 */ 1392 typedef struct channel channel_t; 1393 1394 /** 1395 * \brief Channel capability definition 1396 * 1397 * Definition of the attributes that can be stored/retrieved in/from memory 1398 */ 1399 struct channel_cap { 1400 unsigned bank_num: 1; /*!< Bank number */ 1401 unsigned vfo: 1; /*!< VFO */ 1402 unsigned ant: 1; /*!< Selected antenna */ 1403 unsigned freq: 1; /*!< Receive frequency */ 1404 unsigned mode: 1; /*!< Receive mode */ 1405 unsigned width: 1; /*!< Receive passband width associated with mode */ 1406 1407 unsigned tx_freq: 1; /*!< Transmit frequency */ 1408 unsigned tx_mode: 1; /*!< Transmit mode */ 1409 unsigned tx_width: 1; /*!< Transmit passband width associated with mode */ 1410 1411 unsigned split: 1; /*!< Split mode */ 1412 unsigned tx_vfo: 1; /*!< Split transmit VFO */ 1413 unsigned rptr_shift: 1; /*!< Repeater shift */ 1414 unsigned rptr_offs: 1; /*!< Repeater offset */ 1415 unsigned tuning_step: 1; /*!< Tuning step */ 1416 unsigned rit: 1; /*!< RIT */ 1417 unsigned xit: 1; /*!< XIT */ 1418 setting_t funcs; /*!< Function status */ 1419 setting_t levels; /*!< Level values */ 1420 unsigned ctcss_tone: 1; /*!< CTCSS tone */ 1421 unsigned ctcss_sql: 1; /*!< CTCSS squelch tone */ 1422 unsigned dcs_code: 1; /*!< DCS code */ 1423 unsigned dcs_sql: 1; /*!< DCS squelch code */ 1424 unsigned scan_group: 1; /*!< Scan group */ 1425 unsigned flags: 1; /*!< Channel flags */ 1426 unsigned channel_desc: 1; /*!< Name */ 1427 unsigned ext_levels: 1; /*!< Extension level value list */ 1428 }; 1429 1430 /** 1431 * \brief Channel cap 1432 */ 1433 typedef struct channel_cap channel_cap_t; 1434 1435 1436 /** 1437 * \brief Memory channel type definition 1438 * 1439 * Definition of memory types. Depending on the type, the content 1440 * of the memory channel has to be interpreted accordingly. 1441 * For instance, a RIG_MTYPE_EDGE channel_t will hold only a start 1442 * or stop frequency. 1443 * 1444 * \sa chan_list() 1445 */ 1446 typedef enum { 1447 RIG_MTYPE_NONE = 0, /*!< None */ 1448 RIG_MTYPE_MEM, /*!< Regular */ 1449 RIG_MTYPE_EDGE, /*!< Scan edge */ 1450 RIG_MTYPE_CALL, /*!< Call channel */ 1451 RIG_MTYPE_MEMOPAD, /*!< Memory pad */ 1452 RIG_MTYPE_SAT, /*!< Satellite */ 1453 RIG_MTYPE_BAND, /*!< VFO/Band channel */ 1454 RIG_MTYPE_PRIO /*!< Priority channel */ 1455 } chan_type_t; 1456 1457 1458 /** 1459 * \brief Memory channel list definition 1460 * 1461 * Example for the Ic706MkIIG (99 memory channels, 2 scan edges, 2 call chans): 1462 \code 1463 chan_t chan_list[] = { 1464 { 1, 99, RIG_MTYPE_MEM }, 1465 { 100, 103, RIG_MTYPE_EDGE }, 1466 { 104, 105, RIG_MTYPE_CALL }, 1467 RIG_CHAN_END 1468 } 1469 \endcode 1470 */ 1471 struct chan_list { 1472 int startc; /*!< Starting memory channel \b number */ 1473 int endc; /*!< Ending memory channel \b number */ 1474 chan_type_t type; /*!< Memory type. see chan_type_t */ 1475 channel_cap_t 1476 mem_caps; /*!< Definition of attributes that can be stored/retrieved */ 1477 }; 1478 1479 //! @cond Doxygen_Suppress 1480 #define RIG_CHAN_END {0,0,RIG_MTYPE_NONE} 1481 #define RIG_IS_CHAN_END(c) ((c).type == RIG_MTYPE_NONE) 1482 //! @endcond 1483 1484 /** 1485 * \brief Special memory channel value to tell rig_lookup_mem_caps() to retrieve all the ranges 1486 */ 1487 #define RIG_MEM_CAPS_ALL -1 1488 1489 /** 1490 * \brief chan_t type 1491 */ 1492 typedef struct chan_list chan_t; 1493 1494 1495 /** 1496 * \brief level/parm granularity definition 1497 * 1498 * The granularity is undefined if min = 0, max = 0, and step = 0. 1499 * 1500 * For float settings, if min.f = 0 and max.f = 0 (and step.f! = 0), max.f is 1501 * assumed to be actually equal to 1.0. 1502 * 1503 * If step = 0 (and min and/or max are not null), then this means step can 1504 * have maximum resolution, depending on type (int or float). 1505 */ 1506 struct gran { 1507 value_t min; /*!< Minimum value */ 1508 value_t max; /*!< Maximum value */ 1509 value_t step; /*!< Step */ 1510 }; 1511 1512 /** 1513 * \brief gran_t type 1514 */ 1515 typedef struct gran gran_t; 1516 1517 1518 /** 1519 * \brief Calibration table struct 1520 */ 1521 struct cal_table { 1522 int size; /*!< number of plots in the table */ 1523 struct { 1524 int raw; /*!< raw (A/D) value, as returned by \a RIG_LEVEL_RAWSTR */ 1525 int val; /*!< associated value, basically the measured dB value */ 1526 } table[HAMLIB_MAX_CAL_LENGTH]; /*!< table of plots */ 1527 }; 1528 1529 /** 1530 * \brief calibration table type 1531 * 1532 * cal_table_t is a data type suited to hold linear calibration. 1533 * cal_table_t.size tells the number of plots cal_table_t.table contains. 1534 * 1535 * If a value is below or equal to cal_table_t.table[0].raw, 1536 * rig_raw2val() will return cal_table_t.table[0].val. 1537 * 1538 * If a value is greater or equal to cal_table_t.table[cal_table_t.size-1].raw, 1539 * rig_raw2val() will return cal_table_t.table[cal_table_t.size-1].val. 1540 */ 1541 typedef struct cal_table cal_table_t; 1542 1543 //! @cond Doxygen_Suppress 1544 #define EMPTY_STR_CAL { 0, { { 0, 0 }, } } 1545 //! @endcond Doxygen_Suppress 1546 1547 1548 /** 1549 * \brief Calibration table struct for float values 1550 */ 1551 struct cal_table_float { 1552 int size; /*!< number of plots in the table */ 1553 struct { 1554 int raw; /*!< raw (A/D) value */ 1555 float val; /*!< associated value */ 1556 } table[HAMLIB_MAX_CAL_LENGTH]; /*!< table of plots */ 1557 }; 1558 1559 /** 1560 * \brief calibration table type for float values 1561 * 1562 * cal_table_float_t is a data type suited to hold linear calibration. 1563 * cal_table_float_t.size tells the number of plots cal_table_float_t.table contains. 1564 * 1565 * If a value is below or equal to cal_table_float_t.table[0].raw, 1566 * rig_raw2val_float() will return cal_table_float_t.table[0].val. 1567 * 1568 * If a value is greater or equal to cal_table_float_t.table[cal_table_float_t.size-1].raw, 1569 * rig_raw2val_float() will return cal_table_float_t.table[cal_table_float_t.size-1].val. 1570 */ 1571 typedef struct cal_table_float cal_table_float_t; 1572 1573 //! @cond Doxygen_Suppress 1574 #define EMPTY_FLOAT_CAL { 0, { { 0, 0f }, } } 1575 1576 typedef int (* chan_cb_t)(RIG *, channel_t **, int, const chan_t *, rig_ptr_t); 1577 typedef int (* confval_cb_t)(RIG *, 1578 const struct confparams *, 1579 value_t *, 1580 rig_ptr_t); 1581 //! @endcond 1582 1583 1584 /** 1585 * \brief Rig data structure. 1586 * 1587 * Basic rig type, can store some useful info about different radios. Each 1588 * backend must be able to populate this structure, so we can make useful 1589 * inquiries about capabilities. 1590 * 1591 * The main idea of this struct is that it will be defined by the backend rig 1592 * driver, and will remain readonly for the application. Fields that need to 1593 * be modifiable by the application are copied into the struct rig_state, 1594 * which is a kind of private storage of the RIG instance. 1595 * 1596 * This way, you can have several rigs running within the same application, 1597 * sharing the struct rig_caps of the backend, while keeping their own 1598 * customized data. 1599 * 1600 * mdblack: Don't move or add fields around without bumping the version numbers 1601 * DLL or shared library replacement depends on order 1602 */ 1603 //! @cond Doxygen_Suppress 1604 #define RIG_MODEL(arg) .rig_model=arg,.macro_name=#arg 1605 struct rig_caps { 1606 rig_model_t rig_model; /*!< Rig model. */ 1607 const char *model_name; /*!< Model name. */ 1608 const char *mfg_name; /*!< Manufacturer. */ 1609 const char *version; /*!< Driver version. */ 1610 const char *copyright; /*!< Copyright info. */ 1611 enum rig_status_e status; /*!< Driver status. */ 1612 1613 int rig_type; /*!< Rig type. */ 1614 ptt_type_t ptt_type; /*!< Type of the PTT port. */ 1615 dcd_type_t dcd_type; /*!< Type of the DCD port. */ 1616 rig_port_t port_type; /*!< Type of communication port. */ 1617 1618 int serial_rate_min; /*!< Minimum serial speed. */ 1619 int serial_rate_max; /*!< Maximum serial speed. */ 1620 int serial_data_bits; /*!< Number of data bits. */ 1621 int serial_stop_bits; /*!< Number of stop bits. */ 1622 enum serial_parity_e serial_parity; /*!< Parity. */ 1623 enum serial_handshake_e serial_handshake; /*!< Handshake. */ 1624 1625 int write_delay; /*!< Delay between each byte sent out, in mS */ 1626 int post_write_delay; /*!< Delay between each commands send out, in mS */ 1627 int timeout; /*!< Timeout, in mS */ 1628 int retry; /*!< Maximum number of retries if command fails, 0 to disable */ 1629 1630 setting_t has_get_func; /*!< List of get functions */ 1631 setting_t has_set_func; /*!< List of set functions */ 1632 setting_t has_get_level; /*!< List of get level */ 1633 setting_t has_set_level; /*!< List of set level */ 1634 setting_t has_get_parm; /*!< List of get parm */ 1635 setting_t has_set_parm; /*!< List of set parm */ 1636 1637 gran_t level_gran[RIG_SETTING_MAX]; /*!< level granularity (i.e. steps) */ 1638 gran_t parm_gran[RIG_SETTING_MAX]; /*!< parm granularity (i.e. steps) */ 1639 1640 const struct confparams *extparms; /*!< Extension parm list, \sa ext.c */ 1641 const struct confparams *extlevels; /*!< Extension level list, \sa ext.c */ 1642 const struct confparams *extfuncs; /*!< Extension func list, \sa ext.c */ 1643 int *ext_tokens; /*!< Extension token list */ 1644 1645 tone_t *ctcss_list; /*!< CTCSS tones list, zero ended */ 1646 tone_t *dcs_list; /*!< DCS code list, zero ended */ 1647 1648 int preamp[HAMLIB_MAXDBLSTSIZ]; /*!< Preamp list in dB, 0 terminated */ 1649 int attenuator[HAMLIB_MAXDBLSTSIZ]; /*!< Preamp list in dB, 0 terminated */ 1650 shortfreq_t max_rit; /*!< max absolute RIT */ 1651 shortfreq_t max_xit; /*!< max absolute XIT */ 1652 shortfreq_t max_ifshift; /*!< max absolute IF-SHIFT */ 1653 1654 ann_t announces; /*!< Announces bit field list */ 1655 1656 vfo_op_t vfo_ops; /*!< VFO op bit field list */ 1657 scan_t scan_ops; /*!< Scan bit field list */ 1658 int targetable_vfo; /*!< Bit field list of direct VFO access commands */ 1659 int transceive; /*!< Supported transceive mode */ 1660 1661 int bank_qty; /*!< Number of banks */ 1662 int chan_desc_sz; /*!< Max length of memory channel name */ 1663 1664 chan_t chan_list[HAMLIB_CHANLSTSIZ]; /*!< Channel list, zero ended */ 1665 1666 // As of 2020-02-12 we know of 5 models from Icom USA, EUR, ITR, TPE, KOR for the IC-9700 1667 // So we currently have 5 ranges we need to deal with 1668 // The backend for the model should fill in the label field to explain what model it is 1669 // The the IC-9700 in ic7300.c for an example 1670 freq_range_t rx_range_list1[HAMLIB_FRQRANGESIZ]; /*!< Receive frequency range list #1 */ 1671 freq_range_t tx_range_list1[HAMLIB_FRQRANGESIZ]; /*!< Transmit frequency range list #1 */ 1672 freq_range_t rx_range_list2[HAMLIB_FRQRANGESIZ]; /*!< Receive frequency range list #2 */ 1673 freq_range_t tx_range_list2[HAMLIB_FRQRANGESIZ]; /*!< Transmit frequency range list #2 */ 1674 freq_range_t rx_range_list3[HAMLIB_FRQRANGESIZ]; /*!< Receive frequency range list #3 */ 1675 freq_range_t tx_range_list3[HAMLIB_FRQRANGESIZ]; /*!< Transmit frequency range list #3 */ 1676 freq_range_t rx_range_list4[HAMLIB_FRQRANGESIZ]; /*!< Receive frequency range list #4 */ 1677 freq_range_t tx_range_list4[HAMLIB_FRQRANGESIZ]; /*!< Transmit frequency range list #4 */ 1678 freq_range_t rx_range_list5[HAMLIB_FRQRANGESIZ]; /*!< Receive frequency range list #5 */ 1679 freq_range_t tx_range_list5[HAMLIB_FRQRANGESIZ]; /*!< Transmit frequency range list #5 */ 1680 1681 struct tuning_step_list tuning_steps[HAMLIB_TSLSTSIZ]; /*!< Tuning step list */ 1682 struct filter_list filters[HAMLIB_FLTLSTSIZ]; /*!< mode/filter table, at -6dB */ 1683 1684 cal_table_t str_cal; /*!< S-meter calibration table */ 1685 cal_table_float_t swr_cal; /*!< SWR meter calibration table */ 1686 cal_table_float_t alc_cal; /*!< ALC meter calibration table */ 1687 cal_table_float_t rfpower_meter_cal; /*!< RF power meter calibration table */ 1688 cal_table_float_t comp_meter_cal; /*!< COMP meter calibration table */ 1689 cal_table_float_t vd_meter_cal; /*!< Voltage meter calibration table */ 1690 cal_table_float_t id_meter_cal; /*!< Current draw meter calibration table */ 1691 1692 const struct confparams *cfgparams; /*!< Configuration parametres. */ 1693 const rig_ptr_t priv; /*!< Private data. */ 1694 1695 /* 1696 * Rig API 1697 * 1698 */ 1699 1700 int (*rig_init)(RIG *rig); 1701 int (*rig_cleanup)(RIG *rig); 1702 int (*rig_open)(RIG *rig); 1703 int (*rig_close)(RIG *rig); 1704 1705 /* 1706 * General API commands, from most primitive to least.. :() 1707 * List Set/Get functions pairs 1708 */ 1709 1710 int (*set_freq)(RIG *rig, vfo_t vfo, freq_t freq); 1711 int (*get_freq)(RIG *rig, vfo_t vfo, freq_t *freq); 1712 1713 int (*set_mode)(RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width); 1714 int (*get_mode)(RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width); 1715 1716 int (*set_vfo)(RIG *rig, vfo_t vfo); 1717 int (*get_vfo)(RIG *rig, vfo_t *vfo); 1718 1719 int (*set_ptt)(RIG *rig, vfo_t vfo, ptt_t ptt); 1720 int (*get_ptt)(RIG *rig, vfo_t vfo, ptt_t *ptt); 1721 1722 int (*get_dcd)(RIG *rig, vfo_t vfo, dcd_t *dcd); 1723 1724 int (*set_rptr_shift)(RIG *rig, vfo_t vfo, rptr_shift_t rptr_shift); 1725 int (*get_rptr_shift)(RIG *rig, vfo_t vfo, rptr_shift_t *rptr_shift); 1726 1727 int (*set_rptr_offs)(RIG *rig, vfo_t vfo, shortfreq_t offs); 1728 int (*get_rptr_offs)(RIG *rig, vfo_t vfo, shortfreq_t *offs); 1729 1730 int (*set_split_freq)(RIG *rig, vfo_t vfo, freq_t tx_freq); 1731 int (*get_split_freq)(RIG *rig, vfo_t vfo, freq_t *tx_freq); 1732 1733 int (*set_split_mode)(RIG *rig, 1734 vfo_t vfo, 1735 rmode_t tx_mode, 1736 pbwidth_t tx_width); 1737 int (*get_split_mode)(RIG *rig, 1738 vfo_t vfo, 1739 rmode_t *tx_mode, 1740 pbwidth_t *tx_width); 1741 1742 int (*set_split_freq_mode)(RIG *rig, 1743 vfo_t vfo, 1744 freq_t tx_freq, 1745 rmode_t tx_mode, 1746 pbwidth_t tx_width); 1747 int (*get_split_freq_mode)(RIG *rig, 1748 vfo_t vfo, 1749 freq_t *tx_freq, 1750 rmode_t *tx_mode, 1751 pbwidth_t *tx_width); 1752 1753 int (*set_split_vfo)(RIG *rig, vfo_t vfo, split_t split, vfo_t tx_vfo); 1754 int (*get_split_vfo)(RIG *rig, vfo_t vfo, split_t *split, vfo_t *tx_vfo); 1755 1756 int (*set_rit)(RIG *rig, vfo_t vfo, shortfreq_t rit); 1757 int (*get_rit)(RIG *rig, vfo_t vfo, shortfreq_t *rit); 1758 1759 int (*set_xit)(RIG *rig, vfo_t vfo, shortfreq_t xit); 1760 int (*get_xit)(RIG *rig, vfo_t vfo, shortfreq_t *xit); 1761 1762 int (*set_ts)(RIG *rig, vfo_t vfo, shortfreq_t ts); 1763 int (*get_ts)(RIG *rig, vfo_t vfo, shortfreq_t *ts); 1764 1765 int (*set_dcs_code)(RIG *rig, vfo_t vfo, tone_t code); 1766 int (*get_dcs_code)(RIG *rig, vfo_t vfo, tone_t *code); 1767 1768 int (*set_tone)(RIG *rig, vfo_t vfo, tone_t tone); 1769 int (*get_tone)(RIG *rig, vfo_t vfo, tone_t *tone); 1770 1771 int (*set_ctcss_tone)(RIG *rig, vfo_t vfo, tone_t tone); 1772 int (*get_ctcss_tone)(RIG *rig, vfo_t vfo, tone_t *tone); 1773 1774 int (*set_dcs_sql)(RIG *rig, vfo_t vfo, tone_t code); 1775 int (*get_dcs_sql)(RIG *rig, vfo_t vfo, tone_t *code); 1776 1777 int (*set_tone_sql)(RIG *rig, vfo_t vfo, tone_t tone); 1778 int (*get_tone_sql)(RIG *rig, vfo_t vfo, tone_t *tone); 1779 1780 int (*set_ctcss_sql)(RIG *rig, vfo_t vfo, tone_t tone); 1781 int (*get_ctcss_sql)(RIG *rig, vfo_t vfo, tone_t *tone); 1782 1783 int (*power2mW)(RIG *rig, 1784 unsigned int *mwpower, 1785 float power, 1786 freq_t freq, 1787 rmode_t mode); 1788 int (*mW2power)(RIG *rig, 1789 float *power, 1790 unsigned int mwpower, 1791 freq_t freq, 1792 rmode_t mode); 1793 1794 int (*set_powerstat)(RIG *rig, powerstat_t status); 1795 int (*get_powerstat)(RIG *rig, powerstat_t *status); 1796 1797 int (*reset)(RIG *rig, reset_t reset); 1798 1799 int (*set_ant)(RIG *rig, vfo_t vfo, ant_t ant, value_t option); 1800 int (*get_ant)(RIG *rig, vfo_t vfo, ant_t ant, value_t *option, ant_t *ant_curr, ant_t *ant_tx, ant_t *ant_rx); 1801 1802 int (*set_level)(RIG *rig, vfo_t vfo, setting_t level, value_t val); 1803 int (*get_level)(RIG *rig, vfo_t vfo, setting_t level, value_t *val); 1804 1805 int (*set_func)(RIG *rig, vfo_t vfo, setting_t func, int status); 1806 int (*get_func)(RIG *rig, vfo_t vfo, setting_t func, int *status); 1807 1808 int (*set_parm)(RIG *rig, setting_t parm, value_t val); 1809 int (*get_parm)(RIG *rig, setting_t parm, value_t *val); 1810 1811 int (*set_ext_level)(RIG *rig, vfo_t vfo, token_t token, value_t val); 1812 int (*get_ext_level)(RIG *rig, vfo_t vfo, token_t token, value_t *val); 1813 1814 int (*set_ext_func)(RIG *rig, vfo_t vfo, token_t token, int status); 1815 int (*get_ext_func)(RIG *rig, vfo_t vfo, token_t token, int *status); 1816 1817 int (*set_ext_parm)(RIG *rig, token_t token, value_t val); 1818 int (*get_ext_parm)(RIG *rig, token_t token, value_t *val); 1819 1820 int (*set_conf)(RIG *rig, token_t token, const char *val); 1821 int (*get_conf)(RIG *rig, token_t token, char *val); 1822 1823 int (*send_dtmf)(RIG *rig, vfo_t vfo, const char *digits); 1824 int (*recv_dtmf)(RIG *rig, vfo_t vfo, char *digits, int *length); 1825 1826 int (*send_morse)(RIG *rig, vfo_t vfo, const char *msg); 1827 int (*stop_morse)(RIG *rig, vfo_t vfo); 1828 int (*wait_morse)(RIG *rig, vfo_t vfo); 1829 1830 int (*send_voice_mem)(RIG *rig, vfo_t vfo, int ch); 1831 1832 int (*set_bank)(RIG *rig, vfo_t vfo, int bank); 1833 1834 int (*set_mem)(RIG *rig, vfo_t vfo, int ch); 1835 int (*get_mem)(RIG *rig, vfo_t vfo, int *ch); 1836 1837 int (*vfo_op)(RIG *rig, vfo_t vfo, vfo_op_t op); 1838 1839 int (*scan)(RIG *rig, vfo_t vfo, scan_t scan, int ch); 1840 1841 int (*set_trn)(RIG *rig, int trn); 1842 int (*get_trn)(RIG *rig, int *trn); 1843 1844 int (*decode_event)(RIG *rig); 1845 1846 int (*set_channel)(RIG *rig, vfo_t vfo, const channel_t *chan); 1847 int (*get_channel)(RIG *rig, vfo_t vfo, channel_t *chan, int read_only); 1848 1849 const char * (*get_info)(RIG *rig); 1850 1851 int (*set_chan_all_cb)(RIG *rig, vfo_t vfo, chan_cb_t chan_cb, rig_ptr_t); 1852 int (*get_chan_all_cb)(RIG *rig, vfo_t vfo, chan_cb_t chan_cb, rig_ptr_t); 1853 1854 int (*set_mem_all_cb)(RIG *rig, 1855 chan_cb_t chan_cb, 1856 confval_cb_t parm_cb, 1857 rig_ptr_t); 1858 int (*get_mem_all_cb)(RIG *rig, 1859 chan_cb_t chan_cb, 1860 confval_cb_t parm_cb, 1861 rig_ptr_t); 1862 1863 int (*set_vfo_opt)(RIG *rig, int status); // only for Net Rigctl device 1864 int (*rig_get_vfo_info) (RIG *rig, 1865 vfo_t vfo, 1866 freq_t *freq, 1867 rmode_t *mode, 1868 pbwidth_t *width, 1869 split_t *split); 1870 1871 const char *clone_combo_set; /*!< String describing key combination to enter load cloning mode */ 1872 const char *clone_combo_get; /*!< String describing key combination to enter save cloning mode */ 1873 const char *macro_name; /*!< Rig model macro name */ 1874 }; 1875 //! @endcond 1876 1877 /** 1878 * \brief Enumeration of all rig_ functions 1879 * 1880 */ 1881 //! @cond Doxygen_Suppress 1882 // all functions enumerated for rig_get_function_ptr 1883 enum rig_function_e { 1884 RIG_FUNCTION_INIT, 1885 RIG_FUNCTION_CLEANUP, 1886 RIG_FUNCTION_OPEN, 1887 RIG_FUNCTION_CLOSE, 1888 RIG_FUNCTION_SET_FREQ, 1889 RIG_FUNCTION_GET_FREQ, 1890 RIG_FUNCTION_SET_MODE, 1891 RIG_FUNCTION_GET_MODE, 1892 RIG_FUNCTION_SET_VFO, 1893 RIG_FUNCTION_GET_VFO, 1894 RIG_FUNCTION_SET_PTT, 1895 RIG_FUNCTION_GET_PTT, 1896 RIG_FUNCTION_GET_DCD, 1897 RIG_FUNCTION_SET_RPTR_SHIFT, 1898 RIG_FUNCTION_GET_RPTR_SHIFT, 1899 RIG_FUNCTION_SET_RPTR_OFFS, 1900 RIG_FUNCTION_GET_RPTR_OFFS, 1901 RIG_FUNCTION_SET_SPLIT_FREQ, 1902 RIG_FUNCTION_GET_SPLIT_FREQ, 1903 RIG_FUNCTION_SET_SPLIT_MODE, 1904 RIG_FUNCTION_SET_SPLIT_FREQ_MODE, 1905 RIG_FUNCTION_GET_SPLIT_FREQ_MODE, 1906 RIG_FUNCTION_SET_SPLIT_VFO, 1907 RIG_FUNCTION_GET_SPLIT_VFO, 1908 RIG_FUNCTION_SET_RIT, 1909 RIG_FUNCTION_GET_RIT, 1910 RIG_FUNCTION_SET_XIT, 1911 RIG_FUNCTION_GET_XIT, 1912 RIG_FUNCTION_SET_TS, 1913 RIG_FUNCTION_GET_TS, 1914 RIG_FUNCTION_SET_DCS_CODE, 1915 RIG_FUNCTION_GET_DCS_CODE, 1916 RIG_FUNCTION_SET_TONE, 1917 RIG_FUNCTION_GET_TONE, 1918 RIG_FUNCTION_SET_CTCSS_TONE, 1919 RIG_FUNCTION_GET_CTCSS_TONE, 1920 RIG_FUNCTION_SET_DCS_SQL, 1921 RIG_FUNCTION_GET_DCS_SQL, 1922 RIG_FUNCTION_SET_TONE_SQL, 1923 RIG_FUNCTION_GET_TONE_SQL, 1924 RIG_FUNCTION_SET_CTCSS_SQL, 1925 RIG_FUNCTION_GET_CTCSS_SQL, 1926 RIG_FUNCTION_POWER2MW, 1927 RIG_FUNCTION_MW2POWER, 1928 RIG_FUNCTION_SET_POWERSTAT, 1929 RIG_FUNCTION_GET_POWERSTAT, 1930 RIG_FUNCTION_RESET, 1931 RIG_FUNCTION_SET_ANT, 1932 RIG_FUNCTION_GET_ANT, 1933 RIG_FUNCTION_SET_LEVEL, 1934 RIG_FUNCTION_GET_LEVEL, 1935 RIG_FUNCTION_SET_FUNC, 1936 RIG_FUNCTION_GET_FUNC, 1937 RIG_FUNCTION_SET_PARM, 1938 RIG_FUNCTION_GET_PARM, 1939 RIG_FUNCTION_SET_EXT_LEVEL, 1940 RIG_FUNCTION_GET_EXT_LEVEL, 1941 RIG_FUNCTION_SET_EXT_FUNC, 1942 RIG_FUNCTION_GET_EXT_FUNC, 1943 RIG_FUNCTION_SET_EXT_PARM, 1944 RIG_FUNCTION_GET_EXT_PARM, 1945 RIG_FUNCTION_SET_CONF, 1946 RIG_FUNCTION_GET_CONF, 1947 RIG_FUNCTION_SEND_DTMF, 1948 RIG_FUNCTION_SEND_MORSE, 1949 RIG_FUNCTION_STOP_MORSE, 1950 RIG_FUNCTION_WAIT_MORSE, 1951 RIG_FUNCTION_SEND_VOICE_MEM, 1952 RIG_FUNCTION_SET_BANK, 1953 RIG_FUNCTION_SET_MEM, 1954 RIG_FUNCTION_GET_MEM, 1955 RIG_FUNCTION_VFO_OP, 1956 RIG_FUNCTION_SCAN, 1957 RIG_FUNCTION_SET_TRN, 1958 RIG_FUNCTION_GET_TRN, 1959 RIG_FUNCTION_DECODE_EVENT, 1960 RIG_FUNCTION_SET_CHANNEL, 1961 RIG_FUNCTION_GET_CHANNEL, 1962 RIG_FUNCTION_GET_INFO, 1963 RIG_FUNCTION_SET_CHAN_ALL_CB, 1964 RIG_FUNCTION_GET_CHAN_ALL_CB, 1965 RIG_FUNCTION_SET_MEM_ALL_CB, 1966 RIG_FUNCTION_GET_MEM_ALL_CB, 1967 RIG_FUNCTION_SET_VFO_OPT 1968 }; 1969 1970 /** 1971 * \brief Function to return pointer to rig_* function 1972 * 1973 */ 1974 //! @cond Doxygen_Suppress 1975 extern HAMLIB_EXPORT (void *) rig_get_function_ptr(rig_model_t rig_model, enum rig_function_e rig_function); 1976 1977 /** 1978 * \brief Enumeration of rig->caps values 1979 * 1980 */ 1981 //! @cond Doxygen_Suppress 1982 // values enumerated for rig->caps values 1983 enum rig_caps_int_e { 1984 RIG_CAPS_TARGETABLE_VFO, 1985 RIG_CAPS_RIG_MODEL, 1986 RIG_CAPS_PORT_TYPE, 1987 RIG_CAPS_PTT_TYPE, 1988 RIG_CAPS_HAS_GET_LEVEL 1989 }; 1990 1991 enum rig_caps_cptr_e { 1992 RIG_CAPS_VERSION_CPTR, 1993 RIG_CAPS_MFG_NAME_CPTR, 1994 RIG_CAPS_MODEL_NAME_CPTR, 1995 RIG_CAPS_STATUS_CPTR 1996 }; 1997 1998 /** 1999 * \brief Function to return int value from rig->caps 2000 * Does not support > 32-bit rig_caps values 2001 */ 2002 //! @cond Doxygen_Suppress 2003 extern HAMLIB_EXPORT (long long) rig_get_caps_int(rig_model_t rig_model, enum rig_caps_int_e rig_caps); 2004 2005 /** 2006 * \brief Function to return char pointer value from rig->caps 2007 * 2008 */ 2009 //! @cond Doxygen_Suppress 2010 extern HAMLIB_EXPORT (const char *) rig_get_caps_cptr(rig_model_t rig_model, enum rig_caps_cptr_e rig_caps); 2011 2012 /** 2013 * \brief Port definition 2014 * 2015 * Of course, looks like OO painstakingly programmed in C, sigh. 2016 */ 2017 //! @cond Doxygen_Suppress 2018 typedef struct hamlib_port { 2019 union { 2020 rig_port_t rig; /*!< Communication port type */ 2021 ptt_type_t ptt; /*!< PTT port type */ 2022 dcd_type_t dcd; /*!< DCD port type */ 2023 } type; 2024 2025 int fd; /*!< File descriptor */ 2026 void *handle; /*!< handle for USB */ 2027 2028 int write_delay; /*!< Delay between each byte sent out, in mS */ 2029 int post_write_delay; /*!< Delay between each commands send out, in mS */ 2030 2031 struct { 2032 int tv_sec, tv_usec; 2033 } post_write_date; /*!< hamlib internal use */ 2034 2035 int timeout; /*!< Timeout, in mS */ 2036 short retry; /*!< Maximum number of retries, 0 to disable */ 2037 short flushx; /*!< If true flush is done with read instead of TCFLUSH - MicroHam */ 2038 2039 char pathname[HAMLIB_FILPATHLEN]; /*!< Port pathname */ 2040 2041 union { 2042 struct { 2043 int rate; /*!< Serial baud rate */ 2044 int data_bits; /*!< Number of data bits */ 2045 int stop_bits; /*!< Number of stop bits */ 2046 enum serial_parity_e parity; /*!< Serial parity */ 2047 enum serial_handshake_e handshake; /*!< Serial handshake */ 2048 enum serial_control_state_e rts_state; /*!< RTS set state */ 2049 enum serial_control_state_e dtr_state; /*!< DTR set state */ 2050 } serial; /*!< serial attributes */ 2051 2052 struct { 2053 int pin; /*!< Parallel port pin number */ 2054 } parallel; /*!< parallel attributes */ 2055 2056 struct { 2057 int ptt_bitnum; /*!< Bit number for CM108 GPIO PTT */ 2058 } cm108; /*!< CM108 attributes */ 2059 2060 struct { 2061 int vid; /*!< Vendor ID */ 2062 int pid; /*!< Product ID */ 2063 int conf; /*!< Configuration */ 2064 int iface; /*!< interface */ 2065 int alt; /*!< alternate */ 2066 char *vendor_name; /*!< Vendor name (opt.) */ 2067 char *product; /*!< Product (opt.) */ 2068 } usb; /*!< USB attributes */ 2069 2070 struct { 2071 int on_value; /*!< GPIO: 1 == normal, GPION: 0 == inverted */ 2072 int value; /*!< Toggle PTT ON or OFF */ 2073 } gpio; /*!< GPIO attributes */ 2074 } parm; /*!< Port parameter union */ 2075 } hamlib_port_t; 2076 //! @endcond 2077 2078 #if !defined(__APPLE__) || !defined(__cplusplus) 2079 typedef hamlib_port_t port_t; 2080 #endif 2081 2082 #define HAMLIB_ELAPSED_GET 0 2083 #define HAMLIB_ELAPSED_SET 1 2084 #define HAMLIB_ELAPSED_INVALIDATE 2 2085 2086 typedef enum { 2087 HAMLIB_CACHE_ALL, // to set all cache timeouts at once 2088 HAMLIB_CACHE_VFO, 2089 HAMLIB_CACHE_FREQ, 2090 HAMLIB_CACHE_MODE, 2091 HAMLIB_CACHE_PTT, 2092 HAMLIB_CACHE_SPLIT, 2093 HAMLIB_CACHE_WIDTH 2094 } hamlib_cache_t; 2095 2096 typedef enum { 2097 TWIDDLE_OFF, 2098 TWIDDLE_ON 2099 } twiddle_state_t; 2100 2101 /** 2102 * \brief Rig cache data 2103 * 2104 * This struct contains all the items we cache at the highest level 2105 */ 2106 struct rig_cache { 2107 int timeout_ms; // the cache timeout for invalidating itself 2108 vfo_t vfo; 2109 //freq_t freq; // to be deprecated in 4.1 when full Main/Sub/A/B caching is implemented in 4.1 2110 // other abstraction here is based on dual vfo rigs and mapped to all others 2111 // So we have four possible states of rig 2112 // MainA, MainB, SubA, SubB 2113 // Main is the Main VFO and Sub is for the 2nd VFO 2114 // Most rigs have MainA and MainB 2115 // Dual VFO rigs can have SubA and SubB too 2116 // For dual VFO rigs simplex operations are all done on MainA/MainB -- ergo this abstraction 2117 freq_t freqMainA; // VFO_A, VFO_MAIN, and VFO_MAINA 2118 freq_t freqMainB; // VFO_B, VFO_SUB, and VFO_MAINB 2119 freq_t freqMainC; // VFO_C, VFO_MAINC 2120 freq_t freqSubA; // VFO_SUBA -- only for rigs with dual Sub VFOs 2121 freq_t freqSubB; // VFO_SUBB -- only for rigs with dual Sub VFOs 2122 freq_t freqSubC; // VFO_SUBC -- only for rigs with 3 Sub VFOs 2123 freq_t freqMem; // VFO_MEM -- last MEM channel 2124 rmode_t modeMainA; 2125 rmode_t modeMainB; 2126 rmode_t modeMainC; 2127 rmode_t modeSubA; 2128 rmode_t modeSubB; 2129 rmode_t modeSubC; 2130 rmode_t modeMem; 2131 pbwidth_t widthMainA; // if non-zero then rig has separate width for MainA 2132 pbwidth_t widthMainB; // if non-zero then rig has separate width for MainB 2133 pbwidth_t widthMainC; // if non-zero then rig has separate width for MainC 2134 pbwidth_t widthSubA; // if non-zero then rig has separate width for SubA 2135 pbwidth_t widthSubB; // if non-zero then rig has separate width for SubB 2136 pbwidth_t widthSubC; // if non-zero then rig has separate width for SubC 2137 pbwidth_t widthMem; // if non-zero then rig has separate width for Mem 2138 ptt_t ptt; 2139 split_t split; 2140 vfo_t split_vfo; // split caches two values 2141 struct timespec time_freqMainA; 2142 struct timespec time_freqMainB; 2143 struct timespec time_freqMainC; 2144 struct timespec time_freqSubA; 2145 struct timespec time_freqSubB; 2146 struct timespec time_freqSubC; 2147 struct timespec time_freqMem; 2148 struct timespec time_vfo; 2149 struct timespec time_modeMainA; 2150 struct timespec time_modeMainB; 2151 struct timespec time_modeMainC; 2152 struct timespec time_modeSubA; 2153 struct timespec time_modeSubB; 2154 struct timespec time_modeSubC; 2155 struct timespec time_modeMem; 2156 struct timespec time_widthMainA; 2157 struct timespec time_widthMainB; 2158 struct timespec time_widthMainC; 2159 struct timespec time_widthSubA; 2160 struct timespec time_widthSubB; 2161 struct timespec time_widthSubC; 2162 struct timespec time_widthMem; 2163 struct timespec time_ptt; 2164 struct timespec time_split; 2165 int satmode; // if rig is in satellite mode 2166 }; 2167 2168 2169 /** 2170 * \brief Rig state containing live data and customized fields. 2171 * 2172 * This struct contains live data, as well as a copy of capability fields 2173 * that may be updated (ie. customized) 2174 * 2175 * It is NOT fine to move fields around as it can break share library offset 2176 * As of 2021-03-03 vfo_list is the last known item being reference externally 2177 * So any additions or changes to this structure must be after vfo_list. 2178 */ 2179 struct rig_state { 2180 /* 2181 * overridable fields 2182 */ 2183 hamlib_port_t rigport; /*!< Rig port (internal use). */ 2184 hamlib_port_t pttport; /*!< PTT port (internal use). */ 2185 hamlib_port_t dcdport; /*!< DCD port (internal use). */ 2186 2187 double vfo_comp; /*!< VFO compensation in PPM, 0.0 to disable */ 2188 2189 int deprecated_itu_region; /*!< ITU region to select among freq_range_t */ 2190 freq_range_t rx_range_list[HAMLIB_FRQRANGESIZ]; /*!< Receive frequency range list */ 2191 freq_range_t tx_range_list[HAMLIB_FRQRANGESIZ]; /*!< Transmit frequency range list */ 2192 2193 struct tuning_step_list tuning_steps[HAMLIB_TSLSTSIZ]; /*!< Tuning step list */ 2194 2195 struct filter_list filters[HAMLIB_FLTLSTSIZ]; /*!< Mode/filter table, at -6dB */ 2196 2197 cal_table_t str_cal; /*!< S-meter calibration table */ 2198 2199 chan_t chan_list[HAMLIB_CHANLSTSIZ]; /*!< Channel list, zero ended */ 2200 2201 shortfreq_t max_rit; /*!< max absolute RIT */ 2202 shortfreq_t max_xit; /*!< max absolute XIT */ 2203 shortfreq_t max_ifshift; /*!< max absolute IF-SHIFT */ 2204 2205 ann_t announces; /*!< Announces bit field list */ 2206 2207 int preamp[HAMLIB_MAXDBLSTSIZ]; /*!< Preamp list in dB, 0 terminated */ 2208 int attenuator[HAMLIB_MAXDBLSTSIZ]; /*!< Preamp list in dB, 0 terminated */ 2209 2210 setting_t has_get_func; /*!< List of get functions */ 2211 setting_t has_set_func; /*!< List of set functions */ 2212 setting_t has_get_level; /*!< List of get level */ 2213 setting_t has_set_level; /*!< List of set level */ 2214 setting_t has_get_parm; /*!< List of get parm */ 2215 setting_t has_set_parm; /*!< List of set parm */ 2216 2217 gran_t level_gran[RIG_SETTING_MAX]; /*!< level granularity */ 2218 gran_t parm_gran[RIG_SETTING_MAX]; /*!< parm granularity */ 2219 2220 2221 /* 2222 * non overridable fields, internal use 2223 */ 2224 2225 int hold_decode; /*!< set to 1 to hold the event decoder (async) otherwise 0 */ 2226 vfo_t current_vfo; /*!< VFO currently set */ 2227 int vfo_list; /*!< Complete list of VFO for this rig */ 2228 int comm_state; /*!< Comm port state, opened/closed. */ 2229 rig_ptr_t priv; /*!< Pointer to private rig state data. */ 2230 rig_ptr_t obj; /*!< Internal use by hamlib++ for event handling. */ 2231 2232 int transceive; /*!< Whether the transceive mode is on */ 2233 int poll_interval; /*!< Event notification polling period in milliseconds */ 2234 freq_t current_freq; /*!< Frequency currently set */ 2235 rmode_t current_mode; /*!< Mode currently set */ 2236 //rmode_t current_modeB; /*!< Mode currently set VFOB */ 2237 pbwidth_t current_width; /*!< Passband width currently set */ 2238 vfo_t tx_vfo; /*!< Tx VFO currently set */ 2239 rmode_t mode_list; /*!< Complete list of modes for this rig */ 2240 // mode_list is used by some 2241 // so anything added to this structure must be below here 2242 int transmit; /*!< rig should be transmitting i.e. hard 2243 wired PTT asserted - used by rigs that 2244 don't do CAT while in Tx */ 2245 freq_t lo_freq; /*!< Local oscillator frequency of any transverter */ 2246 time_t twiddle_time; /*!< time when vfo twiddling was detected */ 2247 int twiddle_timeout; /*!< timeout to resume from twiddling */ 2248 // uplink allows gpredict to behave better by no reading the uplink VFO 2249 int uplink; /*!< uplink=1 will not read Sub, uplink=2 will not read Main */ 2250 struct rig_cache cache; 2251 int vfo_opt; /*!< Is -o switch turned on? */ 2252 int auto_power_on; /*!< Allow Hamlib to power on rig 2253 automatically if supported */ 2254 int auto_power_off; /*!< Allow Hamlib to power off rig 2255 automatically if supported */ 2256 int auto_disable_screensaver; /*!< Allow Hamlib to disable the 2257 rig's screen saver automatically if 2258 supported */ 2259 int ptt_share; /*!< Share ptt port by open/close during get_ptt, set_ptt hogs the port while active */ 2260 int power_now; /*!< Current RF power level in rig units */ 2261 int power_min; /*!< Minimum RF power level in rig units */ 2262 int power_max; /*!< Maximum RF power level in rig units */ 2263 unsigned char disable_yaesu_bandselect; /*!< Disables Yaeus band select logic */ 2264 int twiddle_rit; /*!< Suppresses VFOB reading (cached value used) so RIT control can be used */ 2265 int twiddle_state; /*!< keeps track of twiddle status */ 2266 }; 2267 2268 //! @cond Doxygen_Suppress 2269 typedef int (*vprintf_cb_t)(enum rig_debug_level_e, 2270 rig_ptr_t, 2271 const char *, 2272 va_list); 2273 2274 typedef int (*freq_cb_t)(RIG *, vfo_t, freq_t, rig_ptr_t); 2275 typedef int (*mode_cb_t)(RIG *, vfo_t, rmode_t, pbwidth_t, rig_ptr_t); 2276 typedef int (*vfo_cb_t)(RIG *, vfo_t, rig_ptr_t); 2277 typedef int (*ptt_cb_t)(RIG *, vfo_t, ptt_t, rig_ptr_t); 2278 typedef int (*dcd_cb_t)(RIG *, vfo_t, dcd_t, rig_ptr_t); 2279 typedef int (*pltune_cb_t)(RIG *, 2280 vfo_t, freq_t *, 2281 rmode_t *, 2282 pbwidth_t *, 2283 rig_ptr_t); 2284 2285 //! @endcond 2286 2287 /** 2288 * \brief Callback functions and args for rig event. 2289 * 2290 * Some rigs are able to notify the host computer the operator changed 2291 * the freq/mode from the front panel, depressed a button, etc. 2292 * 2293 * Events from the rig are received through async io, 2294 * so callback functions will be called from the SIGIO sighandler context. 2295 * 2296 * Don't set these fields directly, use rig_set_freq_callback et. al. instead. 2297 * 2298 * Callbacks suit event based programming very well, 2299 * really appropriate in a GUI. 2300 * 2301 * \sa rig_set_freq_callback(), rig_set_mode_callback(), rig_set_vfo_callback(), 2302 * rig_set_ptt_callback(), rig_set_dcd_callback() 2303 */ 2304 struct rig_callbacks { 2305 freq_cb_t freq_event; /*!< Frequency change event */ 2306 rig_ptr_t freq_arg; /*!< Frequency change argument */ 2307 mode_cb_t mode_event; /*!< Mode change event */ 2308 rig_ptr_t mode_arg; /*!< Mode change argument */ 2309 vfo_cb_t vfo_event; /*!< VFO change event */ 2310 rig_ptr_t vfo_arg; /*!< VFO change argument */ 2311 ptt_cb_t ptt_event; /*!< PTT change event */ 2312 rig_ptr_t ptt_arg; /*!< PTT change argument */ 2313 dcd_cb_t dcd_event; /*!< DCD change event */ 2314 rig_ptr_t dcd_arg; /*!< DCD change argument */ 2315 pltune_cb_t pltune; /*!< Pipeline tuning module freq/mode/width callback */ 2316 rig_ptr_t pltune_arg; /*!< Pipeline tuning argument */ 2317 /* etc.. */ 2318 }; 2319 2320 2321 /** 2322 * \brief The Rig structure 2323 * 2324 * This is the master data structure, acting as a handle for the controlled 2325 * rig. A pointer to this structure is returned by the rig_init() API 2326 * function and is passed as a parameter to every rig specific API call. 2327 * 2328 * \sa rig_init(), rig_caps(), rig_state() 2329 */ 2330 struct s_rig { 2331 struct rig_caps *caps; /*!< Pointer to rig capabilities (read only) */ 2332 struct rig_state state; /*!< Rig state */ 2333 struct rig_callbacks callbacks; /*!< registered event callbacks */ 2334 }; 2335 2336 2337 2338 /* --------------- API function prototypes -----------------*/ 2339 2340 //! @cond Doxygen_Suppress 2341 2342 extern HAMLIB_EXPORT(RIG *) rig_init HAMLIB_PARAMS((rig_model_t rig_model)); 2343 extern HAMLIB_EXPORT(int) rig_open HAMLIB_PARAMS((RIG *rig)); 2344 2345 /* 2346 * General API commands, from most primitive to least.. :() 2347 * List Set/Get functions pairs 2348 */ 2349 2350 extern HAMLIB_EXPORT(int) 2351 rig_flush(hamlib_port_t *port); 2352 2353 extern HAMLIB_EXPORT(int) 2354 rig_set_freq HAMLIB_PARAMS((RIG *rig, 2355 vfo_t vfo, 2356 freq_t freq)); 2357 extern HAMLIB_EXPORT(int) 2358 rig_get_freq HAMLIB_PARAMS((RIG *rig, 2359 vfo_t vfo, 2360 freq_t *freq)); 2361 2362 extern HAMLIB_EXPORT(int) 2363 rig_set_mode HAMLIB_PARAMS((RIG *rig, 2364 vfo_t vfo, 2365 rmode_t mode, 2366 pbwidth_t width)); 2367 extern HAMLIB_EXPORT(int) 2368 rig_get_mode HAMLIB_PARAMS((RIG *rig, 2369 vfo_t vfo, 2370 rmode_t *mode, 2371 pbwidth_t *width)); 2372 2373 extern HAMLIB_EXPORT(int) 2374 rig_set_vfo HAMLIB_PARAMS((RIG *rig, 2375 vfo_t vfo)); 2376 extern HAMLIB_EXPORT(int) 2377 rig_get_vfo HAMLIB_PARAMS((RIG *rig, 2378 vfo_t *vfo)); 2379 2380 extern HAMLIB_EXPORT(int) 2381 rig_get_vfo_info HAMLIB_PARAMS((RIG *rig, 2382 vfo_t vfo, 2383 freq_t *freq, 2384 rmode_t *mode, 2385 pbwidth_t *width, 2386 split_t *split, 2387 int *satmode)); 2388 2389 extern HAMLIB_EXPORT(int) 2390 rig_get_vfo_list HAMLIB_PARAMS((RIG *rig, char *buf, int buflen)); 2391 2392 extern HAMLIB_EXPORT(int) 2393 netrigctl_get_vfo_mode HAMLIB_PARAMS((RIG *rig)); 2394 2395 extern HAMLIB_EXPORT(int) 2396 rig_set_ptt HAMLIB_PARAMS((RIG *rig, 2397 vfo_t vfo, 2398 ptt_t ptt)); 2399 extern HAMLIB_EXPORT(int) 2400 rig_get_ptt HAMLIB_PARAMS((RIG *rig, 2401 vfo_t vfo, 2402 ptt_t *ptt)); 2403 2404 extern HAMLIB_EXPORT(int) 2405 rig_get_dcd HAMLIB_PARAMS((RIG *rig, 2406 vfo_t vfo, 2407 dcd_t *dcd)); 2408 2409 extern HAMLIB_EXPORT(int) 2410 rig_set_rptr_shift HAMLIB_PARAMS((RIG *rig, 2411 vfo_t vfo, 2412 rptr_shift_t rptr_shift)); 2413 extern HAMLIB_EXPORT(int) 2414 rig_get_rptr_shift HAMLIB_PARAMS((RIG *rig, 2415 vfo_t vfo, 2416 rptr_shift_t *rptr_shift)); 2417 2418 extern HAMLIB_EXPORT(int) 2419 rig_set_rptr_offs HAMLIB_PARAMS((RIG *rig, 2420 vfo_t vfo, 2421 shortfreq_t rptr_offs)); 2422 extern HAMLIB_EXPORT(int) 2423 rig_get_rptr_offs HAMLIB_PARAMS((RIG *rig, 2424 vfo_t vfo, 2425 shortfreq_t *rptr_offs)); 2426 2427 extern HAMLIB_EXPORT(int) 2428 rig_set_ctcss_tone HAMLIB_PARAMS((RIG *rig, 2429 vfo_t vfo, 2430 tone_t tone)); 2431 extern HAMLIB_EXPORT(int) 2432 rig_get_ctcss_tone HAMLIB_PARAMS((RIG *rig, 2433 vfo_t vfo, 2434 tone_t *tone)); 2435 2436 extern HAMLIB_EXPORT(int) 2437 rig_set_dcs_code HAMLIB_PARAMS((RIG *rig, 2438 vfo_t vfo, 2439 tone_t code)); 2440 extern HAMLIB_EXPORT(int) 2441 rig_get_dcs_code HAMLIB_PARAMS((RIG *rig, 2442 vfo_t vfo, 2443 tone_t *code)); 2444 2445 extern HAMLIB_EXPORT(int) 2446 rig_set_ctcss_sql HAMLIB_PARAMS((RIG *rig, 2447 vfo_t vfo, 2448 tone_t tone)); 2449 extern HAMLIB_EXPORT(int) 2450 rig_get_ctcss_sql HAMLIB_PARAMS((RIG *rig, 2451 vfo_t vfo, 2452 tone_t *tone)); 2453 2454 extern HAMLIB_EXPORT(int) 2455 rig_set_dcs_sql HAMLIB_PARAMS((RIG *rig, 2456 vfo_t vfo, 2457 tone_t code)); 2458 extern HAMLIB_EXPORT(int) 2459 rig_get_dcs_sql HAMLIB_PARAMS((RIG *rig, 2460 vfo_t vfo, 2461 tone_t *code)); 2462 2463 extern HAMLIB_EXPORT(int) 2464 rig_set_split_freq HAMLIB_PARAMS((RIG *rig, 2465 vfo_t vfo, 2466 freq_t tx_freq)); 2467 extern HAMLIB_EXPORT(int) 2468 rig_get_split_freq HAMLIB_PARAMS((RIG *rig, 2469 vfo_t vfo, 2470 freq_t *tx_freq)); 2471 2472 extern HAMLIB_EXPORT(int) 2473 rig_set_split_mode HAMLIB_PARAMS((RIG *rig, 2474 vfo_t vfo, 2475 rmode_t tx_mode, 2476 pbwidth_t tx_width)); 2477 extern HAMLIB_EXPORT(int) 2478 rig_get_split_mode HAMLIB_PARAMS((RIG *rig, 2479 vfo_t vfo, 2480 rmode_t *tx_mode, 2481 pbwidth_t *tx_width)); 2482 2483 extern HAMLIB_EXPORT(int) 2484 rig_set_split_freq_mode HAMLIB_PARAMS((RIG *rig, 2485 vfo_t vfo, 2486 freq_t tx_freq, 2487 rmode_t tx_mode, 2488 pbwidth_t tx_width)); 2489 extern HAMLIB_EXPORT(int) 2490 rig_get_split_freq_mode HAMLIB_PARAMS((RIG *rig, 2491 vfo_t vfo, 2492 freq_t *tx_freq, 2493 rmode_t *tx_mode, 2494 pbwidth_t *tx_width)); 2495 2496 extern HAMLIB_EXPORT(int) 2497 rig_set_split_vfo HAMLIB_PARAMS((RIG *, 2498 vfo_t rx_vfo, 2499 split_t split, 2500 vfo_t tx_vfo)); 2501 extern HAMLIB_EXPORT(int) 2502 rig_get_split_vfo HAMLIB_PARAMS((RIG *, 2503 vfo_t rx_vfo, 2504 split_t *split, 2505 vfo_t *tx_vfo)); 2506 2507 #define rig_set_split(r,v,s) rig_set_split_vfo((r),(v),(s),RIG_VFO_CURR) 2508 #define rig_get_split(r,v,s) ({ vfo_t _tx_vfo; rig_get_split_vfo((r),(v),(s),&_tx_vfo); }) 2509 2510 extern HAMLIB_EXPORT(int) 2511 rig_set_rit HAMLIB_PARAMS((RIG *rig, 2512 vfo_t vfo, 2513 shortfreq_t rit)); 2514 extern HAMLIB_EXPORT(int) 2515 rig_get_rit HAMLIB_PARAMS((RIG *rig, 2516 vfo_t vfo, 2517 shortfreq_t *rit)); 2518 2519 extern HAMLIB_EXPORT(int) 2520 rig_set_xit HAMLIB_PARAMS((RIG *rig, 2521 vfo_t vfo, 2522 shortfreq_t xit)); 2523 extern HAMLIB_EXPORT(int) 2524 rig_get_xit HAMLIB_PARAMS((RIG *rig, 2525 vfo_t vfo, 2526 shortfreq_t *xit)); 2527 2528 extern HAMLIB_EXPORT(int) 2529 rig_set_ts HAMLIB_PARAMS((RIG *rig, 2530 vfo_t vfo, 2531 shortfreq_t ts)); 2532 extern HAMLIB_EXPORT(int) 2533 rig_get_ts HAMLIB_PARAMS((RIG *rig, 2534 vfo_t vfo, 2535 shortfreq_t *ts)); 2536 2537 extern HAMLIB_EXPORT(int) 2538 rig_power2mW HAMLIB_PARAMS((RIG *rig, 2539 unsigned int *mwpower, 2540 float power, 2541 freq_t freq, 2542 rmode_t mode)); 2543 extern HAMLIB_EXPORT(int) 2544 rig_mW2power HAMLIB_PARAMS((RIG *rig, 2545 float *power, 2546 unsigned int mwpower, 2547 freq_t freq, 2548 rmode_t mode)); 2549 2550 extern HAMLIB_EXPORT(shortfreq_t) 2551 rig_get_resolution HAMLIB_PARAMS((RIG *rig, 2552 rmode_t mode)); 2553 2554 extern HAMLIB_EXPORT(int) 2555 rig_set_level HAMLIB_PARAMS((RIG *rig, 2556 vfo_t vfo, 2557 setting_t level, 2558 value_t val)); 2559 extern HAMLIB_EXPORT(int) 2560 rig_get_level HAMLIB_PARAMS((RIG *rig, 2561 vfo_t vfo, 2562 setting_t level, 2563 value_t *val)); 2564 2565 #define rig_get_strength(r,v,s) rig_get_level((r),(v),RIG_LEVEL_STRENGTH, (value_t*)(s)) 2566 2567 extern HAMLIB_EXPORT(int) 2568 rig_set_parm HAMLIB_PARAMS((RIG *rig, 2569 setting_t parm, 2570 value_t val)); 2571 extern HAMLIB_EXPORT(int) 2572 rig_get_parm HAMLIB_PARAMS((RIG *rig, 2573 setting_t parm, 2574 value_t *val)); 2575 2576 extern HAMLIB_EXPORT(int) 2577 rig_set_conf HAMLIB_PARAMS((RIG *rig, 2578 token_t token, 2579 const char *val)); 2580 extern HAMLIB_EXPORT(int) 2581 rig_get_conf HAMLIB_PARAMS((RIG *rig, 2582 token_t token, 2583 char *val)); 2584 2585 extern HAMLIB_EXPORT(int) 2586 rig_set_powerstat HAMLIB_PARAMS((RIG *rig, 2587 powerstat_t status)); 2588 extern HAMLIB_EXPORT(int) 2589 rig_get_powerstat HAMLIB_PARAMS((RIG *rig, 2590 powerstat_t *status)); 2591 2592 extern HAMLIB_EXPORT(int) 2593 rig_reset HAMLIB_PARAMS((RIG *rig, 2594 reset_t reset)); /* dangerous! */ 2595 2596 extern HAMLIB_EXPORT(int) 2597 rig_set_ext_level HAMLIB_PARAMS((RIG *rig, 2598 vfo_t vfo, 2599 token_t token, 2600 value_t val)); 2601 extern HAMLIB_EXPORT(int) 2602 rig_get_ext_level HAMLIB_PARAMS((RIG *rig, 2603 vfo_t vfo, 2604 token_t token, 2605 value_t *val)); 2606 2607 extern HAMLIB_EXPORT(int) 2608 rig_set_ext_func HAMLIB_PARAMS((RIG *rig, 2609 vfo_t vfo, 2610 token_t token, 2611 int status)); 2612 extern HAMLIB_EXPORT(int) 2613 rig_get_ext_func HAMLIB_PARAMS((RIG *rig, 2614 vfo_t vfo, 2615 token_t token, 2616 int *status)); 2617 2618 extern HAMLIB_EXPORT(int) 2619 rig_set_ext_parm HAMLIB_PARAMS((RIG *rig, 2620 token_t token, 2621 value_t val)); 2622 extern HAMLIB_EXPORT(int) 2623 rig_get_ext_parm HAMLIB_PARAMS((RIG *rig, 2624 token_t token, 2625 value_t *val)); 2626 2627 extern HAMLIB_EXPORT(int) 2628 rig_ext_func_foreach HAMLIB_PARAMS((RIG *rig, 2629 int (*cfunc)(RIG *, 2630 const struct confparams *, 2631 rig_ptr_t), 2632 rig_ptr_t data)); 2633 extern HAMLIB_EXPORT(int) 2634 rig_ext_level_foreach HAMLIB_PARAMS((RIG *rig, 2635 int (*cfunc)(RIG *, 2636 const struct confparams *, 2637 rig_ptr_t), 2638 rig_ptr_t data)); 2639 extern HAMLIB_EXPORT(int) 2640 rig_ext_parm_foreach HAMLIB_PARAMS((RIG *rig, 2641 int (*cfunc)(RIG *, 2642 const struct confparams *, 2643 rig_ptr_t), 2644 rig_ptr_t data)); 2645 2646 extern HAMLIB_EXPORT(const struct confparams *) 2647 rig_ext_lookup HAMLIB_PARAMS((RIG *rig, 2648 const char *name)); 2649 2650 extern HAMLIB_EXPORT(const struct confparams *) 2651 rig_ext_lookup_tok HAMLIB_PARAMS((RIG *rig, 2652 token_t token)); 2653 extern HAMLIB_EXPORT(token_t) 2654 rig_ext_token_lookup HAMLIB_PARAMS((RIG *rig, 2655 const char *name)); 2656 2657 2658 extern HAMLIB_EXPORT(int) 2659 rig_token_foreach HAMLIB_PARAMS((RIG *rig, 2660 int (*cfunc)(const struct confparams *, 2661 rig_ptr_t), 2662 rig_ptr_t data)); 2663 2664 extern HAMLIB_EXPORT(const struct confparams *) 2665 rig_confparam_lookup HAMLIB_PARAMS((RIG *rig, 2666 const char *name)); 2667 extern HAMLIB_EXPORT(token_t) 2668 rig_token_lookup HAMLIB_PARAMS((RIG *rig, 2669 const char *name)); 2670 2671 extern HAMLIB_EXPORT(int) 2672 rig_close HAMLIB_PARAMS((RIG *rig)); 2673 2674 extern HAMLIB_EXPORT(int) 2675 rig_cleanup HAMLIB_PARAMS((RIG *rig)); 2676 2677 extern HAMLIB_EXPORT(int) 2678 rig_set_ant HAMLIB_PARAMS((RIG *rig, 2679 vfo_t vfo, 2680 ant_t ant, /* antenna */ 2681 value_t option)); /* optional ant info */ 2682 extern HAMLIB_EXPORT(int) 2683 rig_get_ant HAMLIB_PARAMS((RIG *rig, 2684 vfo_t vfo, 2685 ant_t ant, 2686 value_t *option, 2687 ant_t *ant_curr, 2688 ant_t *ant_tx, 2689 ant_t *ant_rx)); 2690 2691 extern HAMLIB_EXPORT(setting_t) 2692 rig_has_get_level HAMLIB_PARAMS((RIG *rig, 2693 setting_t level)); 2694 extern HAMLIB_EXPORT(setting_t) 2695 rig_has_set_level HAMLIB_PARAMS((RIG *rig, 2696 setting_t level)); 2697 2698 extern HAMLIB_EXPORT(setting_t) 2699 rig_has_get_parm HAMLIB_PARAMS((RIG *rig, 2700 setting_t parm)); 2701 extern HAMLIB_EXPORT(setting_t) 2702 rig_has_set_parm HAMLIB_PARAMS((RIG *rig, 2703 setting_t parm)); 2704 2705 extern HAMLIB_EXPORT(setting_t) 2706 rig_has_get_func HAMLIB_PARAMS((RIG *rig, 2707 setting_t func)); 2708 extern HAMLIB_EXPORT(setting_t) 2709 rig_has_set_func HAMLIB_PARAMS((RIG *rig, 2710 setting_t func)); 2711 2712 extern HAMLIB_EXPORT(int) 2713 rig_set_func HAMLIB_PARAMS((RIG *rig, 2714 vfo_t vfo, 2715 setting_t func, 2716 int status)); 2717 extern HAMLIB_EXPORT(int) 2718 rig_get_func HAMLIB_PARAMS((RIG *rig, 2719 vfo_t vfo, 2720 setting_t func, 2721 int *status)); 2722 2723 extern HAMLIB_EXPORT(int) 2724 rig_send_dtmf HAMLIB_PARAMS((RIG *rig, 2725 vfo_t vfo, 2726 const char *digits)); 2727 extern HAMLIB_EXPORT(int) 2728 rig_recv_dtmf HAMLIB_PARAMS((RIG *rig, 2729 vfo_t vfo, 2730 char *digits, 2731 int *length)); 2732 2733 extern HAMLIB_EXPORT(int) 2734 rig_send_morse HAMLIB_PARAMS((RIG *rig, 2735 vfo_t vfo, 2736 const char *msg)); 2737 2738 extern HAMLIB_EXPORT(int) 2739 rig_stop_morse HAMLIB_PARAMS((RIG *rig, 2740 vfo_t vfo)); 2741 2742 extern HAMLIB_EXPORT(int) 2743 rig_wait_morse HAMLIB_PARAMS((RIG *rig, 2744 vfo_t vfo)); 2745 2746 extern HAMLIB_EXPORT(int) 2747 rig_send_voice_mem HAMLIB_PARAMS((RIG *rig, 2748 vfo_t vfo, 2749 int ch)); 2750 2751 extern HAMLIB_EXPORT(int) 2752 rig_set_bank HAMLIB_PARAMS((RIG *rig, 2753 vfo_t vfo, 2754 int bank)); 2755 2756 extern HAMLIB_EXPORT(int) 2757 rig_set_mem HAMLIB_PARAMS((RIG *rig, 2758 vfo_t vfo, 2759 int ch)); 2760 extern HAMLIB_EXPORT(int) 2761 rig_get_mem HAMLIB_PARAMS((RIG *rig, 2762 vfo_t vfo, 2763 int *ch)); 2764 2765 extern HAMLIB_EXPORT(int) 2766 rig_vfo_op HAMLIB_PARAMS((RIG *rig, 2767 vfo_t vfo, 2768 vfo_op_t op)); 2769 2770 extern HAMLIB_EXPORT(vfo_op_t) 2771 rig_has_vfo_op HAMLIB_PARAMS((RIG *rig, 2772 vfo_op_t op)); 2773 2774 extern HAMLIB_EXPORT(int) 2775 rig_scan HAMLIB_PARAMS((RIG *rig, 2776 vfo_t vfo, 2777 scan_t scan, 2778 int ch)); 2779 2780 extern HAMLIB_EXPORT(scan_t) 2781 rig_has_scan HAMLIB_PARAMS((RIG *rig, 2782 scan_t scan)); 2783 2784 extern HAMLIB_EXPORT(int) 2785 rig_set_channel HAMLIB_PARAMS((RIG *rig, 2786 vfo_t vfo, 2787 const channel_t *chan)); /* mem */ 2788 extern HAMLIB_EXPORT(int) 2789 rig_get_channel HAMLIB_PARAMS((RIG *rig, 2790 vfo_t vfo, 2791 channel_t *chan, int read_only)); 2792 2793 extern HAMLIB_EXPORT(int) 2794 rig_set_chan_all HAMLIB_PARAMS((RIG *rig, 2795 vfo_t vfo, 2796 const channel_t chans[])); 2797 extern HAMLIB_EXPORT(int) 2798 rig_get_chan_all HAMLIB_PARAMS((RIG *rig, 2799 vfo_t vfo, 2800 channel_t chans[])); 2801 2802 extern HAMLIB_EXPORT(int) 2803 rig_set_chan_all_cb HAMLIB_PARAMS((RIG *rig, 2804 vfo_t vfo, 2805 chan_cb_t chan_cb, 2806 rig_ptr_t)); 2807 extern HAMLIB_EXPORT(int) 2808 rig_get_chan_all_cb HAMLIB_PARAMS((RIG *rig, 2809 vfo_t vfo, 2810 chan_cb_t chan_cb, 2811 rig_ptr_t)); 2812 2813 extern HAMLIB_EXPORT(int) 2814 rig_set_mem_all_cb HAMLIB_PARAMS((RIG *rig, 2815 vfo_t vfo, 2816 chan_cb_t chan_cb, 2817 confval_cb_t parm_cb, 2818 rig_ptr_t)); 2819 extern HAMLIB_EXPORT(int) 2820 rig_get_mem_all_cb HAMLIB_PARAMS((RIG *rig, 2821 vfo_t vfo, 2822 chan_cb_t chan_cb, 2823 confval_cb_t parm_cb, 2824 rig_ptr_t)); 2825 2826 extern HAMLIB_EXPORT(int) 2827 rig_set_mem_all HAMLIB_PARAMS((RIG *rig, 2828 vfo_t vfo, 2829 const channel_t *chan, 2830 const struct confparams *, 2831 const value_t *)); 2832 extern HAMLIB_EXPORT(int) 2833 rig_get_mem_all HAMLIB_PARAMS((RIG *rig, 2834 vfo_t vfo, 2835 channel_t *chan, 2836 const struct confparams *, 2837 value_t *)); 2838 2839 extern HAMLIB_EXPORT(const chan_t *) 2840 rig_lookup_mem_caps HAMLIB_PARAMS((RIG *rig, 2841 int ch)); 2842 2843 extern HAMLIB_EXPORT(int) 2844 rig_mem_count HAMLIB_PARAMS((RIG *rig)); 2845 2846 extern HAMLIB_EXPORT(int) 2847 rig_set_trn HAMLIB_PARAMS((RIG *rig, 2848 int trn)); 2849 extern HAMLIB_EXPORT(int) 2850 rig_get_trn HAMLIB_PARAMS((RIG *rig, 2851 int *trn)); 2852 2853 extern HAMLIB_EXPORT(int) 2854 rig_set_freq_callback HAMLIB_PARAMS((RIG *, 2855 freq_cb_t, 2856 rig_ptr_t)); 2857 2858 extern HAMLIB_EXPORT(int) 2859 rig_set_mode_callback HAMLIB_PARAMS((RIG *, 2860 mode_cb_t, 2861 rig_ptr_t)); 2862 extern HAMLIB_EXPORT(int) 2863 rig_set_vfo_callback HAMLIB_PARAMS((RIG *, 2864 vfo_cb_t, 2865 rig_ptr_t)); 2866 2867 extern HAMLIB_EXPORT(int) 2868 rig_set_ptt_callback HAMLIB_PARAMS((RIG *, 2869 ptt_cb_t, 2870 rig_ptr_t)); 2871 2872 extern HAMLIB_EXPORT(int) 2873 rig_set_dcd_callback HAMLIB_PARAMS((RIG *, 2874 dcd_cb_t, 2875 rig_ptr_t)); 2876 2877 extern HAMLIB_EXPORT(int) 2878 rig_set_pltune_callback HAMLIB_PARAMS((RIG *, 2879 pltune_cb_t, 2880 rig_ptr_t)); 2881 2882 extern HAMLIB_EXPORT(int) 2883 rig_set_twiddle HAMLIB_PARAMS((RIG *rig, 2884 int seconds)); 2885 2886 extern HAMLIB_EXPORT(int) 2887 rig_get_twiddle HAMLIB_PARAMS((RIG *rig, 2888 int *seconds)); 2889 2890 extern HAMLIB_EXPORT(int) 2891 rig_set_uplink HAMLIB_PARAMS((RIG *rig, 2892 int val)); 2893 2894 extern HAMLIB_EXPORT(const char *) 2895 rig_get_info HAMLIB_PARAMS((RIG *rig)); 2896 2897 extern HAMLIB_EXPORT(const struct rig_caps *) 2898 rig_get_caps HAMLIB_PARAMS((rig_model_t rig_model)); 2899 2900 extern HAMLIB_EXPORT(const freq_range_t *) 2901 rig_get_range HAMLIB_PARAMS((const freq_range_t *range_list, 2902 freq_t freq, 2903 rmode_t mode)); 2904 2905 extern HAMLIB_EXPORT(pbwidth_t) 2906 rig_passband_normal HAMLIB_PARAMS((RIG *rig, 2907 rmode_t mode)); 2908 extern HAMLIB_EXPORT(pbwidth_t) 2909 rig_passband_narrow HAMLIB_PARAMS((RIG *rig, 2910 rmode_t mode)); 2911 extern HAMLIB_EXPORT(pbwidth_t) 2912 rig_passband_wide HAMLIB_PARAMS((RIG *rig, 2913 rmode_t mode)); 2914 2915 extern HAMLIB_EXPORT(const char *) 2916 rigerror HAMLIB_PARAMS((int errnum)); 2917 2918 extern HAMLIB_EXPORT(int) 2919 rig_setting2idx HAMLIB_PARAMS((setting_t s)); 2920 2921 extern HAMLIB_EXPORT(setting_t) 2922 rig_idx2setting(int i); 2923 /* 2924 * Even if these functions are prefixed with "rig_", they are not rig specific 2925 * Maybe "hamlib_" would have been better. Let me know. --SF 2926 */ 2927 extern HAMLIB_EXPORT(void) 2928 rig_set_debug HAMLIB_PARAMS((enum rig_debug_level_e debug_level)); 2929 2930 extern HAMLIB_EXPORT(void) 2931 rig_set_debug_time_stamp HAMLIB_PARAMS((int flag)); 2932 2933 #define rig_set_debug_level(level) rig_set_debug(level) 2934 2935 extern HAMLIB_EXPORT(int) 2936 rig_need_debug HAMLIB_PARAMS((enum rig_debug_level_e debug_level)); 2937 2938 2939 // this need to be fairly big to avoid compiler warnings 2940 #define DEBUGMSGSAVE_SIZE 24000 2941 extern HAMLIB_EXPORT_VAR(char) debugmsgsave[DEBUGMSGSAVE_SIZE]; // last debug msg 2942 extern HAMLIB_EXPORT_VAR(char) debugmsgsave2[DEBUGMSGSAVE_SIZE]; // last-1 debug msg 2943 extern HAMLIB_EXPORT_VAR(char) debugmsgsave3[DEBUGMSGSAVE_SIZE]; // last-2 debug msg 2944 #ifndef __cplusplus 2945 #ifdef __GNUC__ 2946 // doing the debug macro with a dummy sprintf allows gcc to check the format string 2947 #define rig_debug(debug_level,fmt,...) do { strncpy(debugmsgsave3, debugmsgsave2,sizeof(debugmsgsave3));strncpy(debugmsgsave2, debugmsgsave, sizeof(debugmsgsave2));snprintf(debugmsgsave,sizeof(debugmsgsave),fmt,__VA_ARGS__);rig_debug(debug_level,fmt,##__VA_ARGS__); } while(0); 2948 #endif 2949 #endif 2950 extern HAMLIB_EXPORT(void) 2951 rig_debug HAMLIB_PARAMS((enum rig_debug_level_e debug_level, 2952 const char *fmt, ...)); 2953 2954 extern HAMLIB_EXPORT(vprintf_cb_t) 2955 rig_set_debug_callback HAMLIB_PARAMS((vprintf_cb_t cb, 2956 rig_ptr_t arg)); 2957 2958 extern HAMLIB_EXPORT(FILE *) 2959 rig_set_debug_file HAMLIB_PARAMS((FILE *stream)); 2960 2961 extern HAMLIB_EXPORT(int) 2962 rig_register HAMLIB_PARAMS((const struct rig_caps *caps)); 2963 2964 extern HAMLIB_EXPORT(int) 2965 rig_unregister HAMLIB_PARAMS((rig_model_t rig_model)); 2966 2967 extern HAMLIB_EXPORT(int) 2968 rig_list_foreach HAMLIB_PARAMS((int (*cfunc)(const struct rig_caps *, rig_ptr_t), 2969 rig_ptr_t data)); 2970 2971 extern HAMLIB_EXPORT(int) 2972 rig_list_foreach_model HAMLIB_PARAMS((int (*cfunc)(const rig_model_t rig_model, rig_ptr_t), 2973 rig_ptr_t data)); 2974 2975 extern HAMLIB_EXPORT(int) 2976 rig_load_backend HAMLIB_PARAMS((const char *be_name)); 2977 2978 extern HAMLIB_EXPORT(int) 2979 rig_check_backend HAMLIB_PARAMS((rig_model_t rig_model)); 2980 2981 extern HAMLIB_EXPORT(int) 2982 rig_load_all_backends HAMLIB_PARAMS((void)); 2983 2984 typedef int (*rig_probe_func_t)(const hamlib_port_t *, rig_model_t, rig_ptr_t); 2985 2986 extern HAMLIB_EXPORT(int) 2987 rig_probe_all HAMLIB_PARAMS((hamlib_port_t *p, 2988 rig_probe_func_t, 2989 rig_ptr_t)); 2990 2991 extern HAMLIB_EXPORT(rig_model_t) 2992 rig_probe HAMLIB_PARAMS((hamlib_port_t *p)); 2993 2994 2995 /* Misc calls */ 2996 extern HAMLIB_EXPORT(const char *) rig_strrmode(rmode_t mode); 2997 extern HAMLIB_EXPORT(int) rig_strrmodes(rmode_t modes, char *buf, int buflen); 2998 extern HAMLIB_EXPORT(const char *) rig_strvfo(vfo_t vfo); 2999 extern HAMLIB_EXPORT(const char *) rig_strfunc(setting_t); 3000 extern HAMLIB_EXPORT(const char *) rig_strlevel(setting_t); 3001 extern HAMLIB_EXPORT(const char *) rig_strparm(setting_t); 3002 extern HAMLIB_EXPORT(const char *) rig_strptrshift(rptr_shift_t); 3003 extern HAMLIB_EXPORT(const char *) rig_strvfop(vfo_op_t op); 3004 extern HAMLIB_EXPORT(const char *) rig_strscan(scan_t scan); 3005 extern HAMLIB_EXPORT(const char *) rig_strstatus(enum rig_status_e status); 3006 extern HAMLIB_EXPORT(const char *) rig_strmtype(chan_type_t mtype); 3007 3008 extern HAMLIB_EXPORT(rmode_t) rig_parse_mode(const char *s); 3009 extern HAMLIB_EXPORT(vfo_t) rig_parse_vfo(const char *s); 3010 extern HAMLIB_EXPORT(setting_t) rig_parse_func(const char *s); 3011 extern HAMLIB_EXPORT(setting_t) rig_parse_level(const char *s); 3012 extern HAMLIB_EXPORT(setting_t) rig_parse_parm(const char *s); 3013 extern HAMLIB_EXPORT(vfo_op_t) rig_parse_vfo_op(const char *s); 3014 extern HAMLIB_EXPORT(scan_t) rig_parse_scan(const char *s); 3015 extern HAMLIB_EXPORT(rptr_shift_t) rig_parse_rptr_shift(const char *s); 3016 extern HAMLIB_EXPORT(chan_type_t) rig_parse_mtype(const char *s); 3017 3018 extern HAMLIB_EXPORT(const char *) rig_license HAMLIB_PARAMS(()); 3019 extern HAMLIB_EXPORT(const char *) rig_version HAMLIB_PARAMS(()); 3020 extern HAMLIB_EXPORT(const char *) rig_copyright HAMLIB_PARAMS(()); 3021 3022 extern HAMLIB_EXPORT(void) rig_no_restore_ai(); 3023 3024 extern HAMLIB_EXPORT(int) rig_get_cache_timeout_ms(RIG *rig, hamlib_cache_t selection); 3025 extern HAMLIB_EXPORT(int) rig_set_cache_timeout_ms(RIG *rig, hamlib_cache_t selection, int ms); 3026 3027 extern HAMLIB_EXPORT(int) rig_set_vfo_opt(RIG *rig, int status); 3028 extern HAMLIB_EXPORT(int) rig_get_vfo_info(RIG *rig, vfo_t vfo, freq_t *freq, rmode_t *mode, pbwidth_t *width, split_t *split, int *satmode); 3029 extern HAMLIB_EXPORT(int) rig_get_rig_info(RIG *rig, char *response, int max_response_len); 3030 extern HAMLIB_EXPORT(int) rig_get_cache(RIG *rig, vfo_t vfo, freq_t *freq, int * cache_ms_freq, rmode_t *mode, int *cache_ms_mode, pbwidth_t *width, int *cache_ms_width); 3031 3032 3033 typedef unsigned long rig_useconds_t; 3034 extern HAMLIB_EXPORT(int) hl_usleep(rig_useconds_t msec); 3035 3036 //! @endcond 3037 3038 __END_DECLS 3039 3040 #endif /* _RIG_H */ 3041 3042 /*! @} */ 3043