// --------------------------------------------------------------------------- // ADAT Hamlib Backend // --------------------------------------------------------------------------- // // adat.c // // Created by Frank Goenninger DG1SBG. // Copyright © 2011, 2012 Frank Goenninger. // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA #ifdef HAVE_CONFIG_H # include "config.h" #endif // --------------------------------------------------------------------------- // SYSTEM INCLUDES // --------------------------------------------------------------------------- #include #include #include #include #include #include #include // --------------------------------------------------------------------------- // HAMLIB INCLUDES // --------------------------------------------------------------------------- #include #include "token.h" #include "serial.h" #include "misc.h" #include "register.h" #include "num_stdio.h" /* HAVE_SSLEEP is defined when Windows Sleep is found * HAVE_SLEEP is defined when POSIX sleep is found * _WIN32 is defined when compiling with MinGW * * When cross-compiling from POSIX to Windows using MinGW, HAVE_SLEEP * will often be defined by configure although it is not supported by * MinGW. So substitute the sleep definition below in such a case and * when compiling on Windows using MinGW where HAVE_SLEEP will be * undefined. * * FIXME: Needs better handling for all versions of MinGW. * */ #if (defined(HAVE_SSLEEP) || defined(_WIN32)) && (!defined(HAVE_SLEEP)) # include "hl_sleep.h" #endif // --------------------------------------------------------------------------- // ADAT INCLUDES // --------------------------------------------------------------------------- #include "adat.h" // --------------------------------------------------------------------------- // GLOBAL DEFINITIONS // --------------------------------------------------------------------------- #if !defined(NDEDBUG) # define ADAT_DEBUG 1 #endif #undef ADAT_DEBUG // manual override ... // --------------------------------------------------------------------------- // ADAT GLOBAL VARIABLES // --------------------------------------------------------------------------- // DEBUG STUFF static int gFnLevel = 0; // ADAT MODES static adat_mode_list_t the_adat_mode_list = { ADAT_NR_MODES, { { ADAT_MODE_STR_CW_R, ADAT_MODE_RNR_CW_R, ADAT_MODE_ANR_CW_R }, { ADAT_MODE_STR_CW, ADAT_MODE_RNR_CW, ADAT_MODE_ANR_CW }, { ADAT_MODE_STR_LSB, ADAT_MODE_RNR_LSB, ADAT_MODE_ANR_LSB }, { ADAT_MODE_STR_USB, ADAT_MODE_RNR_USB, ADAT_MODE_ANR_USB }, { ADAT_MODE_STR_AM, ADAT_MODE_RNR_AM, ADAT_MODE_ANR_AM }, { ADAT_MODE_STR_AM_SL, ADAT_MODE_RNR_AM_SL, ADAT_MODE_ANR_AM_SL }, { ADAT_MODE_STR_AM_SU, ADAT_MODE_RNR_AM_SU, ADAT_MODE_ANR_AM_SU }, { ADAT_MODE_STR_FM, ADAT_MODE_RNR_FM, ADAT_MODE_ANR_FM } } }; // ADAT VFOS static adat_vfo_list_t the_adat_vfo_list = { ADAT_NR_VFOS, { { ADAT_VFO_STR_A, ADAT_VFO_RNR_A, ADAT_VFO_ANR_A }, { ADAT_VFO_STR_B, ADAT_VFO_RNR_B, ADAT_VFO_ANR_B }, { ADAT_VFO_STR_C, ADAT_VFO_RNR_C, ADAT_VFO_ANR_C } } }; // --------------------------------------------------------------------------- // Individual ADAT CAT commands // --------------------------------------------------------------------------- // -- NIL -- (Marks the end of a cmd list) #if 0 static adat_cmd_def_t adat_cmd_nil = { ADAT_CMD_DEF_NIL, ADAT_CMD_KIND_WITHOUT_RESULT, NULL, 0, { NULL } }; #endif // -- ADAT SPECIAL: DISPLAY OFF -- static adat_cmd_def_t adat_cmd_display_off = { ADAT_CMD_DEF_ADAT_SPECIAL, ADAT_CMD_KIND_WITHOUT_RESULT, NULL, 1, { ADAT_CMD_DEF_STRING_DISPLAY_OFF } }; // -- ADAT SPECIAL: DISPLAY ON -- static adat_cmd_def_t adat_cmd_display_on = { ADAT_CMD_DEF_ADAT_SPECIAL, ADAT_CMD_KIND_WITHOUT_RESULT, NULL, 1, { ADAT_CMD_DEF_STRING_DISPLAY_ON } }; // -- ADAT SPECIAL: SELECT VFO -- // -- ADAT SPECIAL: GET SERIAL NR -- static adat_cmd_def_t adat_cmd_get_serial_nr = { ADAT_CMD_DEF_ADAT_SPECIAL, ADAT_CMD_KIND_WITH_RESULT, adat_cmd_fn_get_serial_nr, 1, { ADAT_CMD_DEF_STRING_GET_SERIAL_NR } }; // -- ADAT SPECIAL: GET FIRMWARE VERSION -- static adat_cmd_def_t adat_cmd_get_fw_version = { ADAT_CMD_DEF_ADAT_SPECIAL, ADAT_CMD_KIND_WITH_RESULT, adat_cmd_fn_get_fw_version, 1, { ADAT_CMD_DEF_STRING_GET_FW_VERSION } }; // -- ADAT SPECIAL: GET HARDWARE VERSION -- static adat_cmd_def_t adat_cmd_get_hw_version = { ADAT_CMD_DEF_ADAT_SPECIAL, ADAT_CMD_KIND_WITH_RESULT, adat_cmd_fn_get_hw_version, 1, { ADAT_CMD_DEF_STRING_GET_HW_VERSION } }; // -- ADAT SPECIAL: GET FIRMWARE VERSION -- static adat_cmd_def_t adat_cmd_get_id_code = { ADAT_CMD_DEF_ADAT_SPECIAL, ADAT_CMD_KIND_WITH_RESULT, adat_cmd_fn_get_id_code, 1, { ADAT_CMD_DEF_STRING_GET_ID_CODE } }; // -- ADAT SPECIAL: GET GUI FIRMWARE VERSION -- static adat_cmd_def_t adat_cmd_get_gui_fw_version = { ADAT_CMD_DEF_ADAT_SPECIAL, ADAT_CMD_KIND_WITH_RESULT, adat_cmd_fn_get_gui_fw_version, 1, { ADAT_CMD_DEF_STRING_GET_GUI_FW_VERSION } }; // -- ADAT SPECIAL: GET OPTIONS -- static adat_cmd_def_t adat_cmd_get_options = { ADAT_CMD_DEF_ADAT_SPECIAL, ADAT_CMD_KIND_WITH_RESULT, adat_cmd_fn_get_options, 1, { ADAT_CMD_DEF_STRING_GET_OPTIONS } }; // -- ADAT SPECIAL: GET CALLSIGN -- static adat_cmd_def_t adat_cmd_get_callsign = { ADAT_CMD_DEF_ADAT_SPECIAL, ADAT_CMD_KIND_WITH_RESULT, adat_cmd_fn_get_callsign, 1, { ADAT_CMD_DEF_STRING_GET_CALLSIGN } }; // -- ADAT SPECIAL: SET CALLSIGN -- static adat_cmd_def_t adat_cmd_set_callsign = { ADAT_CMD_DEF_ADAT_SPECIAL, ADAT_CMD_KIND_WITHOUT_RESULT, adat_cmd_fn_set_callsign, 1, { ADAT_CMD_DEF_STRING_SET_CALLSIGN } }; // -- HAMLIB DEFINED COMMANDS -- // -- GET FREQ -- static adat_cmd_def_t adat_cmd_get_freq = { ADAT_CMD_DEF_GET_FREQ, ADAT_CMD_KIND_WITH_RESULT, adat_cmd_fn_get_freq, 1, { ADAT_CMD_DEF_STRING_GET_FREQ } }; static adat_cmd_list_t adat_cmd_list_get_freq = { 2, { &adat_cmd_display_off, &adat_cmd_get_freq } }; // -- SET FREQ -- static adat_cmd_def_t adat_cmd_set_freq = { ADAT_CMD_DEF_SET_FREQ, ADAT_CMD_KIND_WITHOUT_RESULT, adat_cmd_fn_set_freq, 1, { ADAT_CMD_DEF_STRING_SET_FREQ } }; static adat_cmd_list_t adat_cmd_list_set_freq = { 3, { &adat_cmd_display_off, &adat_cmd_set_freq, &adat_cmd_get_freq, } }; // -- GET VFO -- static adat_cmd_list_t adat_cmd_list_get_vfo = { 2, { &adat_cmd_display_off, &adat_cmd_get_freq, } }; // -- GET MODE -- static adat_cmd_def_t adat_cmd_get_mode = { ADAT_CMD_DEF_GET_MODE, ADAT_CMD_KIND_WITH_RESULT, adat_cmd_fn_get_mode, 1, { ADAT_CMD_DEF_STRING_GET_MODE } }; static adat_cmd_list_t adat_cmd_list_get_mode = { 2, { &adat_cmd_display_off, &adat_cmd_get_mode } }; // -- SET VFO -- static adat_cmd_def_t adat_cmd_set_vfo = { ADAT_CMD_DEF_SET_VFO, ADAT_CMD_KIND_WITHOUT_RESULT, adat_cmd_fn_set_vfo, 2, { ADAT_CMD_DEF_STRING_SWITCH_ON_VFO, ADAT_CMD_DEF_STRING_SET_VFO_AS_MAIN_VFO } }; static adat_cmd_list_t adat_cmd_list_set_vfo = { 2, { &adat_cmd_display_off, &adat_cmd_set_vfo } }; // -- SET MODE -- static adat_cmd_def_t adat_cmd_set_mode = { ADAT_CMD_DEF_SET_MODE, ADAT_CMD_KIND_WITHOUT_RESULT, adat_cmd_fn_set_mode, 1, { ADAT_CMD_DEF_STRING_SET_MODE } }; static adat_cmd_list_t adat_cmd_list_set_mode = { 3, { &adat_cmd_display_off, &adat_cmd_set_vfo, &adat_cmd_set_mode, } }; // -- SET PTT -- static adat_cmd_def_t adat_cmd_set_ptt = { ADAT_CMD_DEF_SET_PTT, ADAT_CMD_KIND_WITHOUT_RESULT, adat_cmd_fn_set_ptt, 1, { ADAT_CMD_DEF_STRING_SET_PTT } }; static adat_cmd_list_t adat_cmd_list_set_ptt = { 2, { &adat_cmd_set_ptt, &adat_cmd_display_off } }; // -- GET PTT -- static adat_cmd_def_t adat_cmd_get_ptt = { ADAT_CMD_DEF_GET_PTT, ADAT_CMD_KIND_WITH_RESULT, adat_cmd_fn_get_ptt, 1, { ADAT_CMD_DEF_STRING_GET_PTT } }; static adat_cmd_list_t adat_cmd_list_get_ptt = { 2, { &adat_cmd_display_off, &adat_cmd_get_ptt } }; // -- GET POWER STATUS -- static adat_cmd_list_t adat_cmd_list_get_powerstatus = { 1, { &adat_cmd_get_id_code } }; // -- GET INFO -- static adat_cmd_list_t adat_cmd_list_get_info = { 7, { &adat_cmd_get_serial_nr, &adat_cmd_get_id_code, &adat_cmd_get_fw_version, &adat_cmd_get_gui_fw_version, &adat_cmd_get_hw_version, &adat_cmd_get_options, &adat_cmd_get_callsign } }; // -- OPEN ADAT -- static adat_cmd_list_t adat_cmd_list_open_adat = { 8, { &adat_cmd_display_off, &adat_cmd_get_serial_nr, &adat_cmd_get_id_code, &adat_cmd_get_fw_version, &adat_cmd_get_gui_fw_version, &adat_cmd_get_hw_version, &adat_cmd_get_options, &adat_cmd_set_callsign } }; // -- CLOSE ADAT -- static adat_cmd_list_t adat_cmd_list_close_adat = { 1, { &adat_cmd_display_on } }; // -- ADAT SPECIAL: RECOVER FROM ERROR -- static adat_cmd_list_t adat_cmd_list_recover_from_error = { 1, { &adat_cmd_display_on } }; // --------------------------------------------------------------------------- // IMPLEMEMTATION // --------------------------------------------------------------------------- // --------------------------------------------------------------------------- // trimwhitespace - taken from Stackoverflow // http://stackoverflow.com/questions/122616/how-do-i-trim-leading-trailing-whitespace-in-a-standard-way // --------------------------------------------------------------------------- // Status: RELEASED size_t trimwhitespace(char *out, size_t len, const char *str) { char *end = NULL; size_t out_size = 0; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. In -> '%s', %d\n", gFnLevel, __func__, __FILE__, __LINE__, str, (int)len); if (len == 0) { gFnLevel--; return 0; } // Trim leading space while (isspace((int)*str)) { str++; } if (*str == 0) // All spaces? { out = NULL; gFnLevel--; return 1; } // Trim trailing space end = (char *)(str + strlen(str) - 1); while (end > str && isspace((int)*end)) { *end = '\0'; end--; } end++; // Set output size to minimum of trimmed string length and buffer size minus 1 //out_size = (end - str) < len-1 ? (end - str) : len - 1; out_size = strlen(str); // Copy trimmed string and add null terminator memcpy(out, str, out_size); out[out_size] = 0; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Out -> \"%s\", %d\n", gFnLevel, __func__, __FILE__, __LINE__, out, (int)out_size); gFnLevel--; return out_size; } // --------------------------------------------------------------------------- // adat_print_cmd // --------------------------------------------------------------------------- // Status: RELEASED int adat_print_cmd(adat_cmd_def_ptr pCmd) { int nRC = RIG_OK; int nI = 0; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %s (%s:%d): ENTRY.\n", __func__, __FILE__, __LINE__); rig_debug(RIG_DEBUG_TRACE, "*** -> Command ID = %u\n", (unsigned int)(pCmd->nCmdId)); rig_debug(RIG_DEBUG_TRACE, "*** -> Command kind = %d\n", pCmd->nCmdKind); while (nI < pCmd->nNrCmdStrs) { rig_debug(RIG_DEBUG_TRACE, "*** -> Command String %d = \"%s\"\n", nI, pCmd->pacCmdStrs[ nI ]); nI++; } rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %s (%s:%d): EXIT. Return Code = %d\n", __func__, __FILE__, __LINE__, nRC); return nRC; } // --------------------------------------------------------------------------- // adat_parse_freq // --------------------------------------------------------------------------- // Status: RELEASED // Can be used to parse strings with VFO nr and without VFO nr in it: // "1 123.456kHz" => nMode = ADAT_FREQ_PARSE_MODE_WITH_VFO // "800Hz" => nMode = ADAT_FREQ_PARSE_MODE_WITHOUT_VFO int adat_parse_freq(char *pcStr, adat_freq_parse_mode_t nMode, int *nVFO, freq_t *nFreq) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pcStr = \"%s\"\n", gFnLevel, __func__, __FILE__, __LINE__, pcStr); if (pcStr != NULL) { int _nVFO = 0; freq_t _nFreq = 0; char *pcEnd = NULL; if (nMode == ADAT_FREQ_PARSE_MODE_WITH_VFO) { // Get VFO from response string _nVFO = strtol(pcStr, &pcEnd, 10); // Save VFO *nVFO = _nVFO; } else { pcEnd = pcStr; } if ((_nVFO != 0) // VFO = 0 -> Current VFO not active. || (nMode == ADAT_FREQ_PARSE_MODE_WITHOUT_VFO)) { char acValueBuf[ ADAT_BUFSZ + 1 ]; char acUnitBuf[ ADAT_BUFSZ + 1 ]; int nI = 0; double dTmpFreq = 0.0; memset(acValueBuf, 0, ADAT_BUFSZ + 1); memset(acUnitBuf, 0, ADAT_BUFSZ + 1); // Get Freq Value from response string while ((isalpha((int)*pcEnd) == 0) || (*pcEnd == '.')) { acValueBuf[ nI++ ] = *pcEnd; pcEnd += sizeof(char); } dTmpFreq = strtod(acValueBuf, (char **) NULL); rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d acValueBuf = \"%s\", dTmpFreq = %f, *pcEnd = %c\n", gFnLevel, acValueBuf, dTmpFreq, *pcEnd); // Get Freq Unit from response string nI = 0; while (isalpha((int)*pcEnd) != 0) { acUnitBuf[ nI++ ] = *pcEnd; pcEnd += sizeof(char); } rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d acUnitBuf = \"%s\"\n", gFnLevel, acUnitBuf); // Normalize to Hz if (!strncmp(acUnitBuf, ADAT_FREQ_UNIT_HZ, ADAT_FREQ_UNIT_HZ_LEN)) { _nFreq = Hz(dTmpFreq); } else { if (!strncmp(acUnitBuf, ADAT_FREQ_UNIT_KHZ, ADAT_FREQ_UNIT_KHZ_LEN)) { _nFreq = kHz(dTmpFreq); } else { if (!strncmp(acUnitBuf, ADAT_FREQ_UNIT_MHZ, ADAT_FREQ_UNIT_MHZ_LEN)) { _nFreq = MHz(dTmpFreq); } else { if (!strncmp(acUnitBuf, ADAT_FREQ_UNIT_GHZ, ADAT_FREQ_UNIT_GHZ_LEN)) { _nFreq = GHz(dTmpFreq); } else { _nFreq = 0; nRC = -RIG_EINVAL; } } } } // Save Freq *nFreq = _nFreq; } } else { // If input string is NULL set Freq and VFO also to NULL *nFreq = 0; *nVFO = 0; } // Done rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d, nVFO = %d, nFreq = %f\n", gFnLevel, __func__, __FILE__, __LINE__, nRC, *nVFO, *nFreq); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_parse_mode // --------------------------------------------------------------------------- // Status: RELEASED int adat_parse_mode(char *pcStr, rmode_t *nRIGMode, char *pcADATMode) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pcStr = \"%s\"\n", gFnLevel, __func__, __FILE__, __LINE__, pcStr); if (pcStr != NULL) { int nI = 0; int nFini = 0; while ((nI < the_adat_mode_list.nNrModes) && (nFini == 0)) { if (!strcmp(pcStr, the_adat_mode_list.adat_modes[ nI ].pcADATModeStr)) { *nRIGMode = the_adat_mode_list.adat_modes[ nI ].nRIGMode; nFini = 1; // Done. } else { nI++; } } } else { // If input string is NULL ... *nRIGMode = RIG_MODE_NONE; pcADATMode = NULL; } // Done rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d, Mode = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC, (int)*nRIGMode); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_mode_rnr2anr // --------------------------------------------------------------------------- // Status: RELEASED int adat_mode_rnr2anr(rmode_t nRIGMode, int *nADATMode) { int nRC = RIG_OK; int nI = 0; int nFini = 0; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: nRIGMode = %u\n", gFnLevel, __func__, __FILE__, __LINE__, (unsigned int)nRIGMode); while ((nI < the_adat_mode_list.nNrModes) && (nFini == 0)) { if (the_adat_mode_list.adat_modes[ nI ].nRIGMode == nRIGMode) { *nADATMode = the_adat_mode_list.adat_modes[ nI ].nADATMode; nFini = 1; // Done. } else { nI++; } } if (nFini == 0) { // No valid Mode given nRC = -RIG_EINVAL; } // Done rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d, ADAT Mode = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC, *nADATMode); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_mode_anr2rnr // --------------------------------------------------------------------------- // Status: RELEASED int adat_mode_anr2rnr(int nADATMode, rmode_t *nRIGMode) { int nRC = RIG_OK; int nI = 0; int nFini = 0; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: nRIGMode = %u\n", gFnLevel, __func__, __FILE__, __LINE__, (unsigned int)*nRIGMode); while ((nI < the_adat_mode_list.nNrModes) && (nFini == 0)) { if (the_adat_mode_list.adat_modes[ nI ].nADATMode == nADATMode) { *nRIGMode = the_adat_mode_list.adat_modes[ nI ].nRIGMode; nFini = 1; // Done. } else { nI++; } } if (nFini == 0) { // No valid Mode given nRC = -RIG_EINVAL; } // Done rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d, RIG Mode = %u\n", gFnLevel, __func__, __FILE__, __LINE__, nRC, (unsigned int)*nRIGMode); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_parse_vfo // --------------------------------------------------------------------------- // Status: RELEASED int adat_parse_vfo(char *pcStr, vfo_t *nRIGVFONr, int *nADATVFONr) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pcStr = \"%s\"\n", gFnLevel, __func__, __FILE__, __LINE__, pcStr); if (pcStr != NULL) { int nI = 0; int nFini = 0; while ((nI < the_adat_vfo_list.nNrVFOs) && (nFini == 0)) { if (!strcmp(pcStr, the_adat_vfo_list.adat_vfos[ nI ].pcADATVFOStr)) { *nRIGVFONr = the_adat_vfo_list.adat_vfos[ nI ].nRIGVFONr; *nADATVFONr = the_adat_vfo_list.adat_vfos[ nI ].nADATVFONr; nFini = 1; // Done. } else { nI++; } } if (nFini == 0) { nRC = -RIG_EINVAL; } } else { // If input string is NULL ... *nRIGVFONr = RIG_VFO_NONE; *nADATVFONr = 0; } // Done rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d, RIG VFO Nr = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC, *nRIGVFONr); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_vfo_rnr2anr // --------------------------------------------------------------------------- // Status: RELEASED int adat_vfo_rnr2anr(vfo_t nRIGVFONr, int *nADATVFONr) { int nRC = RIG_OK; int nI = 0; int nFini = 0; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: nRIGVFONr = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRIGVFONr); while ((nI < the_adat_vfo_list.nNrVFOs) && (nFini == 0)) { if (the_adat_vfo_list.adat_vfos[ nI ].nRIGVFONr == nRIGVFONr) { *nADATVFONr = the_adat_vfo_list.adat_vfos[ nI ].nADATVFONr; nFini = 1; // Done. } else { nI++; } } if (nFini == 0) { // No valid Mode given nRC = -RIG_EINVAL; } // Done rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d, ADAT VFO Nr = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC, *nADATVFONr); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_vfo_anr2rnr // --------------------------------------------------------------------------- // Status: RELEASED int adat_vfo_anr2rnr(int nADATVFONr, vfo_t *nRIGVFONr) { int nRC = RIG_OK; int nI = 0; int nFini = 0; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: nADATVFONr = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nADATVFONr); while ((nI < the_adat_vfo_list.nNrVFOs) && (nFini == 0)) { if (the_adat_vfo_list.adat_vfos[ nI ].nADATVFONr == nADATVFONr) { *nRIGVFONr = the_adat_vfo_list.adat_vfos[ nI ].nRIGVFONr; nFini = 1; // Done. } else { nI++; } } if (nFini == 0) { // No valid ADAT VFO Nr given nRC = -RIG_EINVAL; } // Done rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d, RIG VFO Nr = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC, *nRIGVFONr); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_parse_ptt // --------------------------------------------------------------------------- // Status: RELEASED int adat_parse_ptt(char *pcStr, int *nADATPTTStatus) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pcStr = \"%s\"\n", gFnLevel, __func__, __FILE__, __LINE__, pcStr); if ((pcStr != NULL) && (strlen(pcStr) > 0)) { *nADATPTTStatus = strtol(pcStr, NULL, 10); } else { // If input string is NULL ... *nADATPTTStatus = ADAT_PTT_STATUS_ANR_OFF; nRC = -RIG_EINVAL; } // Done rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_ptt_rnr2anr // --------------------------------------------------------------------------- // Status: RELEASED int adat_ptt_rnr2anr(ptt_t nRIGPTTStatus, int *nADATPTTStatus) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: nRIGPTTStatus = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRIGPTTStatus); switch (nRIGPTTStatus) { case ADAT_PTT_STATUS_RNR_ON: *nADATPTTStatus = ADAT_PTT_STATUS_ANR_ON; break; case ADAT_PTT_STATUS_RNR_OFF: *nADATPTTStatus = ADAT_PTT_STATUS_ANR_OFF; break; default: nRC = -RIG_EINVAL; break; } // Done rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d, ADAT PTT Status = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC, *nADATPTTStatus); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_ptt_anr2rnr // --------------------------------------------------------------------------- // Status: RELEASED int adat_ptt_anr2rnr(int nADATPTTStatus, ptt_t *nRIGPTTStatus) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: nADATPTTStatus = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nADATPTTStatus); switch (nADATPTTStatus) { case ADAT_PTT_STATUS_ANR_ON: *nRIGPTTStatus = ADAT_PTT_STATUS_RNR_ON; break; case ADAT_PTT_STATUS_ANR_OFF: *nRIGPTTStatus = ADAT_PTT_STATUS_RNR_OFF; break; default: nRC = -RIG_EINVAL; break; } // Done rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d, RIG PTT Status = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC, *nRIGPTTStatus); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_send // --------------------------------------------------------------------------- // Status: RELEASED int adat_send(RIG *pRig, char *pcData) { int nRC = RIG_OK; struct rig_state *pRigState = &pRig->state; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p, pcData = %s\n", gFnLevel, __func__, __FILE__, __LINE__, pRig, pcData); serial_flush(&pRigState->rigport); nRC = write_block(&pRigState->rigport, pcData, strlen(pcData)); rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_receive // --------------------------------------------------------------------------- // Status: RELEASED int adat_receive(RIG *pRig, char *pcData) { int nRC = RIG_OK; struct rig_state *pRigState = &pRig->state; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); nRC = read_string(&pRigState->rigport, pcData, ADAT_RESPSZ, ADAT_EOL, 1); if (nRC > 0) { nRC = RIG_OK; } rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_priv_set_cmd // --------------------------------------------------------------------------- // Status: RELEASED int adat_priv_set_cmd(RIG *pRig, char *pcCmd, int nCmdKind) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p, pcCmd = \"%s\"\n", gFnLevel, __func__, __FILE__, __LINE__, pRig, pcCmd); if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; if (pPriv->pcCmd != NULL) { free(pPriv->pcCmd); } pPriv->pcCmd = strdup(pcCmd); pPriv->nCmdKind = nCmdKind; } // Done ! rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_priv_set_result // --------------------------------------------------------------------------- // Status: RELEASED int adat_priv_set_result(RIG *pRig, char *pcResult) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p, pcResult = \"%s\"\n", gFnLevel, __func__, __FILE__, __LINE__, pRig, pcResult); if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; if (pPriv->pcResult != NULL) { free(pPriv->pcResult); } pPriv->pcResult = strdup(pcResult); rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d pPriv->pcResult = \"%s\"\n", gFnLevel, pPriv->pcResult); } // Done ! rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_priv_clear_result // --------------------------------------------------------------------------- // Status: RELEASED int adat_priv_clear_result(RIG *pRig) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; if (pPriv->pcResult != NULL) { free(pPriv->pcResult); } pPriv->pcResult = NULL; } // Done ! rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_get_single_cmd_result // --------------------------------------------------------------------------- // Status: RELEASED int adat_get_single_cmd_result(RIG *pRig) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; struct rig_state *pRigState = &pRig->state; nRC = adat_send(pRig, pPriv->pcCmd); if ((nRC == RIG_OK) && (pPriv->nCmdKind == ADAT_CMD_KIND_WITH_RESULT)) { char acBuf[ ADAT_RESPSZ + 1 ]; char acBuf2[ ADAT_RESPSZ + 1 ]; int nBufLength = 0; char *pcBufEnd = NULL; char *pcPos = NULL; char *pcResult = NULL; memset(acBuf, 0, ADAT_RESPSZ + 1); memset(acBuf2, 0, ADAT_RESPSZ + 1); nRC = adat_receive(pRig, acBuf); rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d acBuf ........ = %p\n", gFnLevel, acBuf); pcPos = acBuf; if ((nRC == RIG_OK) && (pcPos != NULL)) { int nLength = 0; if (*pcPos == '\0') // Adjust for 00 byte at beginning ... { pcPos++; // No, please don't ask me why this happens ... ;-) } nBufLength = strlen(pcPos); pcBufEnd = pcPos + nBufLength - 1; pcResult = pcPos; // Save position if (pcPos < pcBufEnd) { nLength = strlen(pcPos); if (nLength > 0) { char *pcPos2 = strchr(pcPos, (char) 0x0d); if (pcPos2 != NULL) { *pcPos2 = '\0'; // Truncate \0d\0a } pcPos = strchr(pcPos, ' '); if ((pcPos != NULL) && (pcPos < pcBufEnd)) { pcPos += sizeof(char); rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d pcPos ........ = %p\n", gFnLevel, pcPos); rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d pcBufEnd ..... = %p\n", gFnLevel, pcBufEnd); rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d nBufLength ... = %d\n", gFnLevel, nBufLength); rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d pcPos2 ....... = %p\n", gFnLevel, pcPos2); trimwhitespace(acBuf2, strlen(pcPos), pcPos); pcResult = acBuf2; } } else { nRC = -RIG_EINVAL; } } else { nRC = -RIG_EINVAL; } if (nRC == RIG_OK) { adat_priv_set_result(pRig, pcResult); } else { adat_priv_clear_result(pRig); } } } serial_flush(&pRigState->rigport); pPriv->nRC = nRC; } // Done ! rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_cmd_recover_from_error // --------------------------------------------------------------------------- // Status: RELEASED int adat_cmd_recover_from_error(RIG *pRig, int nError) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; // Recover from communication error if ((nError == RIG_ETIMEOUT) || (nError == RIG_EPROTO) || (nError == RIG_EIO)) { rig_close(pRig); sleep(ADAT_SLEEP_AFTER_RIG_CLOSE); rig_open(pRig); } // Reset critical Priv values pPriv->nRC = RIG_OK; // Execute recovery commands (void) adat_transaction(pRig, &adat_cmd_list_recover_from_error); } // Done ! rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_cmd_fn_get_callsign // --------------------------------------------------------------------------- // Status: RELEASED int adat_cmd_fn_get_callsign(RIG *pRig) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; nRC = adat_priv_set_cmd(pRig, ADAT_CMD_DEF_STRING_GET_CALLSIGN, ADAT_CMD_KIND_WITH_RESULT); if (nRC == RIG_OK) { nRC = adat_get_single_cmd_result(pRig); if (nRC == RIG_OK) { pPriv->pcCallsign = strdup(pPriv->pcResult); rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d pPriv->pcCallsign = \"%s\"\n", gFnLevel, pPriv->pcCallsign); } } } // Done ! rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_cmd_fn_set_callsign // --------------------------------------------------------------------------- // Status: IN WORK int adat_cmd_fn_set_callsign(RIG *pRig) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); if (pRig == NULL) { nRC = -RIG_EARG; } else { char acBuf[ ADAT_BUFSZ + 1 ]; memset(acBuf, 0, ADAT_BUFSZ + 1); strcpy(acBuf, ADAT_CMD_DEF_STRING_SET_CALLSIGN); strcat(acBuf, "DG1SBG"ADAT_CR); nRC = adat_priv_set_cmd(pRig, acBuf, ADAT_CMD_KIND_WITHOUT_RESULT); if (nRC == RIG_OK) { nRC = adat_get_single_cmd_result(pRig); } } // Done ! rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_cmd_fn_get_serial_nr // --------------------------------------------------------------------------- // Status: RELEASED int adat_cmd_fn_get_serial_nr(RIG *pRig) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; nRC = adat_priv_set_cmd(pRig, ADAT_CMD_DEF_STRING_GET_SERIAL_NR, ADAT_CMD_KIND_WITH_RESULT); if (nRC == RIG_OK) { nRC = adat_get_single_cmd_result(pRig); if (nRC == RIG_OK) { pPriv->pcSerialNr = strdup(pPriv->pcResult); rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d pPriv->pcSerialNr = \"%s\"\n", gFnLevel, pPriv->pcSerialNr); } } } // Done ! rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_cmd_fn_get_fw_version // --------------------------------------------------------------------------- // Status: RELEASED int adat_cmd_fn_get_fw_version(RIG *pRig) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; nRC = adat_priv_set_cmd(pRig, ADAT_CMD_DEF_STRING_GET_FW_VERSION, ADAT_CMD_KIND_WITH_RESULT); if (nRC == RIG_OK) { nRC = adat_get_single_cmd_result(pRig); if (nRC == RIG_OK) { pPriv->pcFWVersion = strdup(pPriv->pcResult); rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d pPriv->pcFWVersion = \"%s\"\n", gFnLevel, pPriv->pcFWVersion); } } } // Done ! rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_cmd_fn_get_hw_version // --------------------------------------------------------------------------- // Status: RELEASED int adat_cmd_fn_get_hw_version(RIG *pRig) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; nRC = adat_priv_set_cmd(pRig, ADAT_CMD_DEF_STRING_GET_HW_VERSION, ADAT_CMD_KIND_WITH_RESULT); if (nRC == RIG_OK) { nRC = adat_get_single_cmd_result(pRig); if (nRC == RIG_OK) { pPriv->pcHWVersion = strdup(pPriv->pcResult); rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d pPriv->pcHWVersion = \"%s\"\n", gFnLevel, pPriv->pcHWVersion); } } } // Done ! rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_cmd_fn_get_gui_fw_version // --------------------------------------------------------------------------- // Status: RELEASED int adat_cmd_fn_get_gui_fw_version(RIG *pRig) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; nRC = adat_priv_set_cmd(pRig, ADAT_CMD_DEF_STRING_GET_GUI_FW_VERSION, ADAT_CMD_KIND_WITH_RESULT); if (nRC == RIG_OK) { nRC = adat_get_single_cmd_result(pRig); if (nRC == RIG_OK) { pPriv->pcGUIFWVersion = strdup(pPriv->pcResult); rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d pPriv->pcGUIFWVersion = \"%s\"\n", gFnLevel, pPriv->pcGUIFWVersion); } } } // Done ! rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_cmd_fn_get_id_code // --------------------------------------------------------------------------- // Status: RELEASED int adat_cmd_fn_get_id_code(RIG *pRig) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; nRC = adat_priv_set_cmd(pRig, ADAT_CMD_DEF_STRING_GET_ID_CODE, ADAT_CMD_KIND_WITH_RESULT); if (nRC == RIG_OK) { nRC = adat_get_single_cmd_result(pRig); if (nRC == RIG_OK) { pPriv->pcIDCode = strdup(pPriv->pcResult); rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d pPriv->pcIDCode = \"%s\"\n", gFnLevel, pPriv->pcIDCode); } } } // Done ! rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_cmd_fn_get_options // --------------------------------------------------------------------------- // Status: RELEASED int adat_cmd_fn_get_options(RIG *pRig) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; nRC = adat_priv_set_cmd(pRig, ADAT_CMD_DEF_STRING_GET_OPTIONS, ADAT_CMD_KIND_WITH_RESULT); if (nRC == RIG_OK) { nRC = adat_get_single_cmd_result(pRig); if (nRC == RIG_OK) { pPriv->pcOptions = strdup(pPriv->pcResult); rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d pPriv->pcOptions = \"%s\"\n", gFnLevel, pPriv->pcOptions); } } } // Done ! rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_cmd_fn_get_mode // --------------------------------------------------------------------------- // Status: RELEASED int adat_cmd_fn_get_mode(RIG *pRig) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; nRC = adat_priv_set_cmd(pRig, ADAT_CMD_DEF_STRING_GET_MODE, ADAT_CMD_KIND_WITH_RESULT); if (nRC == RIG_OK) { nRC = adat_get_single_cmd_result(pRig); if (nRC == RIG_OK) { nRC = adat_parse_mode(pPriv->pcResult, &(pPriv->nRIGMode), pPriv->acADATMode); } } } // Done ! rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_cmd_fn_set_mode // --------------------------------------------------------------------------- // Status: RELEASED int adat_cmd_fn_set_mode(RIG *pRig) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; // Translate Mode from RIG Mode Nr to ADAT Mode Nr nRC = adat_mode_rnr2anr(pPriv->nRIGMode, &(pPriv->nADATMode)); if (nRC == RIG_OK) { // Prepare Command char acBuf[ ADAT_BUFSZ + 1 ]; memset(acBuf, 0, ADAT_BUFSZ + 1); snprintf(acBuf, ADAT_BUFSZ, "%s%02d%s", ADAT_CMD_DEF_STRING_SET_MODE, (int) pPriv->nADATMode, ADAT_EOM); nRC = adat_priv_set_cmd(pRig, acBuf, ADAT_CMD_KIND_WITHOUT_RESULT); // Execute Command if (nRC == RIG_OK) { nRC = adat_get_single_cmd_result(pRig); } } } // Done ! rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_cmd_fn_get_freq // --------------------------------------------------------------------------- // Status: RELEASED int adat_cmd_fn_get_freq(RIG *pRig) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; nRC = adat_priv_set_cmd(pRig, ADAT_CMD_DEF_STRING_GET_FREQ, ADAT_CMD_KIND_WITH_RESULT); if (nRC == RIG_OK) { nRC = adat_get_single_cmd_result(pRig); if (nRC == RIG_OK) { nRC = adat_parse_freq(pPriv->pcResult, ADAT_FREQ_PARSE_MODE_WITH_VFO, &(pPriv->nCurrentVFO), &(pPriv->nFreq)); rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d pPriv->nCurrentVFO = %d, Freq [Hz] = %f\n", gFnLevel, pPriv->nCurrentVFO, pPriv->nFreq); if (nRC == RIG_OK) { nRC = adat_vfo_anr2rnr(pPriv->nCurrentVFO, &(pPriv->nRIGVFONr)); } } } } // Done ! rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_cmd_fn_set_freq // --------------------------------------------------------------------------- // Status: RELEASED int adat_cmd_fn_set_freq(RIG *pRig) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; char acBuf[ ADAT_BUFSZ + 1 ]; // Get frequency of selected VFO memset(acBuf, 0, ADAT_BUFSZ + 1); snprintf(acBuf, ADAT_BUFSZ, "%s%d%s", ADAT_CMD_DEF_STRING_SET_FREQ, (int) pPriv->nFreq, ADAT_EOM); nRC = adat_priv_set_cmd(pRig, acBuf, ADAT_CMD_KIND_WITHOUT_RESULT); if (nRC == RIG_OK) { nRC = adat_get_single_cmd_result(pRig); } } // Done ! rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_cmd_fn_set_vfo // --------------------------------------------------------------------------- // Status: RELEASED // Setting a VFO on an ADAT is actually two steps: // 1. Switching on that VFO // 2. Setting this VFO as the main VFO int adat_cmd_fn_set_vfo(RIG *pRig) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; char acBuf[ ADAT_BUFSZ + 1 ]; // Switch on VFO memset(acBuf, 0, ADAT_BUFSZ + 1); snprintf(acBuf, ADAT_BUFSZ, ADAT_CMD_DEF_STRING_SWITCH_ON_VFO, (int) pPriv->nCurrentVFO, ADAT_EOM); nRC = adat_priv_set_cmd(pRig, acBuf, ADAT_CMD_KIND_WITHOUT_RESULT); if (nRC == RIG_OK) { nRC = adat_get_single_cmd_result(pRig); if (nRC == RIG_OK) { memset(acBuf, 0, ADAT_BUFSZ + 1); snprintf(acBuf, ADAT_BUFSZ, ADAT_CMD_DEF_STRING_SET_VFO_AS_MAIN_VFO, (int) pPriv->nCurrentVFO, ADAT_EOM); nRC = adat_priv_set_cmd(pRig, acBuf, ADAT_CMD_KIND_WITHOUT_RESULT); if (nRC == RIG_OK) { nRC = adat_get_single_cmd_result(pRig); } } } } // Done ! rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_cmd_fn_get_ptt // --------------------------------------------------------------------------- // Status: RELEASED int adat_cmd_fn_get_ptt(RIG *pRig) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; nRC = adat_priv_set_cmd(pRig, ADAT_CMD_DEF_STRING_GET_PTT, ADAT_CMD_KIND_WITH_RESULT); if (nRC == RIG_OK) { nRC = adat_get_single_cmd_result(pRig); if (nRC == RIG_OK) { nRC = adat_parse_ptt(pPriv->pcResult, &(pPriv->nADATPTTStatus)); if (nRC == RIG_OK) { nRC = adat_ptt_anr2rnr(pPriv->nADATPTTStatus, &(pPriv->nRIGPTTStatus)); } } } } // Done ! rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_cmd_fn_set_ptt // --------------------------------------------------------------------------- // Status: RELEASED int adat_cmd_fn_set_ptt(RIG *pRig) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; char acBuf[ ADAT_BUFSZ + 1 ]; char *pcPTTStr = NULL; memset(acBuf, 0, ADAT_BUFSZ + 1); // Switch PTT switch (pPriv->nOpCode) { case ADAT_OPCODE_PTT_SWITCH_ON: pPriv->nADATPTTStatus = ADAT_PTT_STATUS_ANR_ON; nRC = adat_ptt_anr2rnr(ADAT_PTT_STATUS_ANR_ON, &(pPriv->nRIGPTTStatus)); pcPTTStr = ADAT_CMD_PTT_STR_ON; break; case ADAT_OPCODE_PTT_SWITCH_OFF: pPriv->nADATPTTStatus = ADAT_PTT_STATUS_ANR_OFF; nRC = adat_ptt_anr2rnr(ADAT_PTT_STATUS_ANR_OFF, &(pPriv->nRIGPTTStatus)); pcPTTStr = ADAT_CMD_PTT_STR_OFF; break; default: nRC = -RIG_EINVAL; break; } if (nRC == RIG_OK) { snprintf(acBuf, ADAT_BUFSZ, ADAT_CMD_DEF_STRING_SET_PTT, pcPTTStr, ADAT_EOM); nRC = adat_priv_set_cmd(pRig, acBuf, ADAT_CMD_KIND_WITHOUT_RESULT); if (nRC == RIG_OK) { nRC = adat_get_single_cmd_result(pRig); } } } // Done ! rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_transaction // --------------------------------------------------------------------------- // Status: RELEASED // adat_transaction is a generalized command processor able to execute // commands of type adat_cmd_def_t . int adat_transaction(RIG *pRig, adat_cmd_list_ptr pCmdList) { int nRC = RIG_OK; int nFini = 0; // = 1 -> Stop executing commands gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); if (pRig == NULL) { nRC = -RIG_EARG; } else { int nI = 0; adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): Nr of commands = %d\n", gFnLevel, __func__, __FILE__, __LINE__, pCmdList->nNrCmds); while ((nRC == RIG_OK) && (nFini == 0) && (nI < pCmdList->nNrCmds)) { adat_cmd_def_ptr pCmd = NULL; pCmd = pCmdList->adat_cmds[ nI ]; if ((pCmd != NULL) && (pCmd->nCmdId != ADAT_CMD_DEF_NIL)) { rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d About to execute ADAT Command ... \n", gFnLevel); adat_print_cmd(pCmd); // Execute Command if (pCmd->pfCmdFn != NULL) { rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d Calling function via fn ptr ... \n", gFnLevel); nRC = pCmd->pfCmdFn(pRig); } else { rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d Sending command string ... \n", gFnLevel); // TODO: Quell clang warning of conditional always evaluating to true. // if( pCmd->pacCmdStrs != NULL ) // { int nJ = 0; if (pCmd->nNrCmdStrs > 0) { rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d pacCmdStrs[%d] = %s\n", gFnLevel, nJ, pCmd->pacCmdStrs[ nJ ]); while ((nJ < pCmd->nNrCmdStrs) && (nRC == RIG_OK) && (pCmd->pacCmdStrs[ nJ ] != NULL)) { nRC = adat_send(pRig, pCmd->pacCmdStrs[ nJ ]); if (nRC == RIG_OK) { if (pCmd->nCmdKind == ADAT_CMD_KIND_WITH_RESULT) { char acBuf[ ADAT_RESPSZ + 1 ]; memset(acBuf, 0, ADAT_RESPSZ + 1); nRC = adat_receive(pRig, acBuf); while ((nRC == RIG_OK) && (strncmp(acBuf, ADAT_BOM, strlen(ADAT_BOM)) != 0)) { nRC = adat_receive(pRig, acBuf); } pPriv->pcResult = strdup(acBuf); } } nJ++; } } // } } if (nRC != RIG_OK) { (void) adat_cmd_recover_from_error(pRig, nRC); } nI++; } else { nFini = 1; } // sleep between cmds - ADAT needs time to act upoon cmds usleep(ADAT_SLEEP_MICROSECONDS_BETWEEN_CMDS); } } // Done ! rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // adat_new_priv_data // --------------------------------------------------------------------------- // Status: RELEASED adat_priv_data_ptr adat_new_priv_data(RIG *pRig) { int nRC = 0; adat_priv_data_ptr pPriv = NULL; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); if (pRig != NULL) { // Init Priv Data pPriv = (adat_priv_data_ptr) calloc(sizeof(adat_priv_data_t), 1); if (pPriv != NULL) { char acBuf[ ADAT_BUFSZ + 1 ]; memset(acBuf, 0, ADAT_BUFSZ + 1); // FIXME: pointless code at init time #if 0 nRC = adat_get_conf(pRig, TOKEN_ADAT_PRODUCT_NAME, acBuf); if (nRC == 0) { pPriv->pcProductName = strdup(acBuf); pRig->state.priv = (void *) pPriv; } #else pRig->state.priv = (void *) pPriv; #endif } else { nRC = -RIG_ENOMEM; } } else { nRC = -RIG_EARG; } rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. RC = %d, pPriv = %p\n", gFnLevel, __func__, __FILE__, __LINE__, nRC, pPriv); gFnLevel--; return pPriv; } // --------------------------------------------------------------------------- // adat_del_priv_data // --------------------------------------------------------------------------- // Status: RELEASED void adat_del_priv_data(adat_priv_data_t **ppPriv) { int nRC = 0; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: ppPrivData = %p\n", gFnLevel, __func__, __FILE__, __LINE__, ppPriv); if ((ppPriv != NULL) && (*ppPriv != NULL)) { // Delete / Free Priv Data if ((*ppPriv)->pcProductName != NULL) { free((*ppPriv)->pcProductName); } if ((*ppPriv)->pcSerialNr != NULL) { free((*ppPriv)->pcSerialNr); } if ((*ppPriv)->pcHWVersion != NULL) { free((*ppPriv)->pcHWVersion); } if ((*ppPriv)->pcFWVersion != NULL) { free((*ppPriv)->pcFWVersion); } if ((*ppPriv)->pcGUIFWVersion != NULL) { free((*ppPriv)->pcGUIFWVersion); } if ((*ppPriv)->pcOptions != NULL) { free((*ppPriv)->pcOptions); } if ((*ppPriv)->pcIDCode != NULL) { free((*ppPriv)->pcIDCode); } if ((*ppPriv)->pcCallsign != NULL) { free((*ppPriv)->pcCallsign); } // Free priv struct itself free((*ppPriv)); *ppPriv = NULL; } else { nRC = -RIG_EARG; } rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. RC = %d.\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return; } // --------------------------------------------------------------------------- // Function adat_init // --------------------------------------------------------------------------- // Status: RELEASED int adat_init(RIG *pRig) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); // Check Params if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = NULL; // Get new Priv Data pPriv = adat_new_priv_data(pRig); if (pPriv == NULL) { nRC = -RIG_ENOMEM; } } // Done ! rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // Function adat_cleanup // --------------------------------------------------------------------------- // Status: RELEASED int adat_cleanup(RIG *pRig) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); if (pRig == NULL) { nRC = -RIG_EARG; } else { if (pRig->state.priv != NULL) { adat_del_priv_data((adat_priv_data_t **) & (pRig->state.priv)); pRig->state.priv = NULL; } } rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // Function adat_open // --------------------------------------------------------------------------- // Status: RELEASED int adat_open(RIG *pRig) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); // Check Params if (pRig == NULL) { nRC = -RIG_EARG; } else { // grace period for the radio to be there sleep(ADAT_SLEEP_AFTER_RIG_OPEN); // Now get basic info from ADAT TRX nRC = adat_transaction(pRig, &adat_cmd_list_open_adat); } // Done ! rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // Function adat_close // --------------------------------------------------------------------------- // Status: RELEASED int adat_close(RIG *pRig) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); // Check Params if (pRig == NULL) { nRC = -RIG_EARG; } else { // Now switch to interactive mode nRC = adat_transaction(pRig, &adat_cmd_list_close_adat); } // Done ! rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // Function adat_get_info // --------------------------------------------------------------------------- // Status: RELEASED const char *adat_get_info(RIG *pRig) { int nRC = RIG_OK; static char acBuf[ 512 ]; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); memset(acBuf, 0, 512); if (pRig != NULL) { nRC = adat_transaction(pRig, &adat_cmd_list_get_info); if (nRC == RIG_OK) { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; snprintf(acBuf, 512, "ADAT ADT-200A, Callsign: %s, S/N: %s, ID Code: %s, Options: %s, FW: %s, GUI FW: %s, HW: %s", pPriv->pcCallsign, pPriv->pcSerialNr, pPriv->pcIDCode, pPriv->pcOptions, pPriv->pcFWVersion, pPriv->pcGUIFWVersion, pPriv->pcHWVersion); } } rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Value ='%s'\n", gFnLevel, __func__, __FILE__, __LINE__, acBuf); gFnLevel--; return acBuf; } // --------------------------------------------------------------------------- // Function adat_set_freq // --------------------------------------------------------------------------- // Status: RELEASED int adat_set_freq(RIG *pRig, vfo_t vfo, freq_t freq) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); // Check Params if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; pPriv->nFreq = freq; nRC = adat_transaction(pRig, &adat_cmd_list_set_freq); } rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // Function adat_get_freq // --------------------------------------------------------------------------- // Status: RELEASED int adat_get_freq(RIG *pRig, vfo_t vfo, freq_t *freq) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); // Check Params if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; nRC = adat_transaction(pRig, &adat_cmd_list_get_freq); *freq = pPriv->nFreq; } rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // Function adat_set_level // --------------------------------------------------------------------------- // Status: IN WORK int adat_set_level(RIG *pRig, vfo_t vfo, setting_t level, value_t val) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); // Check Params if (pRig == NULL) { nRC = -RIG_EARG; } else { //adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; } rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // Function adat_get_level // --------------------------------------------------------------------------- // Status: IN WORK int adat_get_level(RIG *pRig, vfo_t vfo, setting_t level, value_t *val) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); // Check Params if (pRig == NULL) { nRC = -RIG_EARG; } else { //adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; } rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // Function adat_set_mode // --------------------------------------------------------------------------- // Status: RELEASED int adat_set_mode(RIG *pRig, vfo_t vfo, rmode_t mode, pbwidth_t width) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); // Check Params if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; pPriv->nRIGMode = mode; nRC = adat_vfo_rnr2anr(vfo, &(pPriv->nCurrentVFO)); if (width != RIG_PASSBAND_NOCHANGE) { if (width == RIG_PASSBAND_NORMAL) { width = rig_passband_normal(pRig, mode); } pPriv->nWidth = width; } nRC = adat_transaction(pRig, &adat_cmd_list_set_mode); } rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // Function adat_get_mode // --------------------------------------------------------------------------- // Status: RELEASED int adat_get_mode(RIG *pRig, vfo_t vfo, rmode_t *mode, pbwidth_t *width) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); // Check Params if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; nRC = adat_transaction(pRig, &adat_cmd_list_get_mode); if (nRC == RIG_OK) { *mode = pPriv->nRIGMode; *width = pPriv->nWidth; } } rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // Function adat_get_vfo // --------------------------------------------------------------------------- // Status: RELEASED int adat_get_vfo(RIG *pRig, vfo_t *vfo) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); // Check Params if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; nRC = adat_transaction(pRig, &adat_cmd_list_get_vfo); *vfo = pPriv->nRIGVFONr; } rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // Function adat_set_vfo // --------------------------------------------------------------------------- // Status: RELEASED int adat_set_vfo(RIG *pRig, vfo_t vfo) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); // Check Params if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; nRC = adat_vfo_rnr2anr(vfo, &(pPriv->nCurrentVFO)); if (nRC == RIG_OK) { nRC = adat_transaction(pRig, &adat_cmd_list_set_vfo); } } rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // Function adat_get_ptt // --------------------------------------------------------------------------- // Status: RELEASED int adat_get_ptt(RIG *pRig, vfo_t vfo, ptt_t *ptt) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); // Check Params if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; nRC = adat_transaction(pRig, &adat_cmd_list_get_ptt); *ptt = pPriv->nRIGPTTStatus; } rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // Function adat_set_ptt // --------------------------------------------------------------------------- // Status: RELEASED int adat_set_ptt(RIG *pRig, vfo_t vfo, ptt_t ptt) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); // Check Params if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; switch (ptt) { case RIG_PTT_ON: pPriv->nOpCode = ADAT_OPCODE_PTT_SWITCH_ON; break; case RIG_PTT_OFF: pPriv->nOpCode = ADAT_OPCODE_PTT_SWITCH_OFF; break; default: nRC = -RIG_EINVAL; break; } if (nRC == RIG_OK) { nRC = adat_transaction(pRig, &adat_cmd_list_set_ptt); } } rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // Function adat_power2mW // --------------------------------------------------------------------------- // Status: RELEASED int adat_power2mW(RIG *pRig, unsigned int *mwpower, float power, freq_t freq, rmode_t mode) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); // Check Params if ((pRig == NULL) || (mwpower == NULL)) { nRC = -RIG_EARG; } else { *mwpower = power * ADAT_MAX_POWER_IN_mW; } rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // Function adat_mW2power // --------------------------------------------------------------------------- // Status: RELEASED int adat_mW2power(RIG *pRig, float *power, unsigned int mwpower, freq_t freq, rmode_t mode) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); // Check Params if ((pRig == NULL) || (power == NULL)) { nRC = -RIG_EARG; } else { *power = mwpower / ((float)ADAT_MAX_POWER_IN_mW); } rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // Function adat_get_powerstat // --------------------------------------------------------------------------- // Status: RELEASED int adat_get_powerstat(RIG *pRig, powerstat_t *status) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); // Check Params if (pRig == NULL) { nRC = -RIG_EARG; } else { //adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; nRC = adat_transaction(pRig, &adat_cmd_list_get_powerstatus); // nRC < 0 -> Power is off. if (nRC == RIG_OK) { *status = RIG_POWER_ON; } else { *status = RIG_POWER_OFF; nRC = RIG_OK; } } rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // Function adat_set_conf // --------------------------------------------------------------------------- // Status: IN WORK int adat_set_conf(RIG *pRig, token_t token, const char *val) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); // Check Params if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; switch (token) { case TOKEN_ADAT_PRODUCT_NAME: pPriv->pcProductName = strdup(val); break; default: nRC = -RIG_EINVAL; } } rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // Function adat_get_conf // --------------------------------------------------------------------------- // Status: IN WORK int adat_get_conf(RIG *pRig, token_t token, char *val) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); // Check Params if (pRig == NULL) { nRC = -RIG_EARG; } else { adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; switch (token) { case TOKEN_ADAT_PRODUCT_NAME: val = pPriv->pcProductName; break; default: nRC = -RIG_EINVAL; } } rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // Function adat_reset // --------------------------------------------------------------------------- // Status: IN WORK int adat_reset(RIG *pRig, reset_t reset) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); // Check Params if (pRig == NULL) { nRC = -RIG_EARG; } else { //adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; } rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // Function adat_handle_event // --------------------------------------------------------------------------- // Status: IN WORK int adat_handle_event(RIG *pRig) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n", gFnLevel, __func__, __FILE__, __LINE__, pRig); // Check Params if (pRig == NULL) { nRC = -RIG_EARG; } else { //adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv; char acBuf[ ADAT_RESPSZ + 1 ]; memset(acBuf, 0, ADAT_RESPSZ + 1); adat_receive(pRig, acBuf); rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d Event data = \"%s\"\n", gFnLevel, acBuf); } rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // initrigs_adat is called by rig_backend_load // --------------------------------------------------------------------------- // Status: RELEASED DECLARE_INITRIG_BACKEND(adat) { int nRC = RIG_OK; gFnLevel++; #if 0 rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY.\n", gFnLevel, __func__, __FILE__, __LINE__); #endif rig_register(&adt_200a_caps); #if 0 rig_debug(RIG_DEBUG_VERBOSE, "ADAT: Rig ADT-200A registered.\n"); rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); #endif gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // proberig_adat // --------------------------------------------------------------------------- // Status: UNTESTED DECLARE_PROBERIG_BACKEND(adat) { int nRC = RIG_OK; gFnLevel++; rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): ENTRY.\n", gFnLevel, __func__, __FILE__, __LINE__); if (!port) { return RIG_MODEL_NONE; } if (port->type.rig != RIG_PORT_SERIAL) { return RIG_MODEL_NONE; } port->write_delay = port->post_write_delay = 10; port->parm.serial.stop_bits = 0; port->retry = 1; nRC = serial_open(port); if (nRC != RIG_OK) { nRC = RIG_MODEL_NONE; } else { char acBuf[ ADAT_RESPSZ + 1 ]; int nRead = 0; memset(acBuf, 0, ADAT_RESPSZ + 1); nRC = write_block(port, ADAT_CMD_DEF_STRING_GET_ID_CODE, strlen(ADAT_CMD_DEF_STRING_GET_ID_CODE)); nRead = read_string(port, acBuf, ADAT_RESPSZ, ADAT_EOM, 1); close(port->fd); if ((nRC != RIG_OK || nRead < 0)) { nRC = RIG_MODEL_NONE; } else { rig_debug(RIG_DEBUG_VERBOSE, "ADAT: %d Received ID = %s.", gFnLevel, acBuf); nRC = RIG_MODEL_ADT_200A; } } rig_debug(RIG_DEBUG_TRACE, "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n", gFnLevel, __func__, __FILE__, __LINE__, nRC); gFnLevel--; return nRC; } // --------------------------------------------------------------------------- // END OF FILE // ---------------------------------------------------------------------------