1 // ---------------------------------------------------------------------------
2 // ADAT Hamlib Backend
3 // ---------------------------------------------------------------------------
4 //
5 // adat.c
6 //
7 // Created by Frank Goenninger DG1SBG.
8 // Copyright © 2011, 2012 Frank Goenninger.
9 //
10 // This library is free software; you can redistribute it and/or
11 // modify it under the terms of the GNU Lesser General Public
12 // License as published by the Free Software Foundation; either
13 // version 2.1 of the License, or (at your option) any later version.
14 //
15 // This library is distributed in the hope that it will be useful,
16 // but WITHOUT ANY WARRANTY; without even the implied warranty of
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 // Lesser General Public License for more details.
19 //
20 // You should have received a copy of the GNU Lesser General Public
21 // License along with this library; if not, write to the Free Software
22 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23
24 #ifdef HAVE_CONFIG_H
25 # include "config.h"
26 #endif
27
28 // ---------------------------------------------------------------------------
29 // SYSTEM INCLUDES
30 // ---------------------------------------------------------------------------
31
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <unistd.h>
36 #include <math.h>
37 #include <ctype.h>
38 #include <time.h>
39
40 // ---------------------------------------------------------------------------
41 // HAMLIB INCLUDES
42 // ---------------------------------------------------------------------------
43
44 #include <hamlib/rig.h>
45 #include "token.h"
46 #include "serial.h"
47 #include "misc.h"
48 #include "register.h"
49 #include "num_stdio.h"
50
51 // ---------------------------------------------------------------------------
52 // ADAT INCLUDES
53 // ---------------------------------------------------------------------------
54
55 #include "adat.h"
56
57 // ---------------------------------------------------------------------------
58 // GLOBAL DEFINITIONS
59 // ---------------------------------------------------------------------------
60
61 #if !defined(NDEDBUG)
62 # define ADAT_DEBUG 1
63 #endif
64
65 #undef ADAT_DEBUG // manual override ...
66
67 // ---------------------------------------------------------------------------
68 // ADAT GLOBAL VARIABLES
69 // ---------------------------------------------------------------------------
70
71 // DEBUG STUFF
72
73 static int gFnLevel = 0;
74
75 // ADAT MODES
76
77 static adat_mode_list_t the_adat_mode_list =
78 {
79 ADAT_NR_MODES,
80
81 {
82 {
83 ADAT_MODE_STR_CW_R,
84 ADAT_MODE_RNR_CW_R,
85 ADAT_MODE_ANR_CW_R
86 },
87
88 {
89 ADAT_MODE_STR_CW,
90 ADAT_MODE_RNR_CW,
91 ADAT_MODE_ANR_CW
92 },
93
94 {
95 ADAT_MODE_STR_LSB,
96 ADAT_MODE_RNR_LSB,
97 ADAT_MODE_ANR_LSB
98 },
99
100 {
101 ADAT_MODE_STR_USB,
102 ADAT_MODE_RNR_USB,
103 ADAT_MODE_ANR_USB
104 },
105
106 {
107 ADAT_MODE_STR_AM,
108 ADAT_MODE_RNR_AM,
109 ADAT_MODE_ANR_AM
110 },
111
112 {
113 ADAT_MODE_STR_AM_SL,
114 ADAT_MODE_RNR_AM_SL,
115 ADAT_MODE_ANR_AM_SL
116 },
117
118 {
119 ADAT_MODE_STR_AM_SU,
120 ADAT_MODE_RNR_AM_SU,
121 ADAT_MODE_ANR_AM_SU
122 },
123
124 {
125 ADAT_MODE_STR_FM,
126 ADAT_MODE_RNR_FM,
127 ADAT_MODE_ANR_FM
128 }
129 }
130 };
131
132 // ADAT VFOS
133
134 static adat_vfo_list_t the_adat_vfo_list =
135 {
136 ADAT_NR_VFOS,
137
138 {
139 {
140 ADAT_VFO_STR_A,
141 ADAT_VFO_RNR_A,
142 ADAT_VFO_ANR_A
143 },
144
145 {
146 ADAT_VFO_STR_B,
147 ADAT_VFO_RNR_B,
148 ADAT_VFO_ANR_B
149 },
150
151 {
152 ADAT_VFO_STR_C,
153 ADAT_VFO_RNR_C,
154 ADAT_VFO_ANR_C
155 }
156 }
157 };
158
159 // ---------------------------------------------------------------------------
160 // Individual ADAT CAT commands
161 // ---------------------------------------------------------------------------
162
163 // -- NIL -- (Marks the end of a cmd list)
164 #if 0
165 static adat_cmd_def_t adat_cmd_nil =
166 {
167 ADAT_CMD_DEF_NIL,
168 ADAT_CMD_KIND_WITHOUT_RESULT,
169 NULL,
170
171 0,
172 {
173 NULL
174 }
175 };
176 #endif
177 // -- ADAT SPECIAL: DISPLAY OFF --
178
179 static adat_cmd_def_t adat_cmd_display_off =
180 {
181 ADAT_CMD_DEF_ADAT_SPECIAL,
182 ADAT_CMD_KIND_WITHOUT_RESULT,
183 NULL,
184
185 1,
186 {
187 ADAT_CMD_DEF_STRING_DISPLAY_OFF
188 }
189 };
190
191 // -- ADAT SPECIAL: DISPLAY ON --
192
193 static adat_cmd_def_t adat_cmd_display_on =
194 {
195 ADAT_CMD_DEF_ADAT_SPECIAL,
196 ADAT_CMD_KIND_WITHOUT_RESULT,
197 NULL,
198
199 1,
200 {
201 ADAT_CMD_DEF_STRING_DISPLAY_ON
202 }
203 };
204
205 // -- ADAT SPECIAL: SELECT VFO --
206
207 // -- ADAT SPECIAL: GET SERIAL NR --
208
209 static adat_cmd_def_t adat_cmd_get_serial_nr =
210 {
211 ADAT_CMD_DEF_ADAT_SPECIAL,
212 ADAT_CMD_KIND_WITH_RESULT,
213 adat_cmd_fn_get_serial_nr,
214
215 1,
216 {
217 ADAT_CMD_DEF_STRING_GET_SERIAL_NR
218 }
219 };
220
221 // -- ADAT SPECIAL: GET FIRMWARE VERSION --
222
223 static adat_cmd_def_t adat_cmd_get_fw_version =
224 {
225 ADAT_CMD_DEF_ADAT_SPECIAL,
226 ADAT_CMD_KIND_WITH_RESULT,
227 adat_cmd_fn_get_fw_version,
228
229 1,
230 {
231 ADAT_CMD_DEF_STRING_GET_FW_VERSION
232 }
233 };
234
235
236 // -- ADAT SPECIAL: GET HARDWARE VERSION --
237
238 static adat_cmd_def_t adat_cmd_get_hw_version =
239 {
240 ADAT_CMD_DEF_ADAT_SPECIAL,
241 ADAT_CMD_KIND_WITH_RESULT,
242 adat_cmd_fn_get_hw_version,
243
244 1,
245 {
246 ADAT_CMD_DEF_STRING_GET_HW_VERSION
247 }
248 };
249
250 // -- ADAT SPECIAL: GET FIRMWARE VERSION --
251
252 static adat_cmd_def_t adat_cmd_get_id_code =
253 {
254 ADAT_CMD_DEF_ADAT_SPECIAL,
255 ADAT_CMD_KIND_WITH_RESULT,
256 adat_cmd_fn_get_id_code,
257
258 1,
259 {
260 ADAT_CMD_DEF_STRING_GET_ID_CODE
261 }
262 };
263
264 // -- ADAT SPECIAL: GET GUI FIRMWARE VERSION --
265
266 static adat_cmd_def_t adat_cmd_get_gui_fw_version =
267 {
268 ADAT_CMD_DEF_ADAT_SPECIAL,
269 ADAT_CMD_KIND_WITH_RESULT,
270 adat_cmd_fn_get_gui_fw_version,
271
272 1,
273 {
274 ADAT_CMD_DEF_STRING_GET_GUI_FW_VERSION
275 }
276 };
277
278 // -- ADAT SPECIAL: GET OPTIONS --
279
280 static adat_cmd_def_t adat_cmd_get_options =
281 {
282 ADAT_CMD_DEF_ADAT_SPECIAL,
283 ADAT_CMD_KIND_WITH_RESULT,
284 adat_cmd_fn_get_options,
285
286 1,
287 {
288 ADAT_CMD_DEF_STRING_GET_OPTIONS
289 }
290 };
291
292 // -- ADAT SPECIAL: GET CALLSIGN --
293
294 static adat_cmd_def_t adat_cmd_get_callsign =
295 {
296 ADAT_CMD_DEF_ADAT_SPECIAL,
297 ADAT_CMD_KIND_WITH_RESULT,
298 adat_cmd_fn_get_callsign,
299
300 1,
301 {
302 ADAT_CMD_DEF_STRING_GET_CALLSIGN
303 }
304 };
305
306 // -- ADAT SPECIAL: SET CALLSIGN --
307
308 static adat_cmd_def_t adat_cmd_set_callsign =
309 {
310 ADAT_CMD_DEF_ADAT_SPECIAL,
311 ADAT_CMD_KIND_WITHOUT_RESULT,
312 adat_cmd_fn_set_callsign,
313
314 1,
315 {
316 ADAT_CMD_DEF_STRING_SET_CALLSIGN
317 }
318 };
319
320 // -- HAMLIB DEFINED COMMANDS --
321
322 // -- GET FREQ --
323
324 static adat_cmd_def_t adat_cmd_get_freq =
325 {
326 ADAT_CMD_DEF_GET_FREQ,
327 ADAT_CMD_KIND_WITH_RESULT,
328
329 adat_cmd_fn_get_freq,
330
331 1,
332 {
333 ADAT_CMD_DEF_STRING_GET_FREQ
334 }
335 };
336
337 static adat_cmd_list_t adat_cmd_list_get_freq =
338 {
339 2,
340 {
341 &adat_cmd_display_off,
342 &adat_cmd_get_freq
343 }
344 };
345
346 // -- SET FREQ --
347
348 static adat_cmd_def_t adat_cmd_set_freq =
349 {
350 ADAT_CMD_DEF_SET_FREQ,
351 ADAT_CMD_KIND_WITHOUT_RESULT,
352
353 adat_cmd_fn_set_freq,
354
355 1,
356 {
357 ADAT_CMD_DEF_STRING_SET_FREQ
358 }
359 };
360
361 static adat_cmd_list_t adat_cmd_list_set_freq =
362 {
363 3,
364 {
365 &adat_cmd_display_off,
366 &adat_cmd_set_freq,
367 &adat_cmd_get_freq,
368 }
369 };
370 // -- GET VFO --
371
372 static adat_cmd_list_t adat_cmd_list_get_vfo =
373 {
374 2,
375 {
376 &adat_cmd_display_off,
377 &adat_cmd_get_freq,
378 }
379 };
380
381 // -- GET MODE --
382
383 static adat_cmd_def_t adat_cmd_get_mode =
384 {
385 ADAT_CMD_DEF_GET_MODE,
386 ADAT_CMD_KIND_WITH_RESULT,
387
388 adat_cmd_fn_get_mode,
389
390 1,
391 {
392 ADAT_CMD_DEF_STRING_GET_MODE
393 }
394 };
395
396 static adat_cmd_list_t adat_cmd_list_get_mode =
397 {
398 2,
399 {
400 &adat_cmd_display_off,
401 &adat_cmd_get_mode
402 }
403 };
404
405 // -- SET VFO --
406
407 static adat_cmd_def_t adat_cmd_set_vfo =
408 {
409 ADAT_CMD_DEF_SET_VFO,
410 ADAT_CMD_KIND_WITHOUT_RESULT,
411
412 adat_cmd_fn_set_vfo,
413
414 2,
415 {
416 ADAT_CMD_DEF_STRING_SWITCH_ON_VFO,
417 ADAT_CMD_DEF_STRING_SET_VFO_AS_MAIN_VFO
418 }
419 };
420
421 static adat_cmd_list_t adat_cmd_list_set_vfo =
422 {
423 2,
424 {
425 &adat_cmd_display_off,
426 &adat_cmd_set_vfo
427 }
428 };
429
430
431 // -- SET MODE --
432
433 static adat_cmd_def_t adat_cmd_set_mode =
434 {
435 ADAT_CMD_DEF_SET_MODE,
436 ADAT_CMD_KIND_WITHOUT_RESULT,
437
438 adat_cmd_fn_set_mode,
439
440 1,
441 {
442 ADAT_CMD_DEF_STRING_SET_MODE
443 }
444 };
445
446 static adat_cmd_list_t adat_cmd_list_set_mode =
447 {
448 3,
449 {
450 &adat_cmd_display_off,
451 &adat_cmd_set_vfo,
452 &adat_cmd_set_mode,
453 }
454 };
455
456 // -- SET PTT --
457
458 static adat_cmd_def_t adat_cmd_set_ptt =
459 {
460 ADAT_CMD_DEF_SET_PTT,
461 ADAT_CMD_KIND_WITHOUT_RESULT,
462
463 adat_cmd_fn_set_ptt,
464
465 1,
466 {
467 ADAT_CMD_DEF_STRING_SET_PTT
468 }
469 };
470
471 static adat_cmd_list_t adat_cmd_list_set_ptt =
472 {
473 2,
474 {
475 &adat_cmd_set_ptt,
476 &adat_cmd_display_off
477 }
478 };
479
480 // -- GET PTT --
481
482 static adat_cmd_def_t adat_cmd_get_ptt =
483 {
484 ADAT_CMD_DEF_GET_PTT,
485 ADAT_CMD_KIND_WITH_RESULT,
486
487 adat_cmd_fn_get_ptt,
488
489 1,
490 {
491 ADAT_CMD_DEF_STRING_GET_PTT
492 }
493 };
494
495 static adat_cmd_list_t adat_cmd_list_get_ptt =
496 {
497 2,
498 {
499 &adat_cmd_display_off,
500 &adat_cmd_get_ptt
501 }
502 };
503
504 // -- GET POWER STATUS --
505
506 static adat_cmd_list_t adat_cmd_list_get_powerstatus =
507 {
508 1,
509 {
510 &adat_cmd_get_id_code
511 }
512 };
513
514 // -- GET INFO --
515
516 static adat_cmd_list_t adat_cmd_list_get_info =
517 {
518 7,
519 {
520 &adat_cmd_get_serial_nr,
521 &adat_cmd_get_id_code,
522 &adat_cmd_get_fw_version,
523 &adat_cmd_get_gui_fw_version,
524 &adat_cmd_get_hw_version,
525 &adat_cmd_get_options,
526 &adat_cmd_get_callsign
527 }
528 };
529
530 // -- OPEN ADAT --
531
532 static adat_cmd_list_t adat_cmd_list_open_adat =
533 {
534 8,
535 {
536 &adat_cmd_display_off,
537 &adat_cmd_get_serial_nr,
538 &adat_cmd_get_id_code,
539 &adat_cmd_get_fw_version,
540 &adat_cmd_get_gui_fw_version,
541 &adat_cmd_get_hw_version,
542 &adat_cmd_get_options,
543 &adat_cmd_set_callsign
544 }
545 };
546
547 // -- CLOSE ADAT --
548
549 static adat_cmd_list_t adat_cmd_list_close_adat =
550 {
551 1,
552 {
553 &adat_cmd_display_on
554 }
555 };
556
557
558 // -- ADAT SPECIAL: RECOVER FROM ERROR --
559
560 static adat_cmd_list_t adat_cmd_list_recover_from_error =
561 {
562 1,
563 {
564 &adat_cmd_display_on
565 }
566 };
567
568
569 // ---------------------------------------------------------------------------
570 // IMPLEMENTATION
571 // ---------------------------------------------------------------------------
572
573 // ---------------------------------------------------------------------------
574 // trimwhitespace - taken from Stackoverflow
575 // http://stackoverflow.com/questions/122616/how-do-i-trim-leading-trailing-whitespace-in-a-standard-way
576 // ---------------------------------------------------------------------------
577 // Status: RELEASED
trimwhitespace(char * out,size_t len,const char * str)578 size_t trimwhitespace(char *out, size_t len, const char *str)
579 {
580 char *end = NULL;
581 size_t out_size = 0;
582
583 gFnLevel++;
584
585 rig_debug(RIG_DEBUG_TRACE,
586 "*** ADAT: %d %s (%s:%d): ENTRY. In -> '%s', %d\n",
587 gFnLevel, __func__, __FILE__, __LINE__, str, (int)len);
588
589 if (len == 0)
590 {
591 gFnLevel--;
592 return 0;
593 }
594
595 // Trim leading space
596 while (isspace((int)*str))
597 {
598 str++;
599 }
600
601 if (*str == 0) // All spaces?
602 {
603 out = NULL;
604 gFnLevel--;
605 return 1;
606 }
607
608 // Trim trailing space
609 end = (char *)(str + strlen(str) - 1);
610
611 while (end > str && isspace((int)*end))
612 {
613 *end = '\0';
614 end--;
615 }
616
617 // Set output size to minimum of trimmed string length and buffer size minus 1
618 //out_size = (end - str) < len-1 ? (end - str) : len - 1;
619 out_size = strlen(str);
620
621 // Copy trimmed string and add null terminator
622 memcpy(out, str, out_size);
623 out[out_size] = 0;
624
625 rig_debug(RIG_DEBUG_TRACE,
626 "*** ADAT: %d %s (%s:%d): EXIT. Out -> \"%s\", %d\n",
627 gFnLevel, __func__, __FILE__, __LINE__, out, (int)out_size);
628 gFnLevel--;
629
630 return out_size;
631 }
632
633
634 // ---------------------------------------------------------------------------
635 // adat_print_cmd
636 // ---------------------------------------------------------------------------
637 // Status: RELEASED
adat_print_cmd(adat_cmd_def_ptr pCmd)638 int adat_print_cmd(adat_cmd_def_ptr pCmd)
639 {
640 int nRC = RIG_OK;
641
642 int nI = 0;
643
644 rig_debug(RIG_DEBUG_TRACE,
645 "*** ADAT: %s (%s:%d): ENTRY.\n",
646 __func__, __FILE__, __LINE__);
647
648 rig_debug(RIG_DEBUG_TRACE,
649 "*** -> Command ID = %u\n", (unsigned int)(pCmd->nCmdId));
650
651 rig_debug(RIG_DEBUG_TRACE,
652 "*** -> Command kind = %d\n",
653 pCmd->nCmdKind);
654
655 while (nI < pCmd->nNrCmdStrs)
656 {
657 rig_debug(RIG_DEBUG_TRACE,
658 "*** -> Command String %d = \"%s\"\n",
659 nI, pCmd->pacCmdStrs[ nI ]);
660 nI++;
661 }
662
663 rig_debug(RIG_DEBUG_TRACE,
664 "*** ADAT: %s (%s:%d): EXIT. Return Code = %d\n",
665 __func__, __FILE__, __LINE__, nRC);
666
667 return nRC;
668 }
669
670
671 // ---------------------------------------------------------------------------
672 // adat_parse_freq
673 // ---------------------------------------------------------------------------
674 // Status: RELEASED
675
676 // Can be used to parse strings with VFO nr and without VFO nr in it:
677 // "1 123.456kHz" => nMode = ADAT_FREQ_PARSE_MODE_WITH_VFO
678 // "800Hz" => nMode = ADAT_FREQ_PARSE_MODE_WITHOUT_VFO
adat_parse_freq(char * pcStr,adat_freq_parse_mode_t nMode,int * nVFO,freq_t * nFreq)679 int adat_parse_freq(char *pcStr,
680 adat_freq_parse_mode_t nMode,
681 int *nVFO,
682 freq_t *nFreq)
683 {
684 int nRC = RIG_OK;
685
686 gFnLevel++;
687 rig_debug(RIG_DEBUG_TRACE,
688 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pcStr = \"%s\"\n",
689 gFnLevel, __func__, __FILE__, __LINE__, pcStr);
690
691 if (pcStr != NULL)
692 {
693 int _nVFO = 0;
694
695 char *pcEnd = NULL;
696
697 if (nMode == ADAT_FREQ_PARSE_MODE_WITH_VFO)
698 {
699 // Get VFO from response string
700
701 _nVFO = strtol(pcStr, &pcEnd, 10);
702
703 // Save VFO
704
705 *nVFO = _nVFO;
706 }
707 else
708 {
709 pcEnd = pcStr;
710 }
711
712 if ((_nVFO != 0) // VFO = 0 -> Current VFO not active.
713 || (nMode == ADAT_FREQ_PARSE_MODE_WITHOUT_VFO))
714 {
715 char acValueBuf[ ADAT_BUFSZ + 1 ];
716 char acUnitBuf[ ADAT_BUFSZ + 1 ];
717 int nI = 0;
718 double dTmpFreq = 0.0;
719 freq_t _nFreq;
720
721 memset(acValueBuf, 0, ADAT_BUFSZ + 1);
722 memset(acUnitBuf, 0, ADAT_BUFSZ + 1);
723
724 // Get Freq Value from response string
725
726 while ((isalpha((int)*pcEnd) == 0)
727 || (*pcEnd == '.'))
728 {
729 acValueBuf[ nI++ ] = *pcEnd;
730 pcEnd += sizeof(char);
731 }
732
733 dTmpFreq = strtod(acValueBuf, (char **) NULL);
734
735 rig_debug(RIG_DEBUG_TRACE,
736 "*** ADAT: %d acValueBuf = \"%s\", dTmpFreq = %f, *pcEnd = %c\n",
737 gFnLevel, acValueBuf, dTmpFreq, *pcEnd);
738
739 // Get Freq Unit from response string
740
741 nI = 0;
742
743 while (isalpha((int)*pcEnd) != 0)
744 {
745 acUnitBuf[ nI++ ] = *pcEnd;
746 pcEnd += sizeof(char);
747 }
748
749 rig_debug(RIG_DEBUG_TRACE,
750 "*** ADAT: %d acUnitBuf = \"%s\"\n",
751 gFnLevel, acUnitBuf);
752
753 // Normalize to Hz
754
755 if (!strncmp(acUnitBuf,
756 ADAT_FREQ_UNIT_HZ,
757 ADAT_FREQ_UNIT_HZ_LEN))
758 {
759 _nFreq = Hz(dTmpFreq);
760 }
761 else
762 {
763 if (!strncmp(acUnitBuf,
764 ADAT_FREQ_UNIT_KHZ,
765 ADAT_FREQ_UNIT_KHZ_LEN))
766 {
767 _nFreq = kHz(dTmpFreq);
768 }
769 else
770 {
771 if (!strncmp(acUnitBuf,
772 ADAT_FREQ_UNIT_MHZ,
773 ADAT_FREQ_UNIT_MHZ_LEN))
774 {
775 _nFreq = MHz(dTmpFreq);
776 }
777 else
778 {
779 if (!strncmp(acUnitBuf,
780 ADAT_FREQ_UNIT_GHZ,
781 ADAT_FREQ_UNIT_GHZ_LEN))
782 {
783 _nFreq = GHz(dTmpFreq);
784 }
785 else
786 {
787 _nFreq = 0;
788 nRC = -RIG_EINVAL;
789 }
790 }
791 }
792
793 }
794
795 // Save Freq
796
797 *nFreq = _nFreq;
798 }
799 }
800 else
801 {
802 // If input string is NULL set Freq and VFO also to NULL
803
804 *nFreq = 0;
805 *nVFO = 0;
806 }
807
808 // Done
809
810 rig_debug(RIG_DEBUG_TRACE,
811 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d, nVFO = %d, nFreq = %f\n",
812 gFnLevel, __func__, __FILE__, __LINE__, nRC, *nVFO, *nFreq);
813 gFnLevel--;
814
815 return nRC;
816 }
817
818
819 // ---------------------------------------------------------------------------
820 // adat_parse_mode
821 // ---------------------------------------------------------------------------
822 // Status: RELEASED
adat_parse_mode(char * pcStr,rmode_t * nRIGMode,char * pcADATMode)823 int adat_parse_mode(char *pcStr,
824 rmode_t *nRIGMode,
825 char *pcADATMode)
826 {
827 int nRC = RIG_OK;
828
829 gFnLevel++;
830
831 rig_debug(RIG_DEBUG_TRACE,
832 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pcStr = \"%s\"\n",
833 gFnLevel, __func__, __FILE__, __LINE__, pcStr);
834
835 if (pcStr != NULL)
836 {
837 int nI = 0;
838 int nFini = 0;
839
840 while ((nI < the_adat_mode_list.nNrModes) && (nFini == 0))
841 {
842 if (!strcmp(pcStr,
843 the_adat_mode_list.adat_modes[ nI ].pcADATModeStr))
844 {
845 *nRIGMode = the_adat_mode_list.adat_modes[ nI ].nRIGMode;
846 nFini = 1; // Done.
847 }
848 else
849 {
850 nI++;
851 }
852 }
853 }
854 else
855 {
856 // If input string is NULL ...
857
858 *nRIGMode = RIG_MODE_NONE;
859 *pcADATMode = 0;
860 }
861
862 // Done
863
864 rig_debug(RIG_DEBUG_TRACE,
865 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d, Mode = %d\n",
866 gFnLevel, __func__, __FILE__, __LINE__, nRC, (int)*nRIGMode);
867 gFnLevel--;
868
869 return nRC;
870 }
871
872
873 // ---------------------------------------------------------------------------
874 // adat_mode_rnr2anr
875 // ---------------------------------------------------------------------------
876 // Status: RELEASED
adat_mode_rnr2anr(rmode_t nRIGMode,int * nADATMode)877 int adat_mode_rnr2anr(rmode_t nRIGMode,
878 int *nADATMode)
879 {
880 int nRC = RIG_OK;
881 int nI = 0;
882 int nFini = 0;
883
884 gFnLevel++;
885
886 rig_debug(RIG_DEBUG_TRACE,
887 "*** ADAT: %d %s (%s:%d): ENTRY. Params: nRIGMode = %u\n",
888 gFnLevel, __func__, __FILE__, __LINE__, (unsigned int)nRIGMode);
889
890 while ((nI < the_adat_mode_list.nNrModes) && (nFini == 0))
891 {
892 if (the_adat_mode_list.adat_modes[ nI ].nRIGMode == nRIGMode)
893 {
894 *nADATMode = the_adat_mode_list.adat_modes[ nI ].nADATMode;
895 nFini = 1; // Done.
896 }
897 else
898 {
899 nI++;
900 }
901 }
902
903 if (nFini == 0)
904 {
905 // No valid Mode given
906
907 nRC = -RIG_EINVAL;
908 }
909
910 // Done
911
912 rig_debug(RIG_DEBUG_TRACE,
913 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d, ADAT Mode = %d\n",
914 gFnLevel, __func__, __FILE__, __LINE__, nRC, *nADATMode);
915 gFnLevel--;
916
917 return nRC;
918 }
919
920
921 // ---------------------------------------------------------------------------
922 // adat_mode_anr2rnr
923 // ---------------------------------------------------------------------------
924 // Status: RELEASED
adat_mode_anr2rnr(int nADATMode,rmode_t * nRIGMode)925 int adat_mode_anr2rnr(int nADATMode,
926 rmode_t *nRIGMode)
927 {
928 int nRC = RIG_OK;
929 int nI = 0;
930 int nFini = 0;
931
932 gFnLevel++;
933
934 rig_debug(RIG_DEBUG_TRACE,
935 "*** ADAT: %d %s (%s:%d): ENTRY. Params: nRIGMode = %u\n",
936 gFnLevel, __func__, __FILE__, __LINE__, (unsigned int)*nRIGMode);
937
938 while ((nI < the_adat_mode_list.nNrModes) && (nFini == 0))
939 {
940 if (the_adat_mode_list.adat_modes[ nI ].nADATMode == nADATMode)
941 {
942 *nRIGMode = the_adat_mode_list.adat_modes[ nI ].nRIGMode;
943 nFini = 1; // Done.
944 }
945 else
946 {
947 nI++;
948 }
949 }
950
951 if (nFini == 0)
952 {
953 // No valid Mode given
954
955 nRC = -RIG_EINVAL;
956 }
957
958 // Done
959
960 rig_debug(RIG_DEBUG_TRACE,
961 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d, RIG Mode = %u\n",
962 gFnLevel, __func__, __FILE__, __LINE__, nRC, (unsigned int)*nRIGMode);
963 gFnLevel--;
964
965 return nRC;
966 }
967
968
969 #ifdef XXREMOVEDXX
970 // this function wasn't referenced anywhere
971 // ---------------------------------------------------------------------------
972 // adat_parse_vfo
973 // ---------------------------------------------------------------------------
974 // Status: RELEASED
adat_parse_vfo(char * pcStr,vfo_t * nRIGVFONr,int * nADATVFONr)975 int adat_parse_vfo(char *pcStr,
976 vfo_t *nRIGVFONr,
977 int *nADATVFONr)
978 {
979 int nRC = RIG_OK;
980
981 gFnLevel++;
982
983 rig_debug(RIG_DEBUG_TRACE,
984 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pcStr = \"%s\"\n",
985 gFnLevel, __func__, __FILE__, __LINE__, pcStr);
986
987 if (pcStr != NULL)
988 {
989 int nI = 0;
990 int nFini = 0;
991
992 while ((nI < the_adat_vfo_list.nNrVFOs) && (nFini == 0))
993 {
994 if (!strcmp(pcStr,
995 the_adat_vfo_list.adat_vfos[ nI ].pcADATVFOStr))
996 {
997 *nRIGVFONr = the_adat_vfo_list.adat_vfos[ nI ].nRIGVFONr;
998 *nADATVFONr = the_adat_vfo_list.adat_vfos[ nI ].nADATVFONr;
999 nFini = 1; // Done.
1000 }
1001 else
1002 {
1003 nI++;
1004 }
1005 }
1006
1007 if (nFini == 0)
1008 {
1009 nRC = -RIG_EINVAL;
1010 }
1011 }
1012 else
1013 {
1014 // If input string is NULL ...
1015
1016 *nRIGVFONr = RIG_VFO_NONE;
1017 *nADATVFONr = 0;
1018 }
1019
1020 // Done
1021
1022 rig_debug(RIG_DEBUG_TRACE,
1023 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d, RIG VFO Nr = %d\n",
1024 gFnLevel, __func__, __FILE__, __LINE__, nRC, *nRIGVFONr);
1025 gFnLevel--;
1026
1027 return nRC;
1028 }
1029 #endif
1030
1031
1032 // ---------------------------------------------------------------------------
1033 // adat_vfo_rnr2anr
1034 // ---------------------------------------------------------------------------
1035 // Status: RELEASED
adat_vfo_rnr2anr(vfo_t nRIGVFONr,int * nADATVFONr)1036 int adat_vfo_rnr2anr(vfo_t nRIGVFONr,
1037 int *nADATVFONr)
1038 {
1039 int nRC = RIG_OK;
1040 int nI = 0;
1041 int nFini = 0;
1042
1043 gFnLevel++;
1044
1045 rig_debug(RIG_DEBUG_TRACE,
1046 "*** ADAT: %d %s (%s:%d): ENTRY. Params: nRIGVFONr = %u\n",
1047 gFnLevel, __func__, __FILE__, __LINE__, nRIGVFONr);
1048
1049 while ((nI < the_adat_vfo_list.nNrVFOs) && (nFini == 0))
1050 {
1051 if (the_adat_vfo_list.adat_vfos[ nI ].nRIGVFONr == nRIGVFONr)
1052 {
1053 *nADATVFONr = the_adat_vfo_list.adat_vfos[ nI ].nADATVFONr;
1054 nFini = 1; // Done.
1055 }
1056 else
1057 {
1058 nI++;
1059 }
1060 }
1061
1062 if (nFini == 0)
1063 {
1064 // No valid Mode given
1065
1066 nRC = -RIG_EINVAL;
1067 }
1068
1069 // Done
1070
1071 rig_debug(RIG_DEBUG_TRACE,
1072 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d, ADAT VFO Nr = %d\n",
1073 gFnLevel, __func__, __FILE__, __LINE__, nRC, *nADATVFONr);
1074 gFnLevel--;
1075
1076 return nRC;
1077 }
1078
1079
1080 // ---------------------------------------------------------------------------
1081 // adat_vfo_anr2rnr
1082 // ---------------------------------------------------------------------------
1083 // Status: RELEASED
adat_vfo_anr2rnr(int nADATVFONr,vfo_t * nRIGVFONr)1084 int adat_vfo_anr2rnr(int nADATVFONr,
1085 vfo_t *nRIGVFONr)
1086 {
1087 int nRC = RIG_OK;
1088 int nI = 0;
1089 int nFini = 0;
1090
1091 gFnLevel++;
1092
1093 rig_debug(RIG_DEBUG_TRACE,
1094 "*** ADAT: %d %s (%s:%d): ENTRY. Params: nADATVFONr = %d\n",
1095 gFnLevel, __func__, __FILE__, __LINE__, nADATVFONr);
1096
1097 while ((nI < the_adat_vfo_list.nNrVFOs) && (nFini == 0))
1098 {
1099 if (the_adat_vfo_list.adat_vfos[ nI ].nADATVFONr == nADATVFONr)
1100 {
1101 *nRIGVFONr = the_adat_vfo_list.adat_vfos[ nI ].nRIGVFONr;
1102 nFini = 1; // Done.
1103 }
1104 else
1105 {
1106 nI++;
1107 }
1108 }
1109
1110 if (nFini == 0)
1111 {
1112 // No valid ADAT VFO Nr given
1113
1114 nRC = -RIG_EINVAL;
1115 }
1116
1117 // Done
1118
1119 rig_debug(RIG_DEBUG_TRACE,
1120 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d, RIG VFO Nr = %u\n",
1121 gFnLevel, __func__, __FILE__, __LINE__, nRC, *nRIGVFONr);
1122 gFnLevel--;
1123
1124 return nRC;
1125 }
1126
1127
1128 // ---------------------------------------------------------------------------
1129 // adat_parse_ptt
1130 // ---------------------------------------------------------------------------
1131 // Status: RELEASED
adat_parse_ptt(char * pcStr,int * nADATPTTStatus)1132 int adat_parse_ptt(char *pcStr,
1133 int *nADATPTTStatus)
1134 {
1135 int nRC = RIG_OK;
1136
1137 gFnLevel++;
1138
1139 rig_debug(RIG_DEBUG_TRACE,
1140 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pcStr = \"%s\"\n",
1141 gFnLevel, __func__, __FILE__, __LINE__, pcStr);
1142
1143 if ((pcStr != NULL) && (strlen(pcStr) > 0))
1144 {
1145 *nADATPTTStatus = strtol(pcStr, NULL, 10);
1146 }
1147 else
1148 {
1149 // If input string is NULL ...
1150
1151 *nADATPTTStatus = ADAT_PTT_STATUS_ANR_OFF;
1152 nRC = -RIG_EINVAL;
1153 }
1154
1155 // Done
1156
1157 rig_debug(RIG_DEBUG_TRACE,
1158 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
1159 gFnLevel, __func__, __FILE__, __LINE__, nRC);
1160 gFnLevel--;
1161
1162 return nRC;
1163 }
1164
1165
1166 #ifdef XXREMOVEDXX
1167 // this function wasn't referenced anywhere
1168 // ---------------------------------------------------------------------------
1169 // adat_ptt_rnr2anr
1170 // ---------------------------------------------------------------------------
1171 // Status: RELEASED
adat_ptt_rnr2anr(ptt_t nRIGPTTStatus,int * nADATPTTStatus)1172 int adat_ptt_rnr2anr(ptt_t nRIGPTTStatus,
1173 int *nADATPTTStatus)
1174 {
1175 int nRC = RIG_OK;
1176
1177 gFnLevel++;
1178
1179 rig_debug(RIG_DEBUG_TRACE,
1180 "*** ADAT: %d %s (%s:%d): ENTRY. Params: nRIGPTTStatus = %d\n",
1181 gFnLevel, __func__, __FILE__, __LINE__, nRIGPTTStatus);
1182
1183 switch (nRIGPTTStatus)
1184 {
1185 case ADAT_PTT_STATUS_RNR_ON:
1186 *nADATPTTStatus = ADAT_PTT_STATUS_ANR_ON;
1187 break;
1188
1189 case ADAT_PTT_STATUS_RNR_OFF:
1190 *nADATPTTStatus = ADAT_PTT_STATUS_ANR_OFF;
1191 break;
1192
1193 default:
1194 nRC = -RIG_EINVAL;
1195 break;
1196 }
1197
1198 // Done
1199
1200 rig_debug(RIG_DEBUG_TRACE,
1201 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d, ADAT PTT Status = %d\n",
1202 gFnLevel, __func__, __FILE__, __LINE__, nRC, *nADATPTTStatus);
1203 gFnLevel--;
1204
1205 return nRC;
1206 }
1207 #endif
1208
1209
1210 // ---------------------------------------------------------------------------
1211 // adat_ptt_anr2rnr
1212 // ---------------------------------------------------------------------------
1213 // Status: RELEASED
adat_ptt_anr2rnr(int nADATPTTStatus,ptt_t * nRIGPTTStatus)1214 int adat_ptt_anr2rnr(int nADATPTTStatus,
1215 ptt_t *nRIGPTTStatus)
1216 {
1217 int nRC = RIG_OK;
1218
1219 gFnLevel++;
1220
1221 rig_debug(RIG_DEBUG_TRACE,
1222 "*** ADAT: %d %s (%s:%d): ENTRY. Params: nADATPTTStatus = %d\n",
1223 gFnLevel, __func__, __FILE__, __LINE__, nADATPTTStatus);
1224
1225 switch (nADATPTTStatus)
1226 {
1227 case ADAT_PTT_STATUS_ANR_ON:
1228 *nRIGPTTStatus = ADAT_PTT_STATUS_RNR_ON;
1229 break;
1230
1231 case ADAT_PTT_STATUS_ANR_OFF:
1232 *nRIGPTTStatus = ADAT_PTT_STATUS_RNR_OFF;
1233 break;
1234
1235 default:
1236 nRC = -RIG_EINVAL;
1237 break;
1238 }
1239
1240 // Done
1241
1242 rig_debug(RIG_DEBUG_TRACE,
1243 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d, RIG PTT Status = %d\n",
1244 gFnLevel, __func__, __FILE__, __LINE__, nRC, *nRIGPTTStatus);
1245 gFnLevel--;
1246
1247 return nRC;
1248 }
1249
1250
1251 // ---------------------------------------------------------------------------
1252 // adat_send
1253 // ---------------------------------------------------------------------------
1254 // Status: RELEASED
adat_send(RIG * pRig,char * pcData)1255 int adat_send(RIG *pRig,
1256 char *pcData)
1257 {
1258 int nRC = RIG_OK;
1259 struct rig_state *pRigState = &pRig->state;
1260
1261 gFnLevel++;
1262
1263 rig_debug(RIG_DEBUG_TRACE,
1264 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p, pcData = %s\n",
1265 gFnLevel, __func__, __FILE__, __LINE__, pRig, pcData);
1266
1267 rig_flush(&pRigState->rigport);
1268
1269 nRC = write_block(&pRigState->rigport, pcData, strlen(pcData));
1270
1271 rig_debug(RIG_DEBUG_TRACE,
1272 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
1273 gFnLevel, __func__, __FILE__, __LINE__, nRC);
1274
1275 gFnLevel--;
1276
1277 return nRC;
1278 }
1279
1280
1281 // ---------------------------------------------------------------------------
1282 // adat_receive
1283 // ---------------------------------------------------------------------------
1284 // Status: RELEASED
adat_receive(RIG * pRig,char * pcData)1285 int adat_receive(RIG *pRig,
1286 char *pcData)
1287 {
1288 int nRC = RIG_OK;
1289 struct rig_state *pRigState = &pRig->state;
1290
1291 gFnLevel++;
1292
1293 rig_debug(RIG_DEBUG_TRACE,
1294 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
1295 gFnLevel, __func__, __FILE__, __LINE__, pRig);
1296
1297 nRC = read_string(&pRigState->rigport, pcData, ADAT_RESPSZ, ADAT_EOL, 1);
1298
1299 if (nRC > 0)
1300 {
1301 nRC = RIG_OK;
1302 }
1303
1304 rig_debug(RIG_DEBUG_TRACE,
1305 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
1306 gFnLevel, __func__, __FILE__, __LINE__, nRC);
1307
1308 gFnLevel--;
1309
1310 return nRC;
1311 }
1312
1313
1314 // ---------------------------------------------------------------------------
1315 // adat_priv_set_cmd
1316 // ---------------------------------------------------------------------------
1317 // Status: RELEASED
adat_priv_set_cmd(RIG * pRig,char * pcCmd,int nCmdKind)1318 int adat_priv_set_cmd(RIG *pRig, char *pcCmd, int nCmdKind)
1319 {
1320 int nRC = RIG_OK;
1321
1322 gFnLevel++;
1323
1324 rig_debug(RIG_DEBUG_TRACE,
1325 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p, pcCmd = \"%s\"\n",
1326 gFnLevel, __func__, __FILE__, __LINE__, pRig, pcCmd);
1327
1328 if (pRig == NULL)
1329 {
1330 nRC = -RIG_EARG;
1331 }
1332 else
1333 {
1334 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
1335
1336 if (pPriv->pcCmd != NULL)
1337 {
1338 free(pPriv->pcCmd);
1339 }
1340
1341 pPriv->pcCmd = strdup(pcCmd);
1342 pPriv->nCmdKind = nCmdKind;
1343 }
1344
1345 // Done !
1346
1347 rig_debug(RIG_DEBUG_TRACE,
1348 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
1349 gFnLevel, __func__, __FILE__, __LINE__, nRC);
1350
1351 gFnLevel--;
1352
1353 return nRC;
1354 }
1355
1356
1357 // ---------------------------------------------------------------------------
1358 // adat_priv_set_result
1359 // ---------------------------------------------------------------------------
1360 // Status: RELEASED
adat_priv_set_result(RIG * pRig,char * pcResult)1361 int adat_priv_set_result(RIG *pRig, char *pcResult)
1362 {
1363 int nRC = RIG_OK;
1364
1365 gFnLevel++;
1366
1367 rig_debug(RIG_DEBUG_TRACE,
1368 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p, pcResult = \"%s\"\n",
1369 gFnLevel, __func__, __FILE__, __LINE__, pRig, pcResult);
1370
1371 if (pRig == NULL)
1372 {
1373 nRC = -RIG_EARG;
1374 }
1375 else
1376 {
1377 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
1378
1379 if (pPriv->pcResult != NULL)
1380 {
1381 free(pPriv->pcResult);
1382 }
1383
1384 pPriv->pcResult = strdup(pcResult);
1385
1386 rig_debug(RIG_DEBUG_TRACE,
1387 "*** ADAT: %d pPriv->pcResult = \"%s\"\n",
1388 gFnLevel, pPriv->pcResult);
1389 }
1390
1391 // Done !
1392
1393 rig_debug(RIG_DEBUG_TRACE,
1394 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
1395 gFnLevel, __func__, __FILE__, __LINE__, nRC);
1396
1397 gFnLevel--;
1398
1399 return nRC;
1400 }
1401
1402
1403 // ---------------------------------------------------------------------------
1404 // adat_priv_clear_result
1405 // ---------------------------------------------------------------------------
1406 // Status: RELEASED
adat_priv_clear_result(RIG * pRig)1407 int adat_priv_clear_result(RIG *pRig)
1408 {
1409 int nRC = RIG_OK;
1410
1411 gFnLevel++;
1412
1413 rig_debug(RIG_DEBUG_TRACE,
1414 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
1415 gFnLevel, __func__, __FILE__, __LINE__, pRig);
1416
1417 if (pRig == NULL)
1418 {
1419 nRC = -RIG_EARG;
1420 }
1421 else
1422 {
1423 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
1424
1425 if (pPriv->pcResult != NULL)
1426 {
1427 free(pPriv->pcResult);
1428 }
1429
1430 pPriv->pcResult = NULL;
1431 }
1432
1433 // Done !
1434
1435 rig_debug(RIG_DEBUG_TRACE,
1436 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
1437 gFnLevel, __func__, __FILE__, __LINE__, nRC);
1438
1439 gFnLevel--;
1440
1441 return nRC;
1442 }
1443
1444
1445 // ---------------------------------------------------------------------------
1446 // adat_get_single_cmd_result
1447 // ---------------------------------------------------------------------------
1448 // Status: RELEASED
adat_get_single_cmd_result(RIG * pRig)1449 int adat_get_single_cmd_result(RIG *pRig)
1450 {
1451 int nRC = RIG_OK;
1452
1453 gFnLevel++;
1454
1455 rig_debug(RIG_DEBUG_TRACE,
1456 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
1457 gFnLevel, __func__, __FILE__, __LINE__, pRig);
1458
1459 if (pRig == NULL)
1460 {
1461 nRC = -RIG_EARG;
1462 }
1463 else
1464 {
1465 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
1466 struct rig_state *pRigState = &pRig->state;
1467
1468 nRC = adat_send(pRig, pPriv->pcCmd);
1469
1470 if ((nRC == RIG_OK)
1471 && (pPriv->nCmdKind == ADAT_CMD_KIND_WITH_RESULT))
1472 {
1473
1474 char acBuf[ ADAT_RESPSZ + 1 ];
1475 char acBuf2[ ADAT_RESPSZ + 1 ];
1476 char *pcBufEnd = NULL;
1477 char *pcPos = NULL;
1478 char *pcResult = NULL;
1479
1480 memset(acBuf, 0, ADAT_RESPSZ + 1);
1481 memset(acBuf2, 0, ADAT_RESPSZ + 1);
1482
1483 nRC = adat_receive(pRig, acBuf);
1484
1485 rig_debug(RIG_DEBUG_TRACE,
1486 "*** ADAT: %d acBuf ........ = %p\n",
1487 gFnLevel, acBuf);
1488
1489 pcPos = acBuf;
1490
1491 if (nRC == RIG_OK)
1492 {
1493 int nBufLength = 0;
1494
1495 if (*pcPos == '\0') // Adjust for 00 byte at beginning ...
1496 {
1497 pcPos++; // No, please don't ask me why this happens ... ;-)
1498 }
1499
1500 nBufLength = strlen(pcPos);
1501 pcBufEnd = pcPos + nBufLength - 1;
1502
1503 pcResult = pcPos; // Save position
1504
1505 if (pcPos < pcBufEnd)
1506 {
1507 int nLength = strlen(pcPos);
1508
1509 if (nLength > 0)
1510 {
1511 char *pcPos2 = strchr(pcPos, (char) 0x0d);
1512
1513 if (pcPos2 != NULL)
1514 {
1515 *pcPos2 = '\0'; // Truncate \0d\0a
1516 }
1517
1518 pcPos = strchr(pcPos, ' ');
1519
1520 if ((pcPos != NULL) && (pcPos < pcBufEnd))
1521 {
1522 pcPos += sizeof(char);
1523
1524 rig_debug(RIG_DEBUG_TRACE,
1525 "*** ADAT: %d pcPos ........ = %p\n",
1526 gFnLevel, pcPos);
1527
1528 rig_debug(RIG_DEBUG_TRACE,
1529 "*** ADAT: %d pcBufEnd ..... = %p\n",
1530 gFnLevel, pcBufEnd);
1531
1532 rig_debug(RIG_DEBUG_TRACE,
1533 "*** ADAT: %d nBufLength ... = %d\n",
1534 gFnLevel, nBufLength);
1535
1536 rig_debug(RIG_DEBUG_TRACE,
1537 "*** ADAT: %d pcPos2 ....... = %p\n",
1538 gFnLevel, pcPos2);
1539
1540 trimwhitespace(acBuf2, strlen(pcPos), pcPos);
1541 pcResult = acBuf2;
1542 }
1543 }
1544 else
1545 {
1546 nRC = -RIG_EINVAL;
1547 }
1548 }
1549 else
1550 {
1551 nRC = -RIG_EINVAL;
1552 }
1553
1554 if (nRC == RIG_OK)
1555 {
1556 adat_priv_set_result(pRig, pcResult);
1557 }
1558 else
1559 {
1560 adat_priv_clear_result(pRig);
1561 }
1562 }
1563 }
1564
1565 rig_flush(&pRigState->rigport);
1566
1567 pPriv->nRC = nRC;
1568 }
1569
1570 // Done !
1571
1572 rig_debug(RIG_DEBUG_TRACE,
1573 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
1574 gFnLevel, __func__, __FILE__, __LINE__, nRC);
1575
1576 gFnLevel--;
1577
1578 return nRC;
1579 }
1580
1581
1582 // ---------------------------------------------------------------------------
1583 // adat_cmd_recover_from_error
1584 // ---------------------------------------------------------------------------
1585 // Status: RELEASED
adat_cmd_recover_from_error(RIG * pRig,int nError)1586 int adat_cmd_recover_from_error(RIG *pRig, int nError)
1587 {
1588 int nRC = RIG_OK;
1589
1590 gFnLevel++;
1591
1592 rig_debug(RIG_DEBUG_TRACE,
1593 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
1594 gFnLevel, __func__, __FILE__, __LINE__, pRig);
1595
1596 if (pRig == NULL)
1597 {
1598 nRC = -RIG_EARG;
1599 }
1600 else
1601 {
1602 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
1603
1604 // Recover from communication error
1605
1606 if ((nError == RIG_ETIMEOUT)
1607 || (nError == RIG_EPROTO)
1608 || (nError == RIG_EIO))
1609 {
1610
1611 rig_close(pRig);
1612 sleep(ADAT_SLEEP_AFTER_RIG_CLOSE);
1613
1614 rig_open(pRig);
1615 }
1616
1617 // Reset critical Priv values
1618
1619 pPriv->nRC = RIG_OK;
1620
1621 // Execute recovery commands
1622
1623 (void) adat_transaction(pRig, &adat_cmd_list_recover_from_error);
1624 }
1625
1626 // Done !
1627
1628 rig_debug(RIG_DEBUG_TRACE,
1629 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
1630 gFnLevel, __func__, __FILE__, __LINE__, nRC);
1631
1632 gFnLevel--;
1633
1634 return nRC;
1635 }
1636
1637
1638 // ---------------------------------------------------------------------------
1639 // adat_cmd_fn_get_callsign
1640 // ---------------------------------------------------------------------------
1641 // Status: RELEASED
adat_cmd_fn_get_callsign(RIG * pRig)1642 int adat_cmd_fn_get_callsign(RIG *pRig)
1643 {
1644 int nRC = RIG_OK;
1645
1646 gFnLevel++;
1647
1648 rig_debug(RIG_DEBUG_TRACE,
1649 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
1650 gFnLevel, __func__, __FILE__, __LINE__, pRig);
1651
1652 if (pRig == NULL)
1653 {
1654 nRC = -RIG_EARG;
1655 }
1656 else
1657 {
1658 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
1659
1660 nRC = adat_priv_set_cmd(pRig,
1661 ADAT_CMD_DEF_STRING_GET_CALLSIGN,
1662 ADAT_CMD_KIND_WITH_RESULT);
1663
1664 if (nRC == RIG_OK)
1665 {
1666 nRC = adat_get_single_cmd_result(pRig);
1667
1668 if (nRC == RIG_OK)
1669 {
1670 pPriv->pcCallsign = strdup(pPriv->pcResult);
1671
1672 rig_debug(RIG_DEBUG_TRACE,
1673 "*** ADAT: %d pPriv->pcCallsign = \"%s\"\n",
1674 gFnLevel, pPriv->pcCallsign);
1675 }
1676 }
1677 }
1678
1679 // Done !
1680
1681 rig_debug(RIG_DEBUG_TRACE,
1682 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
1683 gFnLevel, __func__, __FILE__, __LINE__, nRC);
1684
1685 gFnLevel--;
1686
1687 return nRC;
1688 }
1689
1690
1691 // ---------------------------------------------------------------------------
1692 // adat_cmd_fn_set_callsign
1693 // ---------------------------------------------------------------------------
1694 // Status: IN WORK
adat_cmd_fn_set_callsign(RIG * pRig)1695 int adat_cmd_fn_set_callsign(RIG *pRig)
1696 {
1697 int nRC = RIG_OK;
1698
1699 gFnLevel++;
1700
1701 rig_debug(RIG_DEBUG_TRACE,
1702 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
1703 gFnLevel, __func__, __FILE__, __LINE__, pRig);
1704
1705 if (pRig == NULL)
1706 {
1707 nRC = -RIG_EARG;
1708 }
1709 else
1710 {
1711 char acBuf[ ADAT_BUFSZ + 1 ];
1712
1713 memset(acBuf, 0, ADAT_BUFSZ + 1);
1714
1715 strcpy(acBuf, ADAT_CMD_DEF_STRING_SET_CALLSIGN);
1716 strcat(acBuf, "DG1SBG"ADAT_CR);
1717
1718 nRC = adat_priv_set_cmd(pRig, acBuf,
1719 ADAT_CMD_KIND_WITHOUT_RESULT);
1720
1721 if (nRC == RIG_OK)
1722 {
1723 nRC = adat_get_single_cmd_result(pRig);
1724 }
1725 }
1726
1727 // Done !
1728
1729 rig_debug(RIG_DEBUG_TRACE,
1730 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
1731 gFnLevel, __func__, __FILE__, __LINE__, nRC);
1732
1733 gFnLevel--;
1734
1735 return nRC;
1736 }
1737
1738
1739 // ---------------------------------------------------------------------------
1740 // adat_cmd_fn_get_serial_nr
1741 // ---------------------------------------------------------------------------
1742 // Status: RELEASED
adat_cmd_fn_get_serial_nr(RIG * pRig)1743 int adat_cmd_fn_get_serial_nr(RIG *pRig)
1744 {
1745 int nRC = RIG_OK;
1746
1747 gFnLevel++;
1748
1749 rig_debug(RIG_DEBUG_TRACE,
1750 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
1751 gFnLevel, __func__, __FILE__, __LINE__, pRig);
1752
1753 if (pRig == NULL)
1754 {
1755 nRC = -RIG_EARG;
1756 }
1757 else
1758 {
1759 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
1760
1761 nRC = adat_priv_set_cmd(pRig,
1762 ADAT_CMD_DEF_STRING_GET_SERIAL_NR,
1763 ADAT_CMD_KIND_WITH_RESULT);
1764
1765 if (nRC == RIG_OK)
1766 {
1767 nRC = adat_get_single_cmd_result(pRig);
1768
1769 if (nRC == RIG_OK)
1770 {
1771 pPriv->pcSerialNr = strdup(pPriv->pcResult);
1772
1773 rig_debug(RIG_DEBUG_TRACE,
1774 "*** ADAT: %d pPriv->pcSerialNr = \"%s\"\n",
1775 gFnLevel, pPriv->pcSerialNr);
1776 }
1777 }
1778 }
1779
1780 // Done !
1781
1782 rig_debug(RIG_DEBUG_TRACE,
1783 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
1784 gFnLevel, __func__, __FILE__, __LINE__, nRC);
1785 gFnLevel--;
1786
1787 return nRC;
1788 }
1789
1790
1791 // ---------------------------------------------------------------------------
1792 // adat_cmd_fn_get_fw_version
1793 // ---------------------------------------------------------------------------
1794 // Status: RELEASED
adat_cmd_fn_get_fw_version(RIG * pRig)1795 int adat_cmd_fn_get_fw_version(RIG *pRig)
1796 {
1797 int nRC = RIG_OK;
1798
1799 gFnLevel++;
1800
1801 rig_debug(RIG_DEBUG_TRACE,
1802 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
1803 gFnLevel, __func__, __FILE__, __LINE__, pRig);
1804
1805 if (pRig == NULL)
1806 {
1807 nRC = -RIG_EARG;
1808 }
1809 else
1810 {
1811 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
1812
1813 nRC = adat_priv_set_cmd(pRig,
1814 ADAT_CMD_DEF_STRING_GET_FW_VERSION,
1815 ADAT_CMD_KIND_WITH_RESULT);
1816
1817 if (nRC == RIG_OK)
1818 {
1819 nRC = adat_get_single_cmd_result(pRig);
1820
1821 if (nRC == RIG_OK)
1822 {
1823 pPriv->pcFWVersion = strdup(pPriv->pcResult);
1824
1825 rig_debug(RIG_DEBUG_TRACE,
1826 "*** ADAT: %d pPriv->pcFWVersion = \"%s\"\n",
1827 gFnLevel, pPriv->pcFWVersion);
1828 }
1829 }
1830 }
1831
1832 // Done !
1833
1834 rig_debug(RIG_DEBUG_TRACE,
1835 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
1836 gFnLevel, __func__, __FILE__, __LINE__, nRC);
1837
1838 gFnLevel--;
1839
1840 return nRC;
1841 }
1842
1843
1844 // ---------------------------------------------------------------------------
1845 // adat_cmd_fn_get_hw_version
1846 // ---------------------------------------------------------------------------
1847 // Status: RELEASED
adat_cmd_fn_get_hw_version(RIG * pRig)1848 int adat_cmd_fn_get_hw_version(RIG *pRig)
1849 {
1850 int nRC = RIG_OK;
1851
1852 gFnLevel++;
1853
1854 rig_debug(RIG_DEBUG_TRACE,
1855 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
1856 gFnLevel, __func__, __FILE__, __LINE__, pRig);
1857
1858 if (pRig == NULL)
1859 {
1860 nRC = -RIG_EARG;
1861 }
1862 else
1863 {
1864 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
1865
1866 nRC = adat_priv_set_cmd(pRig,
1867 ADAT_CMD_DEF_STRING_GET_HW_VERSION,
1868 ADAT_CMD_KIND_WITH_RESULT);
1869
1870 if (nRC == RIG_OK)
1871 {
1872 nRC = adat_get_single_cmd_result(pRig);
1873
1874 if (nRC == RIG_OK)
1875 {
1876 pPriv->pcHWVersion = strdup(pPriv->pcResult);
1877
1878 rig_debug(RIG_DEBUG_TRACE,
1879 "*** ADAT: %d pPriv->pcHWVersion = \"%s\"\n",
1880 gFnLevel, pPriv->pcHWVersion);
1881 }
1882 }
1883 }
1884
1885 // Done !
1886
1887 rig_debug(RIG_DEBUG_TRACE,
1888 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
1889 gFnLevel, __func__, __FILE__, __LINE__, nRC);
1890 gFnLevel--;
1891
1892 return nRC;
1893 }
1894
1895
1896 // ---------------------------------------------------------------------------
1897 // adat_cmd_fn_get_gui_fw_version
1898 // ---------------------------------------------------------------------------
1899 // Status: RELEASED
adat_cmd_fn_get_gui_fw_version(RIG * pRig)1900 int adat_cmd_fn_get_gui_fw_version(RIG *pRig)
1901 {
1902 int nRC = RIG_OK;
1903
1904 gFnLevel++;
1905
1906 rig_debug(RIG_DEBUG_TRACE,
1907 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
1908 gFnLevel, __func__, __FILE__, __LINE__, pRig);
1909
1910 if (pRig == NULL)
1911 {
1912 nRC = -RIG_EARG;
1913 }
1914 else
1915 {
1916 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
1917
1918 nRC = adat_priv_set_cmd(pRig,
1919 ADAT_CMD_DEF_STRING_GET_GUI_FW_VERSION,
1920 ADAT_CMD_KIND_WITH_RESULT);
1921
1922 if (nRC == RIG_OK)
1923 {
1924 nRC = adat_get_single_cmd_result(pRig);
1925
1926 if (nRC == RIG_OK)
1927 {
1928 pPriv->pcGUIFWVersion = strdup(pPriv->pcResult);
1929
1930 rig_debug(RIG_DEBUG_TRACE,
1931 "*** ADAT: %d pPriv->pcGUIFWVersion = \"%s\"\n",
1932 gFnLevel, pPriv->pcGUIFWVersion);
1933 }
1934 }
1935 }
1936
1937 // Done !
1938
1939 rig_debug(RIG_DEBUG_TRACE,
1940 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
1941 gFnLevel, __func__, __FILE__, __LINE__, nRC);
1942
1943 gFnLevel--;
1944
1945 return nRC;
1946 }
1947
1948
1949 // ---------------------------------------------------------------------------
1950 // adat_cmd_fn_get_id_code
1951 // ---------------------------------------------------------------------------
1952 // Status: RELEASED
adat_cmd_fn_get_id_code(RIG * pRig)1953 int adat_cmd_fn_get_id_code(RIG *pRig)
1954 {
1955 int nRC = RIG_OK;
1956
1957 gFnLevel++;
1958
1959 rig_debug(RIG_DEBUG_TRACE,
1960 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
1961 gFnLevel, __func__, __FILE__, __LINE__, pRig);
1962
1963 if (pRig == NULL)
1964 {
1965 nRC = -RIG_EARG;
1966 }
1967 else
1968 {
1969 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
1970
1971 nRC = adat_priv_set_cmd(pRig,
1972 ADAT_CMD_DEF_STRING_GET_ID_CODE,
1973 ADAT_CMD_KIND_WITH_RESULT);
1974
1975 if (nRC == RIG_OK)
1976 {
1977 nRC = adat_get_single_cmd_result(pRig);
1978
1979 if (nRC == RIG_OK)
1980 {
1981 pPriv->pcIDCode = strdup(pPriv->pcResult);
1982
1983 rig_debug(RIG_DEBUG_TRACE,
1984 "*** ADAT: %d pPriv->pcIDCode = \"%s\"\n",
1985 gFnLevel, pPriv->pcIDCode);
1986 }
1987 }
1988 }
1989
1990 // Done !
1991
1992 rig_debug(RIG_DEBUG_TRACE,
1993 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
1994 gFnLevel, __func__, __FILE__, __LINE__, nRC);
1995 gFnLevel--;
1996
1997 return nRC;
1998 }
1999
2000
2001 // ---------------------------------------------------------------------------
2002 // adat_cmd_fn_get_options
2003 // ---------------------------------------------------------------------------
2004 // Status: RELEASED
adat_cmd_fn_get_options(RIG * pRig)2005 int adat_cmd_fn_get_options(RIG *pRig)
2006 {
2007 int nRC = RIG_OK;
2008
2009 gFnLevel++;
2010
2011 rig_debug(RIG_DEBUG_TRACE,
2012 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
2013 gFnLevel, __func__, __FILE__, __LINE__, pRig);
2014
2015 if (pRig == NULL)
2016 {
2017 nRC = -RIG_EARG;
2018 }
2019 else
2020 {
2021 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
2022
2023 nRC = adat_priv_set_cmd(pRig,
2024 ADAT_CMD_DEF_STRING_GET_OPTIONS,
2025 ADAT_CMD_KIND_WITH_RESULT);
2026
2027 if (nRC == RIG_OK)
2028 {
2029 nRC = adat_get_single_cmd_result(pRig);
2030
2031 if (nRC == RIG_OK)
2032 {
2033 pPriv->pcOptions = strdup(pPriv->pcResult);
2034
2035 rig_debug(RIG_DEBUG_TRACE,
2036 "*** ADAT: %d pPriv->pcOptions = \"%s\"\n",
2037 gFnLevel, pPriv->pcOptions);
2038 }
2039 }
2040 }
2041
2042 // Done !
2043
2044 rig_debug(RIG_DEBUG_TRACE,
2045 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
2046 gFnLevel, __func__, __FILE__, __LINE__, nRC);
2047 gFnLevel--;
2048
2049 return nRC;
2050 }
2051
2052
2053 // ---------------------------------------------------------------------------
2054 // adat_cmd_fn_get_mode
2055 // ---------------------------------------------------------------------------
2056 // Status: RELEASED
adat_cmd_fn_get_mode(RIG * pRig)2057 int adat_cmd_fn_get_mode(RIG *pRig)
2058 {
2059 int nRC = RIG_OK;
2060
2061 gFnLevel++;
2062
2063 rig_debug(RIG_DEBUG_TRACE,
2064 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
2065 gFnLevel, __func__, __FILE__, __LINE__, pRig);
2066
2067 if (pRig == NULL)
2068 {
2069 nRC = -RIG_EARG;
2070 }
2071 else
2072 {
2073 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
2074
2075 nRC = adat_priv_set_cmd(pRig,
2076 ADAT_CMD_DEF_STRING_GET_MODE,
2077 ADAT_CMD_KIND_WITH_RESULT);
2078
2079 if (nRC == RIG_OK)
2080 {
2081 nRC = adat_get_single_cmd_result(pRig);
2082
2083 if (nRC == RIG_OK)
2084 {
2085 nRC = adat_parse_mode(pPriv->pcResult,
2086 &(pPriv->nRIGMode),
2087 pPriv->acADATMode);
2088 }
2089 }
2090 }
2091
2092 // Done !
2093
2094 rig_debug(RIG_DEBUG_TRACE,
2095 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
2096 gFnLevel, __func__, __FILE__, __LINE__, nRC);
2097 gFnLevel--;
2098
2099 return nRC;
2100 }
2101
2102
2103 // ---------------------------------------------------------------------------
2104 // adat_cmd_fn_set_mode
2105 // ---------------------------------------------------------------------------
2106 // Status: RELEASED
adat_cmd_fn_set_mode(RIG * pRig)2107 int adat_cmd_fn_set_mode(RIG *pRig)
2108 {
2109 int nRC = RIG_OK;
2110
2111 gFnLevel++;
2112
2113 rig_debug(RIG_DEBUG_TRACE,
2114 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
2115 gFnLevel, __func__, __FILE__, __LINE__, pRig);
2116
2117 if (pRig == NULL)
2118 {
2119 nRC = -RIG_EARG;
2120 }
2121 else
2122 {
2123 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
2124
2125 // Translate Mode from RIG Mode Nr to ADAT Mode Nr
2126
2127 nRC = adat_mode_rnr2anr(pPriv->nRIGMode, &(pPriv->nADATMode));
2128
2129 if (nRC == RIG_OK)
2130 {
2131 // Prepare Command
2132
2133 char acBuf[ ADAT_BUFSZ + 1 ];
2134
2135 memset(acBuf, 0, ADAT_BUFSZ + 1);
2136
2137 snprintf(acBuf, ADAT_BUFSZ, "%s%02d%s",
2138 ADAT_CMD_DEF_STRING_SET_MODE,
2139 (int) pPriv->nADATMode,
2140 ADAT_EOM);
2141
2142 nRC = adat_priv_set_cmd(pRig, acBuf, ADAT_CMD_KIND_WITHOUT_RESULT);
2143
2144 // Execute Command
2145
2146 if (nRC == RIG_OK)
2147 {
2148 nRC = adat_get_single_cmd_result(pRig);
2149 }
2150 }
2151 }
2152
2153 // Done !
2154
2155 rig_debug(RIG_DEBUG_TRACE,
2156 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
2157 gFnLevel, __func__, __FILE__, __LINE__, nRC);
2158
2159 gFnLevel--;
2160
2161 return nRC;
2162 }
2163
2164
2165 // ---------------------------------------------------------------------------
2166 // adat_cmd_fn_get_freq
2167 // ---------------------------------------------------------------------------
2168 // Status: RELEASED
adat_cmd_fn_get_freq(RIG * pRig)2169 int adat_cmd_fn_get_freq(RIG *pRig)
2170 {
2171 int nRC = RIG_OK;
2172
2173 gFnLevel++;
2174
2175 rig_debug(RIG_DEBUG_TRACE,
2176 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
2177 gFnLevel, __func__, __FILE__, __LINE__, pRig);
2178
2179 if (pRig == NULL)
2180 {
2181 nRC = -RIG_EARG;
2182 }
2183 else
2184 {
2185 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
2186
2187 nRC = adat_priv_set_cmd(pRig,
2188 ADAT_CMD_DEF_STRING_GET_FREQ,
2189 ADAT_CMD_KIND_WITH_RESULT);
2190
2191 if (nRC == RIG_OK)
2192 {
2193 nRC = adat_get_single_cmd_result(pRig);
2194
2195 if (nRC == RIG_OK)
2196 {
2197 nRC = adat_parse_freq(pPriv->pcResult,
2198 ADAT_FREQ_PARSE_MODE_WITH_VFO,
2199 &(pPriv->nCurrentVFO),
2200 &(pPriv->nFreq));
2201
2202 rig_debug(RIG_DEBUG_TRACE,
2203 "*** ADAT: %d pPriv->nCurrentVFO = %d, Freq [Hz] = %f\n",
2204 gFnLevel, pPriv->nCurrentVFO, pPriv->nFreq);
2205
2206 if (nRC == RIG_OK)
2207 {
2208 nRC = adat_vfo_anr2rnr(pPriv->nCurrentVFO,
2209 &(pPriv->nRIGVFONr));
2210 }
2211 }
2212 }
2213 }
2214
2215 // Done !
2216
2217 rig_debug(RIG_DEBUG_TRACE,
2218 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
2219 gFnLevel, __func__, __FILE__, __LINE__, nRC);
2220 gFnLevel--;
2221
2222 return nRC;
2223 }
2224
2225
2226 // ---------------------------------------------------------------------------
2227 // adat_cmd_fn_set_freq
2228 // ---------------------------------------------------------------------------
2229 // Status: RELEASED
adat_cmd_fn_set_freq(RIG * pRig)2230 int adat_cmd_fn_set_freq(RIG *pRig)
2231 {
2232 int nRC = RIG_OK;
2233
2234 gFnLevel++;
2235
2236 rig_debug(RIG_DEBUG_TRACE,
2237 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
2238 gFnLevel, __func__, __FILE__, __LINE__, pRig);
2239
2240 if (pRig == NULL)
2241 {
2242 nRC = -RIG_EARG;
2243 }
2244 else
2245 {
2246 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
2247 char acBuf[ ADAT_BUFSZ + 1 ];
2248
2249 // Get frequency of selected VFO
2250
2251 memset(acBuf, 0, ADAT_BUFSZ + 1);
2252
2253 snprintf(acBuf, ADAT_BUFSZ, "%s%d%s",
2254 ADAT_CMD_DEF_STRING_SET_FREQ,
2255 (int) pPriv->nFreq,
2256 ADAT_EOM);
2257
2258 nRC = adat_priv_set_cmd(pRig, acBuf, ADAT_CMD_KIND_WITHOUT_RESULT);
2259
2260 if (nRC == RIG_OK)
2261 {
2262 nRC = adat_get_single_cmd_result(pRig);
2263 }
2264 }
2265
2266 // Done !
2267
2268 rig_debug(RIG_DEBUG_TRACE,
2269 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
2270 gFnLevel, __func__, __FILE__, __LINE__, nRC);
2271 gFnLevel--;
2272
2273 return nRC;
2274 }
2275
2276
2277 // ---------------------------------------------------------------------------
2278 // adat_cmd_fn_set_vfo
2279 // ---------------------------------------------------------------------------
2280 // Status: RELEASED
2281
2282 // Setting a VFO on an ADAT is actually two steps:
2283 // 1. Switching on that VFO
2284 // 2. Setting this VFO as the main VFO
adat_cmd_fn_set_vfo(RIG * pRig)2285 int adat_cmd_fn_set_vfo(RIG *pRig)
2286 {
2287 int nRC = RIG_OK;
2288
2289 gFnLevel++;
2290
2291 rig_debug(RIG_DEBUG_TRACE,
2292 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
2293 gFnLevel, __func__, __FILE__, __LINE__, pRig);
2294
2295 if (pRig == NULL)
2296 {
2297 nRC = -RIG_EARG;
2298 }
2299 else
2300 {
2301 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
2302 char acBuf[ ADAT_BUFSZ + 1 ];
2303
2304 // Switch on VFO
2305
2306 memset(acBuf, 0, ADAT_BUFSZ + 1);
2307
2308 snprintf(acBuf, ADAT_BUFSZ, ADAT_CMD_DEF_STRING_SWITCH_ON_VFO,
2309 (int) pPriv->nCurrentVFO,
2310 ADAT_EOM);
2311
2312 nRC = adat_priv_set_cmd(pRig, acBuf, ADAT_CMD_KIND_WITHOUT_RESULT);
2313
2314 if (nRC == RIG_OK)
2315 {
2316 nRC = adat_get_single_cmd_result(pRig);
2317
2318 if (nRC == RIG_OK)
2319 {
2320 memset(acBuf, 0, ADAT_BUFSZ + 1);
2321 snprintf(acBuf, ADAT_BUFSZ,
2322 ADAT_CMD_DEF_STRING_SET_VFO_AS_MAIN_VFO,
2323 (int) pPriv->nCurrentVFO,
2324 ADAT_EOM);
2325
2326 nRC = adat_priv_set_cmd(pRig, acBuf,
2327 ADAT_CMD_KIND_WITHOUT_RESULT);
2328
2329 if (nRC == RIG_OK)
2330 {
2331 nRC = adat_get_single_cmd_result(pRig);
2332 }
2333 }
2334 }
2335 }
2336
2337 // Done !
2338
2339 rig_debug(RIG_DEBUG_TRACE,
2340 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
2341 gFnLevel, __func__, __FILE__, __LINE__, nRC);
2342 gFnLevel--;
2343
2344 return nRC;
2345 }
2346
2347
2348 // ---------------------------------------------------------------------------
2349 // adat_cmd_fn_get_ptt
2350 // ---------------------------------------------------------------------------
2351 // Status: RELEASED
adat_cmd_fn_get_ptt(RIG * pRig)2352 int adat_cmd_fn_get_ptt(RIG *pRig)
2353 {
2354 int nRC = RIG_OK;
2355
2356 gFnLevel++;
2357
2358 rig_debug(RIG_DEBUG_TRACE,
2359 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
2360 gFnLevel, __func__, __FILE__, __LINE__, pRig);
2361
2362 if (pRig == NULL)
2363 {
2364 nRC = -RIG_EARG;
2365 }
2366 else
2367 {
2368 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
2369
2370 nRC = adat_priv_set_cmd(pRig,
2371 ADAT_CMD_DEF_STRING_GET_PTT,
2372 ADAT_CMD_KIND_WITH_RESULT);
2373
2374 if (nRC == RIG_OK)
2375 {
2376 nRC = adat_get_single_cmd_result(pRig);
2377
2378 if (nRC == RIG_OK)
2379 {
2380 nRC = adat_parse_ptt(pPriv->pcResult,
2381 &(pPriv->nADATPTTStatus));
2382
2383 if (nRC == RIG_OK)
2384 {
2385 nRC = adat_ptt_anr2rnr(pPriv->nADATPTTStatus,
2386 &(pPriv->nRIGPTTStatus));
2387 }
2388 }
2389 }
2390 }
2391
2392 // Done !
2393
2394 rig_debug(RIG_DEBUG_TRACE,
2395 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
2396 gFnLevel, __func__, __FILE__, __LINE__, nRC);
2397 gFnLevel--;
2398
2399 return nRC;
2400 }
2401
2402
2403 // ---------------------------------------------------------------------------
2404 // adat_cmd_fn_set_ptt
2405 // ---------------------------------------------------------------------------
2406 // Status: RELEASED
adat_cmd_fn_set_ptt(RIG * pRig)2407 int adat_cmd_fn_set_ptt(RIG *pRig)
2408 {
2409 int nRC = RIG_OK;
2410
2411 gFnLevel++;
2412
2413 rig_debug(RIG_DEBUG_TRACE,
2414 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
2415 gFnLevel, __func__, __FILE__, __LINE__, pRig);
2416
2417 if (pRig == NULL)
2418 {
2419 nRC = -RIG_EARG;
2420 }
2421 else
2422 {
2423 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
2424 char acBuf[ ADAT_BUFSZ + 1 ];
2425 char *pcPTTStr = NULL;
2426
2427 memset(acBuf, 0, ADAT_BUFSZ + 1);
2428
2429 // Switch PTT
2430
2431 switch (pPriv->nOpCode)
2432 {
2433 case ADAT_OPCODE_PTT_SWITCH_ON:
2434
2435 pPriv->nADATPTTStatus = ADAT_PTT_STATUS_ANR_ON;
2436 nRC = adat_ptt_anr2rnr(ADAT_PTT_STATUS_ANR_ON,
2437 &(pPriv->nRIGPTTStatus));
2438 pcPTTStr = ADAT_CMD_PTT_STR_ON;
2439 break;
2440
2441 case ADAT_OPCODE_PTT_SWITCH_OFF:
2442 pPriv->nADATPTTStatus = ADAT_PTT_STATUS_ANR_OFF;
2443 nRC = adat_ptt_anr2rnr(ADAT_PTT_STATUS_ANR_OFF,
2444 &(pPriv->nRIGPTTStatus));
2445 pcPTTStr = ADAT_CMD_PTT_STR_OFF;
2446 break;
2447
2448 default:
2449 nRC = -RIG_EINVAL;
2450 break;
2451 }
2452
2453 if (nRC == RIG_OK)
2454 {
2455 snprintf(acBuf, ADAT_BUFSZ, ADAT_CMD_DEF_STRING_SET_PTT,
2456 pcPTTStr,
2457 ADAT_EOM);
2458
2459 nRC = adat_priv_set_cmd(pRig, acBuf, ADAT_CMD_KIND_WITHOUT_RESULT);
2460
2461 if (nRC == RIG_OK)
2462 {
2463 nRC = adat_get_single_cmd_result(pRig);
2464 }
2465 }
2466 }
2467
2468 // Done !
2469
2470 rig_debug(RIG_DEBUG_TRACE,
2471 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
2472 gFnLevel, __func__, __FILE__, __LINE__, nRC);
2473 gFnLevel--;
2474
2475 return nRC;
2476 }
2477
2478
2479 // ---------------------------------------------------------------------------
2480 // adat_transaction
2481 // ---------------------------------------------------------------------------
2482 // Status: RELEASED
2483
2484 // adat_transaction is a generalized command processor able to execute
2485 // commands of type adat_cmd_def_t .
adat_transaction(RIG * pRig,adat_cmd_list_ptr pCmdList)2486 int adat_transaction(RIG *pRig,
2487 adat_cmd_list_ptr pCmdList)
2488 {
2489 int nRC = RIG_OK;
2490
2491 gFnLevel++;
2492
2493 rig_debug(RIG_DEBUG_TRACE,
2494 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
2495 gFnLevel, __func__, __FILE__, __LINE__, pRig);
2496
2497 if (pRig == NULL)
2498 {
2499 nRC = -RIG_EARG;
2500 }
2501 else
2502 {
2503 int nI = 0;
2504 int nFini = 0; // = 1 -> Stop executing commands
2505 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
2506
2507 rig_debug(RIG_DEBUG_TRACE,
2508 "*** ADAT: %d %s (%s:%d): Nr of commands = %d\n",
2509 gFnLevel, __func__, __FILE__, __LINE__, pCmdList->nNrCmds);
2510
2511 while ((nRC == RIG_OK) && (nFini == 0) && (nI < pCmdList->nNrCmds))
2512 {
2513 adat_cmd_def_ptr pCmd = NULL;
2514
2515 pCmd = pCmdList->adat_cmds[ nI ];
2516
2517 if ((pCmd != NULL) && (pCmd->nCmdId != ADAT_CMD_DEF_NIL))
2518 {
2519
2520 rig_debug(RIG_DEBUG_TRACE,
2521 "*** ADAT: %d About to execute ADAT Command ... \n",
2522 gFnLevel);
2523 adat_print_cmd(pCmd);
2524
2525 // Execute Command
2526
2527 if (pCmd->pfCmdFn != NULL)
2528 {
2529 rig_debug(RIG_DEBUG_TRACE,
2530 "*** ADAT: %d Calling function via fn ptr ... \n",
2531 gFnLevel);
2532 nRC = pCmd->pfCmdFn(pRig);
2533 }
2534 else
2535 {
2536 rig_debug(RIG_DEBUG_TRACE,
2537 "*** ADAT: %d Sending command string ... \n",
2538 gFnLevel);
2539 // TODO: Quell clang warning of conditional always evaluating to true.
2540 // if( pCmd->pacCmdStrs != NULL )
2541 // {
2542
2543 if (pCmd->nNrCmdStrs > 0)
2544 {
2545 int nJ = 0;
2546 rig_debug(RIG_DEBUG_TRACE,
2547 "*** ADAT: %d pacCmdStrs[%d] = %s\n",
2548 gFnLevel, nJ, pCmd->pacCmdStrs[ nJ ]);
2549
2550 while ((nJ < pCmd->nNrCmdStrs)
2551 && (nRC == RIG_OK)
2552 && (pCmd->pacCmdStrs[ nJ ] != NULL))
2553 {
2554
2555 nRC = adat_send(pRig, pCmd->pacCmdStrs[ nJ ]);
2556
2557 if (nRC == RIG_OK)
2558 {
2559 if (pCmd->nCmdKind == ADAT_CMD_KIND_WITH_RESULT)
2560 {
2561 char acBuf[ ADAT_RESPSZ + 1 ];
2562
2563 memset(acBuf, 0, ADAT_RESPSZ + 1);
2564
2565 nRC = adat_receive(pRig, acBuf);
2566
2567 while ((nRC == RIG_OK)
2568 && (strncmp(acBuf, ADAT_BOM,
2569 strlen(ADAT_BOM)) != 0))
2570 {
2571
2572 nRC = adat_receive(pRig, acBuf);
2573 }
2574
2575 if (pPriv->pcResult != NULL)
2576 {
2577 free(pPriv->pcResult);
2578 }
2579
2580 pPriv->pcResult = strdup(acBuf);
2581 }
2582 }
2583
2584 nJ++;
2585 }
2586 }
2587
2588 // }
2589 }
2590
2591 if (nRC != RIG_OK)
2592 {
2593 (void) adat_cmd_recover_from_error(pRig, nRC);
2594 }
2595
2596 nI++;
2597 }
2598 else
2599 {
2600 nFini = 1;
2601 }
2602
2603 // sleep between cmds - ADAT needs time to act upoon cmds
2604
2605 hl_usleep(ADAT_SLEEP_MICROSECONDS_BETWEEN_CMDS);
2606 }
2607 }
2608
2609 // Done !
2610
2611 rig_debug(RIG_DEBUG_TRACE,
2612 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
2613 gFnLevel, __func__, __FILE__, __LINE__, nRC);
2614 gFnLevel--;
2615
2616 return nRC;
2617 }
2618
2619
2620 // ---------------------------------------------------------------------------
2621 // adat_new_priv_data
2622 // ---------------------------------------------------------------------------
2623 // Status: RELEASED
adat_new_priv_data(RIG * pRig)2624 adat_priv_data_ptr adat_new_priv_data(RIG *pRig)
2625 {
2626 int nRC = 0;
2627 adat_priv_data_ptr pPriv = NULL;
2628
2629 gFnLevel++;
2630
2631 rig_debug(RIG_DEBUG_TRACE,
2632 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
2633 gFnLevel, __func__, __FILE__, __LINE__, pRig);
2634
2635 if (pRig != NULL)
2636 {
2637 // Init Priv Data
2638
2639 pPriv = pRig->state.priv = (adat_priv_data_ptr) calloc(sizeof(adat_priv_data_t),
2640 1);
2641
2642 if (pRig->state.priv != NULL)
2643 {
2644 char acBuf[ ADAT_BUFSZ + 1 ];
2645 memset(acBuf, 0, ADAT_BUFSZ + 1);
2646
2647 // FIXME: pointless code at init time
2648 #if 0
2649 nRC = adat_get_conf(pRig, TOKEN_ADAT_PRODUCT_NAME, acBuf);
2650
2651 if (nRC == 0)
2652 {
2653 pPriv->pcProductName = strdup(acBuf);
2654
2655 pRig->state.priv = (void *) pPriv;
2656 }
2657
2658 #endif
2659 }
2660 else
2661 {
2662 nRC = -RIG_ENOMEM;
2663 }
2664 }
2665 else
2666 {
2667 nRC = -RIG_EARG;
2668 }
2669
2670 rig_debug(RIG_DEBUG_TRACE,
2671 "*** ADAT: %d %s (%s:%d): EXIT. RC = %d, pPriv = %p\n",
2672 gFnLevel, __func__, __FILE__, __LINE__, nRC, pPriv);
2673 gFnLevel--;
2674
2675 return pPriv;
2676 }
2677
2678
2679 // ---------------------------------------------------------------------------
2680 // adat_del_priv_data
2681 // ---------------------------------------------------------------------------
2682 // Status: RELEASED
adat_del_priv_data(adat_priv_data_t ** ppPriv)2683 void adat_del_priv_data(adat_priv_data_t **ppPriv)
2684 {
2685 int nRC = 0;
2686
2687 gFnLevel++;
2688
2689 rig_debug(RIG_DEBUG_TRACE,
2690 "*** ADAT: %d %s (%s:%d): ENTRY. Params: ppPrivData = %p\n",
2691 gFnLevel, __func__, __FILE__, __LINE__, ppPriv);
2692
2693 if ((ppPriv != NULL) && (*ppPriv != NULL))
2694 {
2695 // Delete / Free Priv Data
2696
2697 if ((*ppPriv)->pcProductName != NULL)
2698 {
2699 free((*ppPriv)->pcProductName);
2700 }
2701
2702 if ((*ppPriv)->pcSerialNr != NULL)
2703 {
2704 free((*ppPriv)->pcSerialNr);
2705 }
2706
2707 if ((*ppPriv)->pcHWVersion != NULL)
2708 {
2709 free((*ppPriv)->pcHWVersion);
2710 }
2711
2712 if ((*ppPriv)->pcFWVersion != NULL)
2713 {
2714 free((*ppPriv)->pcFWVersion);
2715 }
2716
2717 if ((*ppPriv)->pcGUIFWVersion != NULL)
2718 {
2719 free((*ppPriv)->pcGUIFWVersion);
2720 }
2721
2722 if ((*ppPriv)->pcOptions != NULL)
2723 {
2724 free((*ppPriv)->pcOptions);
2725 }
2726
2727 if ((*ppPriv)->pcIDCode != NULL)
2728 {
2729 free((*ppPriv)->pcIDCode);
2730 }
2731
2732 if ((*ppPriv)->pcCallsign != NULL)
2733 {
2734 free((*ppPriv)->pcCallsign);
2735 }
2736
2737 // Free priv struct itself
2738
2739 free((*ppPriv));
2740 *ppPriv = NULL;
2741 }
2742 else
2743 {
2744 nRC = -RIG_EARG;
2745 }
2746
2747 rig_debug(RIG_DEBUG_TRACE,
2748 "*** ADAT: %d %s (%s:%d): EXIT. RC = %d.\n",
2749 gFnLevel, __func__, __FILE__, __LINE__, nRC);
2750 gFnLevel--;
2751
2752 return;
2753 }
2754
2755
2756 // ---------------------------------------------------------------------------
2757 // Function adat_init
2758 // ---------------------------------------------------------------------------
2759 // Status: RELEASED
adat_init(RIG * pRig)2760 int adat_init(RIG *pRig)
2761 {
2762 int nRC = RIG_OK;
2763
2764 gFnLevel++;
2765
2766 rig_debug(RIG_DEBUG_TRACE,
2767 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
2768 gFnLevel, __func__, __FILE__, __LINE__, pRig);
2769
2770 // Check Params
2771
2772 if (pRig != NULL)
2773 {
2774 adat_priv_data_ptr pPriv = NULL;
2775
2776 // Get new Priv Data
2777
2778 pPriv = adat_new_priv_data(pRig);
2779
2780 if (pPriv == NULL)
2781 {
2782 nRC = -RIG_ENOMEM;
2783 }
2784 }
2785
2786 // Done !
2787
2788 rig_debug(RIG_DEBUG_TRACE,
2789 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
2790 gFnLevel, __func__, __FILE__, __LINE__, nRC);
2791 gFnLevel--;
2792
2793 return nRC;
2794 }
2795
2796
2797 // ---------------------------------------------------------------------------
2798 // Function adat_cleanup
2799 // ---------------------------------------------------------------------------
2800 // Status: RELEASED
adat_cleanup(RIG * pRig)2801 int adat_cleanup(RIG *pRig)
2802 {
2803 int nRC = RIG_OK;
2804
2805 gFnLevel++;
2806
2807 rig_debug(RIG_DEBUG_TRACE,
2808 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
2809 gFnLevel, __func__, __FILE__, __LINE__, pRig);
2810
2811 if (pRig == NULL)
2812 {
2813 nRC = -RIG_EARG;
2814 }
2815 else
2816 {
2817 if (pRig->state.priv != NULL)
2818 {
2819 adat_del_priv_data((adat_priv_data_t **) & (pRig->state.priv));
2820 pRig->state.priv = NULL;
2821 }
2822 }
2823
2824 rig_debug(RIG_DEBUG_TRACE,
2825 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
2826 gFnLevel, __func__, __FILE__, __LINE__, nRC);
2827 gFnLevel--;
2828
2829 return nRC;
2830 }
2831
2832
2833 // ---------------------------------------------------------------------------
2834 // Function adat_open
2835 // ---------------------------------------------------------------------------
2836 // Status: RELEASED
adat_open(RIG * pRig)2837 int adat_open(RIG *pRig)
2838 {
2839 int nRC = RIG_OK;
2840
2841 gFnLevel++;
2842
2843 rig_debug(RIG_DEBUG_TRACE,
2844 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
2845 gFnLevel, __func__, __FILE__, __LINE__, pRig);
2846
2847 // Check Params
2848
2849 if (pRig == NULL)
2850 {
2851 nRC = -RIG_EARG;
2852 }
2853 else
2854 {
2855 // grace period for the radio to be there
2856
2857 sleep(ADAT_SLEEP_AFTER_RIG_OPEN);
2858
2859 // Now get basic info from ADAT TRX
2860
2861 nRC = adat_transaction(pRig, &adat_cmd_list_open_adat);
2862 }
2863
2864 // Done !
2865
2866 rig_debug(RIG_DEBUG_TRACE,
2867 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
2868 gFnLevel, __func__, __FILE__, __LINE__, nRC);
2869 gFnLevel--;
2870
2871 return nRC;
2872 }
2873
2874
2875 // ---------------------------------------------------------------------------
2876 // Function adat_close
2877 // ---------------------------------------------------------------------------
2878 // Status: RELEASED
adat_close(RIG * pRig)2879 int adat_close(RIG *pRig)
2880 {
2881 int nRC = RIG_OK;
2882 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
2883
2884 if (pPriv->pcCmd != NULL) { free(pPriv->pcCmd); }
2885
2886 if (pPriv->pcResult != NULL) { free(pPriv->pcResult); }
2887
2888 gFnLevel++;
2889
2890 rig_debug(RIG_DEBUG_TRACE,
2891 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
2892 gFnLevel, __func__, __FILE__, __LINE__, pRig);
2893
2894 // Now switch to interactive mode
2895
2896 nRC = adat_transaction(pRig, &adat_cmd_list_close_adat);
2897
2898 // Done !
2899
2900 rig_debug(RIG_DEBUG_TRACE,
2901 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
2902 gFnLevel, __func__, __FILE__, __LINE__, nRC);
2903 gFnLevel--;
2904
2905 return nRC;
2906 }
2907
2908
2909 // ---------------------------------------------------------------------------
2910 // Function adat_get_info
2911 // ---------------------------------------------------------------------------
2912 // Status: RELEASED
adat_get_info(RIG * pRig)2913 const char *adat_get_info(RIG *pRig)
2914 {
2915 static char acBuf[ 512 ];
2916
2917 gFnLevel++;
2918
2919 rig_debug(RIG_DEBUG_TRACE,
2920 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
2921 gFnLevel, __func__, __FILE__, __LINE__, pRig);
2922
2923 memset(acBuf, 0, 512);
2924
2925 if (pRig != NULL)
2926 {
2927 int nRC = adat_transaction(pRig, &adat_cmd_list_get_info);
2928
2929 if (nRC == RIG_OK)
2930 {
2931 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
2932
2933 snprintf(acBuf, 512,
2934 "ADAT ADT-200A, Callsign: %s, S/N: %s, ID Code: %s, Options: %s, FW: %s, GUI FW: %s, HW: %s",
2935 pPriv->pcCallsign,
2936 pPriv->pcSerialNr,
2937 pPriv->pcIDCode,
2938 pPriv->pcOptions,
2939 pPriv->pcFWVersion,
2940 pPriv->pcGUIFWVersion,
2941 pPriv->pcHWVersion);
2942 }
2943 }
2944
2945 rig_debug(RIG_DEBUG_TRACE,
2946 "*** ADAT: %d %s (%s:%d): EXIT. Return Value ='%s'\n",
2947 gFnLevel, __func__, __FILE__, __LINE__, acBuf);
2948 gFnLevel--;
2949
2950 return acBuf;
2951 }
2952
2953
2954 // ---------------------------------------------------------------------------
2955 // Function adat_set_freq
2956 // ---------------------------------------------------------------------------
2957 // Status: RELEASED
adat_set_freq(RIG * pRig,vfo_t vfo,freq_t freq)2958 int adat_set_freq(RIG *pRig, vfo_t vfo, freq_t freq)
2959 {
2960 int nRC = RIG_OK;
2961
2962 gFnLevel++;
2963
2964 rig_debug(RIG_DEBUG_TRACE,
2965 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
2966 gFnLevel, __func__, __FILE__, __LINE__, pRig);
2967
2968 // Check Params
2969
2970 if (pRig == NULL)
2971 {
2972 nRC = -RIG_EARG;
2973 }
2974 else
2975 {
2976 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
2977
2978 pPriv->nFreq = freq;
2979
2980 nRC = adat_transaction(pRig, &adat_cmd_list_set_freq);
2981 }
2982
2983 rig_debug(RIG_DEBUG_TRACE,
2984 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
2985 gFnLevel, __func__, __FILE__, __LINE__, nRC);
2986 gFnLevel--;
2987
2988 return nRC;
2989 }
2990
2991
2992 // ---------------------------------------------------------------------------
2993 // Function adat_get_freq
2994 // ---------------------------------------------------------------------------
2995 // Status: RELEASED
adat_get_freq(RIG * pRig,vfo_t vfo,freq_t * freq)2996 int adat_get_freq(RIG *pRig, vfo_t vfo, freq_t *freq)
2997 {
2998 int nRC = RIG_OK;
2999
3000 gFnLevel++;
3001
3002 rig_debug(RIG_DEBUG_TRACE,
3003 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
3004 gFnLevel, __func__, __FILE__, __LINE__, pRig);
3005
3006 // Check Params
3007
3008 if (pRig == NULL)
3009 {
3010 nRC = -RIG_EARG;
3011 }
3012 else
3013 {
3014 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
3015
3016 nRC = adat_transaction(pRig, &adat_cmd_list_get_freq);
3017
3018 *freq = pPriv->nFreq;
3019 }
3020
3021 rig_debug(RIG_DEBUG_TRACE,
3022 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
3023 gFnLevel, __func__, __FILE__, __LINE__, nRC);
3024 gFnLevel--;
3025
3026 return nRC;
3027 }
3028
3029
3030 // ---------------------------------------------------------------------------
3031 // Function adat_set_level
3032 // ---------------------------------------------------------------------------
3033 // Status: IN WORK
adat_set_level(RIG * pRig,vfo_t vfo,setting_t level,value_t val)3034 int adat_set_level(RIG *pRig, vfo_t vfo, setting_t level, value_t val)
3035 {
3036 int nRC = RIG_OK;
3037
3038 gFnLevel++;
3039
3040 rig_debug(RIG_DEBUG_TRACE,
3041 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
3042 gFnLevel, __func__, __FILE__, __LINE__, pRig);
3043
3044 // Check Params
3045
3046 if (pRig == NULL)
3047 {
3048 nRC = -RIG_EARG;
3049 }
3050 else
3051 {
3052 //adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
3053
3054 }
3055
3056 rig_debug(RIG_DEBUG_TRACE,
3057 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
3058 gFnLevel, __func__, __FILE__, __LINE__, nRC);
3059 gFnLevel--;
3060
3061 return nRC;
3062 }
3063
3064
3065 // ---------------------------------------------------------------------------
3066 // Function adat_get_level
3067 // ---------------------------------------------------------------------------
3068 // Status: IN WORK
adat_get_level(RIG * pRig,vfo_t vfo,setting_t level,value_t * val)3069 int adat_get_level(RIG *pRig, vfo_t vfo, setting_t level, value_t *val)
3070 {
3071 int nRC = RIG_OK;
3072
3073 gFnLevel++;
3074
3075 rig_debug(RIG_DEBUG_TRACE,
3076 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
3077 gFnLevel, __func__, __FILE__, __LINE__, pRig);
3078
3079 // Check Params
3080
3081 if (pRig == NULL)
3082 {
3083 nRC = -RIG_EARG;
3084 }
3085 else
3086 {
3087 //adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
3088
3089 }
3090
3091 rig_debug(RIG_DEBUG_TRACE,
3092 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
3093 gFnLevel, __func__, __FILE__, __LINE__, nRC);
3094 gFnLevel--;
3095
3096 return nRC;
3097 }
3098
3099
3100 // ---------------------------------------------------------------------------
3101 // Function adat_set_mode
3102 // ---------------------------------------------------------------------------
3103 // Status: RELEASED
adat_set_mode(RIG * pRig,vfo_t vfo,rmode_t mode,pbwidth_t width)3104 int adat_set_mode(RIG *pRig, vfo_t vfo, rmode_t mode, pbwidth_t width)
3105 {
3106 int nRC;
3107
3108 gFnLevel++;
3109
3110 rig_debug(RIG_DEBUG_TRACE,
3111 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
3112 gFnLevel, __func__, __FILE__, __LINE__, pRig);
3113
3114 // Check Params
3115
3116 if (pRig == NULL)
3117 {
3118 nRC = -RIG_EARG;
3119 }
3120 else
3121 {
3122 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
3123
3124 pPriv->nRIGMode = mode;
3125 adat_vfo_rnr2anr(vfo, &(pPriv->nCurrentVFO));
3126
3127 if (width != RIG_PASSBAND_NOCHANGE)
3128 {
3129 if (width == RIG_PASSBAND_NORMAL)
3130 {
3131 width = rig_passband_normal(pRig, mode);
3132 }
3133
3134 pPriv->nWidth = width;
3135 }
3136
3137 nRC = adat_transaction(pRig, &adat_cmd_list_set_mode);
3138 }
3139
3140 rig_debug(RIG_DEBUG_TRACE,
3141 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
3142 gFnLevel, __func__, __FILE__, __LINE__, nRC);
3143 gFnLevel--;
3144
3145 return nRC;
3146 }
3147
3148
3149 // ---------------------------------------------------------------------------
3150 // Function adat_get_mode
3151 // ---------------------------------------------------------------------------
3152 // Status: RELEASED
adat_get_mode(RIG * pRig,vfo_t vfo,rmode_t * mode,pbwidth_t * width)3153 int adat_get_mode(RIG *pRig, vfo_t vfo, rmode_t *mode, pbwidth_t *width)
3154 {
3155 int nRC = RIG_OK;
3156
3157 gFnLevel++;
3158
3159 rig_debug(RIG_DEBUG_TRACE,
3160 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
3161 gFnLevel, __func__, __FILE__, __LINE__, pRig);
3162
3163 // Check Params
3164
3165 if (pRig == NULL)
3166 {
3167 nRC = -RIG_EARG;
3168 }
3169 else
3170 {
3171 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
3172
3173 nRC = adat_transaction(pRig, &adat_cmd_list_get_mode);
3174
3175 if (nRC == RIG_OK)
3176 {
3177 *mode = pPriv->nRIGMode;
3178 *width = pPriv->nWidth;
3179 }
3180 }
3181
3182 rig_debug(RIG_DEBUG_TRACE,
3183 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
3184 gFnLevel, __func__, __FILE__, __LINE__, nRC);
3185 gFnLevel--;
3186
3187 return nRC;
3188 }
3189
3190
3191 // ---------------------------------------------------------------------------
3192 // Function adat_get_vfo
3193 // ---------------------------------------------------------------------------
3194 // Status: RELEASED
adat_get_vfo(RIG * pRig,vfo_t * vfo)3195 int adat_get_vfo(RIG *pRig, vfo_t *vfo)
3196 {
3197 int nRC = RIG_OK;
3198
3199 gFnLevel++;
3200
3201 rig_debug(RIG_DEBUG_TRACE,
3202 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
3203 gFnLevel, __func__, __FILE__, __LINE__, pRig);
3204
3205 // Check Params
3206
3207 if (pRig == NULL)
3208 {
3209 nRC = -RIG_EARG;
3210 }
3211 else
3212 {
3213 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
3214
3215 nRC = adat_transaction(pRig, &adat_cmd_list_get_vfo);
3216
3217 *vfo = pPriv->nRIGVFONr;
3218 }
3219
3220 rig_debug(RIG_DEBUG_TRACE,
3221 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
3222 gFnLevel, __func__, __FILE__, __LINE__, nRC);
3223 gFnLevel--;
3224
3225 return nRC;
3226 }
3227
3228
3229 // ---------------------------------------------------------------------------
3230 // Function adat_set_vfo
3231 // ---------------------------------------------------------------------------
3232 // Status: RELEASED
adat_set_vfo(RIG * pRig,vfo_t vfo)3233 int adat_set_vfo(RIG *pRig, vfo_t vfo)
3234 {
3235 int nRC = RIG_OK;
3236
3237 gFnLevel++;
3238
3239 rig_debug(RIG_DEBUG_TRACE,
3240 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
3241 gFnLevel, __func__, __FILE__, __LINE__, pRig);
3242
3243 // Check Params
3244
3245 if (pRig == NULL)
3246 {
3247 nRC = -RIG_EARG;
3248 }
3249 else
3250 {
3251 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
3252
3253 nRC = adat_vfo_rnr2anr(vfo, &(pPriv->nCurrentVFO));
3254
3255 if (nRC == RIG_OK)
3256 {
3257 nRC = adat_transaction(pRig, &adat_cmd_list_set_vfo);
3258 }
3259 }
3260
3261 rig_debug(RIG_DEBUG_TRACE,
3262 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
3263 gFnLevel, __func__, __FILE__, __LINE__, nRC);
3264 gFnLevel--;
3265
3266 return nRC;
3267 }
3268
3269
3270 // ---------------------------------------------------------------------------
3271 // Function adat_get_ptt
3272 // ---------------------------------------------------------------------------
3273 // Status: RELEASED
adat_get_ptt(RIG * pRig,vfo_t vfo,ptt_t * ptt)3274 int adat_get_ptt(RIG *pRig, vfo_t vfo, ptt_t *ptt)
3275 {
3276 int nRC = RIG_OK;
3277
3278 gFnLevel++;
3279
3280 rig_debug(RIG_DEBUG_TRACE,
3281 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
3282 gFnLevel, __func__, __FILE__, __LINE__, pRig);
3283
3284 // Check Params
3285
3286 if (pRig == NULL)
3287 {
3288 nRC = -RIG_EARG;
3289 }
3290 else
3291 {
3292 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
3293
3294 nRC = adat_transaction(pRig, &adat_cmd_list_get_ptt);
3295
3296 *ptt = pPriv->nRIGPTTStatus;
3297 }
3298
3299 rig_debug(RIG_DEBUG_TRACE,
3300 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
3301 gFnLevel, __func__, __FILE__, __LINE__, nRC);
3302 gFnLevel--;
3303
3304 return nRC;
3305 }
3306
3307
3308 // ---------------------------------------------------------------------------
3309 // Function adat_set_ptt
3310 // ---------------------------------------------------------------------------
3311 // Status: RELEASED
adat_set_ptt(RIG * pRig,vfo_t vfo,ptt_t ptt)3312 int adat_set_ptt(RIG *pRig, vfo_t vfo, ptt_t ptt)
3313 {
3314 int nRC = RIG_OK;
3315
3316 gFnLevel++;
3317
3318 rig_debug(RIG_DEBUG_TRACE,
3319 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
3320 gFnLevel, __func__, __FILE__, __LINE__, pRig);
3321
3322 // Check Params
3323
3324 if (pRig == NULL)
3325 {
3326 nRC = -RIG_EARG;
3327 }
3328 else
3329 {
3330 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
3331
3332 switch (ptt)
3333 {
3334 case RIG_PTT_ON:
3335 pPriv->nOpCode = ADAT_OPCODE_PTT_SWITCH_ON;
3336 break;
3337
3338 case RIG_PTT_OFF:
3339 pPriv->nOpCode = ADAT_OPCODE_PTT_SWITCH_OFF;
3340 break;
3341
3342 default:
3343 nRC = -RIG_EINVAL;
3344 break;
3345 }
3346
3347 if (nRC == RIG_OK)
3348 {
3349 nRC = adat_transaction(pRig, &adat_cmd_list_set_ptt);
3350 }
3351 }
3352
3353 rig_debug(RIG_DEBUG_TRACE,
3354 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
3355 gFnLevel, __func__, __FILE__, __LINE__, nRC);
3356 gFnLevel--;
3357
3358 return nRC;
3359 }
3360
3361
3362 // ---------------------------------------------------------------------------
3363 // Function adat_power2mW
3364 // ---------------------------------------------------------------------------
3365 // Status: RELEASED
adat_power2mW(RIG * pRig,unsigned int * mwpower,float power,freq_t freq,rmode_t mode)3366 int adat_power2mW(RIG *pRig,
3367 unsigned int *mwpower,
3368 float power,
3369 freq_t freq,
3370 rmode_t mode)
3371 {
3372 int nRC = RIG_OK;
3373
3374 gFnLevel++;
3375
3376 rig_debug(RIG_DEBUG_TRACE,
3377 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
3378 gFnLevel, __func__, __FILE__, __LINE__, pRig);
3379
3380 // Check Params
3381
3382 if ((pRig == NULL) || (mwpower == NULL))
3383 {
3384 nRC = -RIG_EARG;
3385 }
3386 else
3387 {
3388 *mwpower = power * ADAT_MAX_POWER_IN_mW;
3389 }
3390
3391 rig_debug(RIG_DEBUG_TRACE,
3392 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
3393 gFnLevel, __func__, __FILE__, __LINE__, nRC);
3394 gFnLevel--;
3395
3396 return nRC;
3397 }
3398
3399
3400 // ---------------------------------------------------------------------------
3401 // Function adat_mW2power
3402 // ---------------------------------------------------------------------------
3403 // Status: RELEASED
adat_mW2power(RIG * pRig,float * power,unsigned int mwpower,freq_t freq,rmode_t mode)3404 int adat_mW2power(RIG *pRig,
3405 float *power,
3406 unsigned int mwpower,
3407 freq_t freq,
3408 rmode_t mode)
3409 {
3410 int nRC = RIG_OK;
3411
3412 gFnLevel++;
3413
3414 rig_debug(RIG_DEBUG_TRACE,
3415 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
3416 gFnLevel, __func__, __FILE__, __LINE__, pRig);
3417
3418 // Check Params
3419
3420 if ((pRig == NULL) || (power == NULL))
3421 {
3422 nRC = -RIG_EARG;
3423 }
3424 else
3425 {
3426 *power = mwpower / ((float)ADAT_MAX_POWER_IN_mW);
3427 }
3428
3429 rig_debug(RIG_DEBUG_TRACE,
3430 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
3431 gFnLevel, __func__, __FILE__, __LINE__, nRC);
3432 gFnLevel--;
3433
3434 return nRC;
3435 }
3436
3437
3438 // ---------------------------------------------------------------------------
3439 // Function adat_get_powerstat
3440 // ---------------------------------------------------------------------------
3441 // Status: RELEASED
adat_get_powerstat(RIG * pRig,powerstat_t * status)3442 int adat_get_powerstat(RIG *pRig, powerstat_t *status)
3443 {
3444 int nRC = RIG_OK;
3445
3446 gFnLevel++;
3447
3448 rig_debug(RIG_DEBUG_TRACE,
3449 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
3450 gFnLevel, __func__, __FILE__, __LINE__, pRig);
3451
3452 // Check Params
3453
3454 if (pRig == NULL)
3455 {
3456 nRC = -RIG_EARG;
3457 }
3458 else
3459 {
3460 //adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
3461
3462 nRC = adat_transaction(pRig, &adat_cmd_list_get_powerstatus);
3463
3464 // nRC < 0 -> Power is off.
3465
3466 if (nRC == RIG_OK)
3467 {
3468 *status = RIG_POWER_ON;
3469 }
3470 else
3471 {
3472 *status = RIG_POWER_OFF;
3473 nRC = RIG_OK;
3474 }
3475 }
3476
3477 rig_debug(RIG_DEBUG_TRACE,
3478 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
3479 gFnLevel, __func__, __FILE__, __LINE__, nRC);
3480 gFnLevel--;
3481
3482 return nRC;
3483 }
3484
3485
3486 // ---------------------------------------------------------------------------
3487 // Function adat_set_conf
3488 // ---------------------------------------------------------------------------
3489 // Status: IN WORK
adat_set_conf(RIG * pRig,token_t token,const char * val)3490 int adat_set_conf(RIG *pRig, token_t token, const char *val)
3491 {
3492 int nRC = RIG_OK;
3493
3494 gFnLevel++;
3495
3496 rig_debug(RIG_DEBUG_TRACE,
3497 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
3498 gFnLevel, __func__, __FILE__, __LINE__, pRig);
3499
3500 // Check Params
3501
3502 if (pRig == NULL)
3503 {
3504 nRC = -RIG_EARG;
3505 }
3506 else
3507 {
3508 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
3509
3510 switch (token)
3511 {
3512 case TOKEN_ADAT_PRODUCT_NAME:
3513 if (pPriv->pcProductName != NULL) { free(pPriv->pcProductName); }
3514
3515 pPriv->pcProductName = strdup(val);
3516 break;
3517
3518 default:
3519 nRC = -RIG_EINVAL;
3520 }
3521 }
3522
3523 rig_debug(RIG_DEBUG_TRACE,
3524 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
3525 gFnLevel, __func__, __FILE__, __LINE__, nRC);
3526 gFnLevel--;
3527
3528 return nRC;
3529 }
3530
3531
3532 // ---------------------------------------------------------------------------
3533 // Function adat_get_conf
3534 // ---------------------------------------------------------------------------
3535 // Status: IN WORK
adat_get_conf(RIG * pRig,token_t token,char * val)3536 int adat_get_conf(RIG *pRig, token_t token, char *val)
3537 {
3538 int nRC = RIG_OK;
3539
3540 gFnLevel++;
3541
3542 rig_debug(RIG_DEBUG_TRACE,
3543 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
3544 gFnLevel, __func__, __FILE__, __LINE__, pRig);
3545
3546 // Check Params
3547
3548 if (pRig == NULL)
3549 {
3550 nRC = -RIG_EARG;
3551 }
3552 else
3553 {
3554 adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
3555
3556 switch (token)
3557 {
3558 case TOKEN_ADAT_PRODUCT_NAME:
3559 strcpy(val, pPriv->pcProductName != NULL ? pPriv->pcProductName :
3560 "Unknown product");
3561 break;
3562
3563 default:
3564 nRC = -RIG_EINVAL;
3565 }
3566 }
3567
3568 rig_debug(RIG_DEBUG_TRACE,
3569 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
3570 gFnLevel, __func__, __FILE__, __LINE__, nRC);
3571 gFnLevel--;
3572
3573 return nRC;
3574 }
3575
3576
3577 // ---------------------------------------------------------------------------
3578 // Function adat_reset
3579 // ---------------------------------------------------------------------------
3580 // Status: IN WORK
adat_reset(RIG * pRig,reset_t reset)3581 int adat_reset(RIG *pRig, reset_t reset)
3582 {
3583 int nRC = RIG_OK;
3584
3585 gFnLevel++;
3586
3587 rig_debug(RIG_DEBUG_TRACE,
3588 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
3589 gFnLevel, __func__, __FILE__, __LINE__, pRig);
3590
3591 // Check Params
3592
3593 if (pRig == NULL)
3594 {
3595 nRC = -RIG_EARG;
3596 }
3597 else
3598 {
3599 //adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
3600
3601 }
3602
3603 rig_debug(RIG_DEBUG_TRACE,
3604 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
3605 gFnLevel, __func__, __FILE__, __LINE__, nRC);
3606 gFnLevel--;
3607
3608 return nRC;
3609 }
3610
3611
3612 // ---------------------------------------------------------------------------
3613 // Function adat_handle_event
3614 // ---------------------------------------------------------------------------
3615 // Status: IN WORK
adat_handle_event(RIG * pRig)3616 int adat_handle_event(RIG *pRig)
3617 {
3618 int nRC = RIG_OK;
3619
3620 gFnLevel++;
3621
3622 rig_debug(RIG_DEBUG_TRACE,
3623 "*** ADAT: %d %s (%s:%d): ENTRY. Params: pRig = %p\n",
3624 gFnLevel, __func__, __FILE__, __LINE__, pRig);
3625
3626 // Check Params
3627
3628 if (pRig == NULL)
3629 {
3630 nRC = -RIG_EARG;
3631 }
3632 else
3633 {
3634 //adat_priv_data_ptr pPriv = (adat_priv_data_ptr) pRig->state.priv;
3635 char acBuf[ ADAT_RESPSZ + 1 ];
3636
3637 memset(acBuf, 0, ADAT_RESPSZ + 1);
3638 adat_receive(pRig, acBuf);
3639
3640 rig_debug(RIG_DEBUG_TRACE,
3641 "*** ADAT: %d Event data = \"%s\"\n",
3642 gFnLevel, acBuf);
3643 }
3644
3645 rig_debug(RIG_DEBUG_TRACE,
3646 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
3647 gFnLevel, __func__, __FILE__, __LINE__, nRC);
3648 gFnLevel--;
3649
3650 return nRC;
3651 }
3652
3653
3654 // ---------------------------------------------------------------------------
3655 // initrigs_adat is called by rig_backend_load
3656 // ---------------------------------------------------------------------------
3657 // Status: RELEASED
DECLARE_INITRIG_BACKEND(adat)3658 DECLARE_INITRIG_BACKEND(adat)
3659 {
3660 int nRC = RIG_OK;
3661
3662 gFnLevel++;
3663
3664 #if 0
3665 rig_debug(RIG_DEBUG_TRACE,
3666 "*** ADAT: %d %s (%s:%d): ENTRY.\n",
3667 gFnLevel, __func__, __FILE__, __LINE__);
3668 #endif
3669 rig_register(&adt_200a_caps);
3670
3671 #if 0
3672 rig_debug(RIG_DEBUG_VERBOSE, "ADAT: Rig ADT-200A registered.\n");
3673
3674 rig_debug(RIG_DEBUG_TRACE,
3675 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
3676 gFnLevel, __func__, __FILE__, __LINE__, nRC);
3677 #endif
3678 gFnLevel--;
3679
3680 return nRC;
3681 }
3682
3683
3684 // ---------------------------------------------------------------------------
3685 // proberig_adat
3686 // ---------------------------------------------------------------------------
3687 // Status: UNTESTED
DECLARE_PROBERIG_BACKEND(adat)3688 DECLARE_PROBERIG_BACKEND(adat)
3689 {
3690 int nRC = RIG_OK;
3691
3692 gFnLevel++;
3693
3694 rig_debug(RIG_DEBUG_TRACE,
3695 "*** ADAT: %d %s (%s:%d): ENTRY.\n",
3696 gFnLevel, __func__, __FILE__, __LINE__);
3697
3698 if (!port)
3699 {
3700 return RIG_MODEL_NONE;
3701 }
3702
3703 if (port->type.rig != RIG_PORT_SERIAL)
3704 {
3705 return RIG_MODEL_NONE;
3706 }
3707
3708 port->write_delay = port->post_write_delay = 10;
3709 port->parm.serial.stop_bits = 0;
3710 port->retry = 1;
3711
3712
3713 nRC = serial_open(port);
3714
3715 if (nRC != RIG_OK)
3716 {
3717 nRC = RIG_MODEL_NONE;
3718 }
3719 else
3720 {
3721 char acBuf[ ADAT_RESPSZ + 1 ];
3722 int nRead = 0;
3723
3724 memset(acBuf, 0, ADAT_RESPSZ + 1);
3725
3726 nRC = write_block(port,
3727 ADAT_CMD_DEF_STRING_GET_ID_CODE,
3728 strlen(ADAT_CMD_DEF_STRING_GET_ID_CODE));
3729 nRead = read_string(port, acBuf, ADAT_RESPSZ, ADAT_EOM, 1);
3730 close(port->fd);
3731
3732 if ((nRC != RIG_OK || nRead < 0))
3733 {
3734 nRC = RIG_MODEL_NONE;
3735 }
3736 else
3737 {
3738 rig_debug(RIG_DEBUG_VERBOSE, "ADAT: %d Received ID = %s.",
3739 gFnLevel, acBuf);
3740
3741 nRC = RIG_MODEL_ADT_200A;
3742 }
3743 }
3744
3745 rig_debug(RIG_DEBUG_TRACE,
3746 "*** ADAT: %d %s (%s:%d): EXIT. Return Code = %d\n",
3747 gFnLevel, __func__, __FILE__, __LINE__, nRC);
3748 gFnLevel--;
3749
3750 return nRC;
3751 }
3752
3753 // ---------------------------------------------------------------------------
3754 // END OF FILE
3755 // ---------------------------------------------------------------------------
3756