1 /***************************************************************************
2 hamlibclass.cpp - description
3 -------------------
4 begin : oct 2020
5 copyright : (C) 2020 by Jaime Robles
6 user : jaime@robles.es
7 ***************************************************************************/
8
9 /*****************************************************************************
10 * This file is part of KLog. *
11 * *
12 * KLog is free software: you can redistribute it and/or modify *
13 * it under the terms of the GNU General Public License as published by *
14 * the Free Software Foundation, either version 3 of the License, or *
15 * (at your option) any later version. *
16 * *
17 * KLog is distributed in the hope that it will be useful, *
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
20 * GNU General Public License for more details. *
21 * *
22 * You should have received a copy of the GNU General Public License *
23 * along with KLog. If not, see <https://www.gnu.org/licenses/>. *
24 * *
25 *****************************************************************************/
26
27 #include "hamlibclass.h"
28
29 #include <stdio.h>
30 #include <string.h>
31 #include <unistd.h>
32 #include <stdlib.h>
33
34
HamLibClass(QObject * parent)35 HamLibClass::HamLibClass(QObject *parent) : QObject(parent)
36 {
37 //qDebug() << "HamLibClass::HamLibClass" << QT_ENDL;
38 strings.clear();
39 //qDebug() << "HamLibClass::HamLibClass -10" << QT_ENDL;
40 timer = new QTimer(this);
41 rigLaunched = false;
42 pollInterval = 300;
43 errorCount = 0;
44 readOnlyMode = false;
45 justEmitted = false;
46 freq_old = 0.0;
47 connect(timer, SIGNAL(timeout()), this, SLOT(slotTimer()) );
48 //qDebug() << "HamLibClass::HamLibClass -20" << QT_ENDL;
49 clean();
50 //qDebug() << "HamLibClass::HamLibClass END" << QT_ENDL;
51 }
52
~HamLibClass()53 HamLibClass::~HamLibClass()
54 {
55 if (rigLaunched)
56 {
57 rig_close(my_rig);
58 rig_cleanup(my_rig);
59 rigLaunched = false;
60 }
61 }
62
setPoll(const int _milsecs)63 void HamLibClass::setPoll(const int _milsecs)
64 {
65 if (_milsecs>0)
66 {
67 pollInterval = _milsecs;
68 }
69
70 }
71
readRadio(bool _forceRead)72 bool HamLibClass::readRadio(bool _forceRead)
73 {
74 return readRadioInternal(_forceRead);
75 }
76
readRadioInternal(bool _forceRead)77 bool HamLibClass::readRadioInternal(bool _forceRead)
78 {
79 //qDebug() << Q_FUNC_INFO << QT_ENDL;
80 if (!isRunning())
81 {
82 //qDebug() << Q_FUNC_INFO << ": isn't running" << QT_ENDL;
83 return false;
84 }
85
86 retcode = rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
87
88 if (retcode == RIG_OK)
89 {
90 //qDebug() << Q_FUNC_INFO << ": RIG OK for Freq" << QT_ENDL;
91 errorCount = 0;
92 //qDebug() << "HamLibClass:readRadioInternal: Freq: " << QString::number(freq) << QT_ENDL;
93 if ((freq_old > freq) || (freq_old < freq) || (_forceRead == true))
94 {
95 emit freqChanged(freq/1000000);
96 freq_old = freq;
97 //qDebug() << "HamLibClass::readRadioInternal EMITING; " << QString::number(freq) << QT_ENDL;
98 }
99 //qDebug() << "HamLibClass::readRadioInternal read: " << QString::number(freq) << QT_ENDL;
100 }
101 else
102 {
103 return errorManage(retcode);
104 }
105
106 retcode = rig_get_mode(my_rig, RIG_VFO_CURR, &rmode, &width);
107 if (retcode == RIG_OK)
108 {
109 //qDebug() << Q_FUNC_INFO << ": RIG OK for Mode" << QT_ENDL;
110 errorCount = 0;
111 //qDebug() << "HamLibClass::slotTimer: Mode: " << hamlibMode2Mode(rmode) << QT_ENDL;
112 if ((mode_old != rmode) || (_forceRead == true))
113 {
114 if (justEmitted)
115 {
116 justEmitted = false;
117 return true;
118 }
119 mode_old = rmode;
120 emit modeChanged(hamlibMode2Mode(rmode));
121 justEmitted = true;
122 }
123 }
124 else
125 {
126 return errorManage (retcode);
127 }
128
129 return true;
130 }
131
slotTimer()132 void HamLibClass::slotTimer()
133 {
134 //qDebug() << Q_FUNC_INFO << QT_ENDL;
135 if (!isRunning())
136 {
137 //qDebug() << Q_FUNC_INFO << ": Isn't running..." << QT_ENDL;
138 return;
139 }
140 readRadioInternal(false); // We don't force the radio reading.
141 //qDebug() << Q_FUNC_INFO << " - END" << QT_ENDL;
142 }
143
setMode(const QString & _m)144 void HamLibClass::setMode(const QString &_m)
145 {
146 //qDebug() << "HamLibClass::setMode: " << _m << QT_ENDL;
147 if ((!isRunning()) || (readOnlyMode))
148 {
149 return;
150 }
151
152 // Check if we are already in a mode that should not be changed (CWR should not be changed to CW and so on)
153 retcode = rig_get_mode(my_rig, RIG_VFO_CURR, &rmode, &width);
154 if (RIG_OK != retcode)
155 {
156 //qDebug() << "HamLibClass::setMode: ERROR: Could not get mode: " << QT_ENDL;
157 errorManage (retcode);
158 }
159 QString currentMode = hamlibMode2Mode(rmode);
160 if (_m == currentMode)
161 {
162 return;
163 }
164
165 retcode = rig_set_mode(my_rig, RIG_VFO_CURR, rig_parse_mode(_m.toLocal8Bit()), rig_passband_normal(my_rig, rig_parse_mode(_m.toLocal8Bit())));
166
167 if (RIG_OK != retcode)
168 {
169 //qDebug() << "HamLibClass::setMode: ERROR: Could not set mode: " << _m << QT_ENDL;
170 errorManage (retcode);
171 }
172
173
174 errorCount = 0;
175 //qDebug() << "HamLibClass::setMode - END true " << QT_ENDL;
176 return;
177 }
178 /*
179 rmode_t HamLibClass::mode2HamlibMode(const QString &_m)
180 {
181
182
183 if (_m == "USB")
184 {
185 return RIG_MODE_USB;
186 }
187 else if (_m == "LSB")
188 {
189 return RIG_MODE_LSB;
190 }
191 else if (_m == "CW")
192 {
193 return RIG_MODE_CW;
194 }
195 else if (_m == "FM")
196 {
197 return RIG_MODE_FM;
198 }
199 else if (_m == "")
200 {
201 return RIG_MODE_;
202 }
203 else if (_m == "")
204 {
205 return RIG_MODE_;
206 }
207 else if (_m == "")
208 {
209 return RIG_MODE_;
210 }
211 else if (_m == "")
212 {
213 return RIG_MODE_;
214 }
215 else if (_m == "")
216 {
217 return RIG_MODE_;
218 }
219 else if (_m == "")
220 {
221 return RIG_MODE_;
222 }
223 else if (_m == "")
224 {
225 return RIG_MODE_;
226 }
227 else if (_m == "")
228 {
229 return RIG_MODE_;
230 }
231 else if (_m == "")
232 {
233 return RIG_MODE_;
234 }
235 else if (_m == "")
236 {
237 return RIG_MODE_;
238 }
239 else if (_m == "")
240 {
241 return RIG_MODE_;
242 }
243 else if (_m == "")
244 {
245 return RIG_MODE_;
246 }
247 else if (_m == "")
248 {
249 return RIG_MODE_;
250 }
251 else if (_m == "")
252 {
253 return RIG_MODE_;
254 }
255 else if (_m == "")
256 {
257 return RIG_MODE_;
258 }
259 else if (_m == "")
260 {
261 return RIG_MODE_;
262 }
263 else if (_m == "")
264 {
265 return RIG_MODE_;
266 }
267 else if (_m == "")
268 {
269 return RIG_MODE_;
270 }
271
272
273 return RIG_MODE_NONE;
274 }
275 */
276
isModeADIFMode(const QString & _m)277 bool isModeADIFMode(const QString &_m)
278 {
279 QString _mode;
280 _mode = _m.toUpper();
281 if ((_mode == "AM") || (_mode == "CW") || (_mode == "FM") || (_mode == "LSB") ||
282 (_mode == "USB") || (_mode == "RTTY") )
283 {
284 return true;
285 }
286 else
287 {
288 return false;
289 }
290 }
291
hamlibMode2Mode(rmode_t _rmode)292 QString HamLibClass::hamlibMode2Mode(rmode_t _rmode)
293 {
294
295 switch (_rmode)
296 {
297 case RIG_MODE_NONE:
298 return QString();
299 case RIG_MODE_AM:
300 return "AM";
301 case RIG_MODE_CW:
302 return "CW";
303 case RIG_MODE_USB:
304 return "USB";
305 case RIG_MODE_LSB:
306 return "LSB";
307 case RIG_MODE_RTTY:
308 return "RTTY";
309 case RIG_MODE_FM:
310 return "FM";
311 case RIG_MODE_WFM:
312 return "FM";
313 case RIG_MODE_CWR:
314 return "CW"; //TODO: Check with ADIF
315 case RIG_MODE_RTTYR:
316 return "RTTY"; // TODO Check
317 case RIG_MODE_AMS://TODO: Check with ADIF
318 return "AM";
319 case RIG_MODE_PKTLSB:
320 return "LSB";//TODO: Check with ADIF
321 case RIG_MODE_PKTUSB:
322 return "USB";//TODO: Check with ADIF
323 case RIG_MODE_PKTFM:
324 return "FM";//TODO: Check with ADIF
325 case RIG_MODE_ECSSUSB:
326 return "USB";//TODO: Check with ADIF
327 case RIG_MODE_ECSSLSB:
328 return "LSB";//TODO: Check with ADIF
329 case RIG_MODE_FAX:
330 return "FAX";
331 case RIG_MODE_SAM:
332 return "AM"; //TODO: Check with ADIF
333 case RIG_MODE_SAL:
334 return "LSB";//TODO: Check with ADIF
335 case RIG_MODE_SAH:
336 return "USB";//TODO: Check with ADIF
337 #if defined(Q_OS_OPENBSD)
338 #else
339 case RIG_MODE_FMN:
340 return "FM"; //TODO: Check with ADIF
341 #endif
342 default:
343 return QString();
344 }
345 }
346
stop()347 bool HamLibClass::stop()
348 {
349 //qDebug() << "HamLibClass::stop" << QT_ENDL;
350 timer->stop();
351 if (!isRunning())
352 {
353 return true;
354 }
355 int errorCode = rig_close(my_rig);
356 //qDebug() << "HamLibClass::stop-1" << QT_ENDL;
357
358
359 if (errorCode == RIG_OK)
360 {
361 errorCount = 0;
362 //qDebug() << "HamLibClass::stop: rig_close OK" << QT_ENDL;
363 errorCode = rig_cleanup(my_rig);
364 if (errorCode == RIG_OK)
365 {
366 errorCount = 0;
367 //qDebug() << "HamLibClass::stop: rig_cleanUp OK" << QT_ENDL;
368 rigLaunched = false;
369 //qDebug() << "HamLibClass::stop - true" << QT_ENDL;
370 return true;
371 }
372 else
373 {
374 //return errorManage (retcode);
375 errorCount++;
376 //qDebug() << "HamLibClass::stop: rig_cleanup NOK: " << QString::number(errorCode) << QT_ENDL;
377 }
378 }
379 else
380 {
381 errorCount++;
382 //qDebug() << "HamLibClass::stop: rig_close NOK: " << QString::number(errorCode) << QT_ENDL;
383 }
384 //qDebug() << "HamLibClass::stop - false" << QT_ENDL;
385 return false;
386 }
387
clean()388 void HamLibClass::clean()
389 {
390 //qDebug() << "HamLibClass::Clean" << QT_ENDL;
391 myrig_model = 1; //Dummy equipment
392 //qDebug() << "HamLibClass::Clean 0" << QT_ENDL;
393
394 bauds = 9600;
395 //qDebug() << "HamLibClass::Clean - 1" << QT_ENDL;
396 dataBits = 8;
397 //qDebug() << "HamLibClass::Clean - 2" << QT_ENDL;
398 stopBits = 1;
399 //qDebug() << "HamLibClass::Clean - 3" << QT_ENDL;
400 shandshake = RIG_HANDSHAKE_NONE;
401 //qDebug() << "HamLibClass::Clean - 4" << QT_ENDL;
402 sparity = RIG_PARITY_NONE;
403 //qDebug() << "HamLibClass::Clean - 5" << QT_ENDL;
404
405 //qDebug() << "HamLibClass::Clean - 8" << QT_ENDL;
406 serialPort = QString();
407 sdtr = RIG_SIGNAL_UNSET;
408 //qDebug() << "HamLibClass::Clean - 9" << QT_ENDL;
409 srts = RIG_SIGNAL_UNSET;
410
411 //qDebug() << "HamLibClass::Clean - 10" << QT_ENDL;
412 rigLaunched = false;
413 //qDebug() << "HamLibClass::clean - END" << QT_ENDL;
414 }
415
init(bool _active)416 bool HamLibClass::init(bool _active)
417 {
418 //qDebug()<< "HamLibClass::init: " << QT_ENDL;
419 //qDebug() << "HamLibClass::init: " << getNameFromModelId(myrig_model) << QT_ENDL;
420
421 if (!_active)
422 {
423 //qDebug()<< "HamLibClass::init: Stopping..." << QT_ENDL;
424 //qDebug() << Q_FUNC_INFO << ": Calling stop";
425 return stop();
426 //qDebug() << "HamLibClass::init: Stopped!" << QT_ENDL;
427 }
428
429 if (myrig_model < 0)
430 {
431 //qDebug()<< "HamLibClass::init: Rig Model not valid" << QT_ENDL;
432 return false;
433 }
434
435 rig_set_debug(RIG_DEBUG_NONE);
436 //qDebug()<< "HamLibClass::init: set Debug NONE" << QT_ENDL;
437 my_rig = rig_init(myrig_model);
438 //qDebug()<< "HamLibClass::init: set after init" << QT_ENDL;
439 if (my_rig == nullptr)
440 {
441 //qDebug()<< "HamLibClass::init: Init failed, hamlib returned fail!" << QT_ENDL;
442 return false;
443 }
444 else
445 {
446 //qDebug() << "HamLibClass::init: rig_init went OK!" << QT_ENDL;
447 }
448 // Code of DG1VS (Thank you!)
449 if (myrig_model == RIG_MODEL_NETRIGCTL)
450 {
451 //qDebug() << "HamLibClass::init: RIG_PORT_NETWORK" << QT_ENDL;
452 // network based communication
453 my_rig->state.rigport.type.rig = RIG_PORT_NETWORK;
454 qstrncpy (my_rig->state.rigport.pathname, networkAddress.toLocal8Bit().constData(), FILPATHLEN);
455
456 // the other stuff is hardcoded in hamlib!
457 }
458 else if (myrig_model == RIG_MODEL_FLRIG)
459 {
460 //qDebug() << "HamLibClass::init: RIG_PORT_RPC" << QT_ENDL;
461 my_rig->state.rigport.type.rig = RIG_PORT_RPC;
462 qstrncpy (my_rig->state.rigport.pathname, networkAddress.toLocal8Bit().constData(), FILPATHLEN);
463
464 }
465 else
466 {
467 //qDebug() << "HamLibClass::init: !RIG_PORT_NETWORK" << QT_ENDL;
468 //qDebug() << "HamLibClass::init: serialport2: " << serialPort.toLocal8Bit() << QT_ENDL;
469 my_rig->state.rigport.type.rig = RIG_PORT_SERIAL;
470 //strncpy (my_rig->state.rigport.pathname, serialPort.toLocal8Bit().constData(), FILPATHLEN);
471 qstrncpy (my_rig->state.rigport.pathname, serialPort.toLocal8Bit().constData(), FILPATHLEN);
472
473
474 //qDebug() << "HamLibClass::init: rigport: " << my_rig->state.rigport.pathname << QT_ENDL;
475 my_rig->state.rigport.parm.serial.rate = bauds;
476 //qDebug() << "HamLibClass::init: serial rate: " << QString::number(my_rig->state.rigport.parm.serial.rate) << QT_ENDL;
477 my_rig->state.rigport.parm.serial.data_bits = dataBits;
478 //qDebug() << "HamLibClass::init: data bits: " << QString::number(my_rig->state.rigport.parm.serial.data_bits) << QT_ENDL;
479 my_rig->state.rigport.parm.serial.stop_bits = stopBits;
480 //qDebug() << "HamLibClass::init: stop bits: " << QString::number(my_rig->state.rigport.parm.serial.stop_bits) << QT_ENDL;
481 my_rig->state.rigport.parm.serial.parity = sparity;
482 //qDebug() << "HamLibClass::init: handshake before" << QT_ENDL;
483 my_rig->state.rigport.parm.serial.handshake = shandshake;
484 //qDebug() << "HamLibClass::init: after handshake " << QT_ENDL;
485 // Config done
486 }
487
488 //qDebug() << "HamLibClass::init: after handshake " << QT_ENDL;
489 // Config done
490 retcode = rig_open(my_rig);
491 //qDebug() << "HamLibClass::init: retcode" << QT_ENDL;
492
493 if (retcode != RIG_OK)
494 {
495 //qDebug()<< "HamLibClass::init: Can't open: " << rigerror(retcode) << QT_ENDL;
496
497 rig_cleanup(my_rig);
498 return errorManage (retcode);
499 }
500
501 //qDebug()<< "HamLibClass::init: Rig open!" << QT_ENDL;
502 errorCount = 0;
503 rigLaunched = true;
504 freq_old = 0.0;
505 timer->start(pollInterval);
506
507 //qDebug() << "HamLibClass::init: END TRUE" << QT_ENDL;
508 return true;
509 }
510
isRunning()511 bool HamLibClass::isRunning()
512 {
513 return rigLaunched;
514 }
515
getRigList()516 QStringList HamLibClass::getRigList ()
517 {
518 //qDebug()<< "HamLibClass::getRigList: StringsList before filling it: " << QT_ENDL;
519 // Rutine to fill the rig combo boxes
520 // Do not display debug codes when load the rig's
521 rig_set_debug (RIG_DEBUG_NONE);
522 //qDebug() << "HamLibClass::getRigList-01" << QT_ENDL;
523 // and continue...
524
525 strings.clear();
526 //qDebug()<< "HamLibClass::getRigList: StringsList after cleaning it: " << QT_ENDL;
527 //qDebug() << "HamLibClass::getRigList-02" << QT_ENDL;
528 rig_load_all_backends();
529 //qDebug() << "HamLibClass::getRigList-10" << QT_ENDL;
530 rig_list_foreach (addRigToList, this);
531 //qDebug() << "HamLibClass::getRigList-11" << QT_ENDL;
532
533 strings.sort();
534 //qDebug()<< "HamLibClass::getRigList-12 - Strings length: " << QString::number(strings.length()) << QT_ENDL;
535 return strings;
536 }
537
addRigToList(const struct rig_caps * caps,void * data)538 int HamLibClass::addRigToList (const struct rig_caps *caps, void *data)
539 {
540 //qDebug()<< "HamLibClass::addRigToList" << caps->model_name << QT_ENDL;
541 QString name;
542 //qDebug()<< "HamLibClass::addRigToList-10" << QT_ENDL;
543 //HamLibClass *r = (HamLibClass *) data;
544 HamLibClass *r = static_cast<HamLibClass *> (data);
545
546 //qDebug()<< "HamLibClass::addRigToList-11" << QT_ENDL;
547 name = caps->model_name;
548 //qDebug()<< "HamLibClass::addRigToList-12" << QT_ENDL;
549 r->rigName2RigId[name] = caps->rig_model; // We fill the equivalences between name & Id
550 //qDebug()<< "HamLibClass::addRigToList-13" << QT_ENDL;
551 r->rigId2RigName[caps->rig_model] = name;
552 //qDebug()<< "HamLibClass::addRigToList-14" << QT_ENDL;
553 r->strings << name;
554 //qDebug()<< "HamLibClass::addRigToList-END" << QT_ENDL;
555 return -1; // not 0 --> we want all rigs
556 }
557
getModelIdFromName(const QString & _name)558 int HamLibClass::getModelIdFromName (const QString &_name)
559 {
560 //HamLibClass *r (HamLibClass *) data;
561 int i = -1;
562 i = rigName2RigId[_name];
563 return i;
564 }
565
getNameFromModelId(const int _id)566 QString HamLibClass::getNameFromModelId(const int _id)
567 {
568 //qDebug() << "HamLibClass::getNameFromModelId: " << QString::number(_id) << "/" << rigId2RigName.value(_id)<< QT_ENDL;
569
570 return rigId2RigName.value(_id);
571 }
572
setModelId(const int _id)573 void HamLibClass::setModelId(const int _id)
574 {
575 //qDebug() << "HamLibClass::setModelId: " << QString::number(_id) << QT_ENDL;
576 myrig_model = _id;
577 }
578
setPort(const QString & _port)579 void HamLibClass::setPort(const QString &_port)
580 {
581 //qDebug() << "HamLibClass::setPort: " << _port << QT_ENDL;
582 serialPort = _port;
583 //strncpy (my_rig->state.rigport.pathname, serialPort.toLocal8Bit().constData(), FILPATHLEN);
584 //qstrncpy(myport.pathname, serialPort.toLocal8Bit().constData(), serialPort.length()+1);
585 }
586
setSpeed(const QString & _speed)587 void HamLibClass::setSpeed(const QString &_speed)
588 {
589 bauds = _speed.toInt();
590 }
591
setData(const QString & _data)592 void HamLibClass::setData(const QString &_data)
593 {
594 dataBits = _data.toInt();
595 }
596
setStop(const QString & _stop)597 void HamLibClass::setStop(const QString &_stop)
598 {
599 stopBits = _stop.toInt();
600 }
601
setFlow(const QString & _flow)602 void HamLibClass::setFlow(const QString &_flow)
603 {
604
605 flowControl = _flow.toUpper();
606
607 if (flowControl == "HARDWARE")
608 {
609 shandshake = RIG_HANDSHAKE_HARDWARE;
610 }
611 else if (flowControl == "SOFTWARE")
612 {
613 shandshake = RIG_HANDSHAKE_XONXOFF;
614 }
615 else
616 {
617 shandshake = RIG_HANDSHAKE_NONE;
618 }
619 }
620
setParity(const QString & _parity)621 void HamLibClass::setParity(const QString &_parity)
622 {
623 parity = _parity.toUpper();
624 if (parity == "EVEN")
625 {
626 sparity= RIG_PARITY_EVEN;
627 }
628 else if (parity == "ODD")
629 {
630 sparity = RIG_PARITY_ODD;
631 }
632 else if (parity == "SPACE")
633 {
634 sparity = RIG_PARITY_SPACE;
635 }
636 else if (parity == "MARK")
637 {
638 sparity = RIG_PARITY_MARK;
639 }
640 else
641 {
642 sparity = RIG_PARITY_NONE;
643 }
644 }
645
setFreq(const double _fr)646 void HamLibClass::setFreq(const double _fr)
647 {
648 //qDebug() << "HamLibClass::setFreq: " << QString::number(_fr) << QT_ENDL;
649 if ((!isRunning()) || (readOnlyMode))
650 {
651 return;
652 }
653
654 freq = _fr * 1000000;
655 int retcode = rig_set_freq(my_rig, RIG_VFO_CURR, freq);
656 if (retcode != RIG_OK)
657 {
658 errorManage (retcode);
659 }
660 else
661 {
662 errorCount = 0;
663 //qDebug() << "HamLibClass::setFreq OK: " << QString::number(freq) << QT_ENDL;
664 retcode = rig_get_freq(my_rig, RIG_VFO_CURR, &freq);
665 if (retcode == RIG_OK)
666 {
667 errorCount = 0;
668 //qDebug() << "HamLibClass::setFreq read: " << QString::number(freq) << QT_ENDL;
669 }
670 else
671 {
672 errorManage (retcode);
673 }
674 return;
675 }
676 }
677
setRTS(const QString & _state)678 void HamLibClass::setRTS(const QString &_state)
679 {
680
681 if (shandshake == RIG_HANDSHAKE_HARDWARE)
682 { // Note: An attempt to control the RTS signal in the HardwareControl mode will fail with error code
683 // set to UnsupportedOperationError, because the signal is automatically controlled by the driver.
684 return;
685 }
686
687 if (_state.toUpper() == "TRUE")
688 {
689 srts = RIG_SIGNAL_ON;
690 }
691 else
692 {
693 srts = RIG_SIGNAL_OFF;
694 }
695 }
696
setDTR(const QString & _state)697 void HamLibClass::setDTR(const QString &_state)
698 {
699
700 if (_state.toUpper() == "TRUE")
701 {
702 sdtr = RIG_SIGNAL_ON;
703 }
704 else
705 {
706 sdtr = RIG_SIGNAL_OFF;
707 }
708 }
709
checkErrorCountAndStop()710 void HamLibClass::checkErrorCountAndStop()
711 {
712 //qDebug() << Q_FUNC_INFO;
713 if (errorCount > 10)
714 {
715 //qDebug() << Q_FUNC_INFO << ": Error>10 - calling stop";
716 stop();
717 }
718 }
719
setReadOnly(const bool _r)720 void HamLibClass::setReadOnly(const bool _r)
721 {
722 readOnlyMode = _r;
723 }
724
setNetworkAddress(const QString & _address)725 void HamLibClass::setNetworkAddress(const QString &_address)
726 {
727 networkAddress = _address;
728 }
729
setNetworkPort(const int _port)730 void HamLibClass::setNetworkPort(const int _port)
731 {
732 if ((_port>0) && (_port<65535))
733 {
734 networkPort = _port;
735 }
736 }
737
errorManage(const int _errorcode)738 bool HamLibClass::errorManage(const int _errorcode)
739 {
740 //qDebug() << Q_FUNC_INFO << ": error: " << QString::number(_errorcode);
741
742 if (RIG_OK == _errorcode)
743 {
744 //qDebug() << Q_FUNC_INFO << " - RIG_OK";
745 return true;
746 }
747 switch (_errorcode)
748 {
749
750 case (RIG_EINVAL):
751 //qDebug() << Q_FUNC_INFO << ": Error: 1 invalid parameter";
752 break;
753 case (RIG_ECONF):
754 //qDebug() << Q_FUNC_INFO << ": Error: 2 invalid configuration (serial,..) ";
755 break;
756 case (RIG_ENOMEM):
757 //qDebug() << Q_FUNC_INFO << ": Error: 3 memory shortage";
758 break;
759 case (RIG_ENIMPL):
760 //qDebug() << Q_FUNC_INFO << ": Error: 4 function not implemented, but will be ";
761 break;
762 case (RIG_ETIMEOUT):
763 //qDebug() << Q_FUNC_INFO << ": Error: 5 communication timed ou";
764 break;
765 case (RIG_EIO):
766 //qDebug() << Q_FUNC_INFO << ": Error: 6 IO error, including open failed";
767 break;
768 case (RIG_EINTERNAL):
769 //qDebug() << Q_FUNC_INFO << ": Error: 7 Internal Hamlib error, huh!";
770 break;
771 case (RIG_EPROTO):
772 //qDebug() << Q_FUNC_INFO << ": Error: 9 Command rejected by the rig";
773 break;
774 case (RIG_ETRUNC):
775 //qDebug() << Q_FUNC_INFO << ": Error: 10 Command performed, but arg truncated";
776 break;
777 case (RIG_ENAVAIL):
778 //qDebug() << Q_FUNC_INFO << ": Error: 11 Function not available";
779 break;
780 case (RIG_ENTARGET):
781 //qDebug() << Q_FUNC_INFO << ": Error: 12 VFO not targetable";
782 break;
783 case (RIG_BUSERROR):
784 //qDebug() << Q_FUNC_INFO << ": Error: 13 Error talking on the bus";
785 break;
786 case (RIG_BUSBUSY):
787 //qDebug() << Q_FUNC_INFO << ": Error: 14 Collision on the bus";
788 break;
789 case (RIG_EARG):
790 //qDebug() << Q_FUNC_INFO << ": Error: 15 NULL RIG handle or any invalid pointer parameter in get arg";
791 break;
792 case (RIG_EVFO):
793 //qDebug() << Q_FUNC_INFO << ": Error: 16 Invalid VFO";
794 break;
795 case (RIG_EDOM):
796 //qDebug() << Q_FUNC_INFO << ": Error: 17 Argument out of domain of func";
797 break;
798 default:
799 //qDebug() << Q_FUNC_INFO << ": Error: ?? Unknown error";
800 break;
801 }
802 if (_errorcode == RIG_EINVAL || _errorcode == RIG_ENIMPL || _errorcode == RIG_ERJCTED \
803 || _errorcode == RIG_ETRUNC || _errorcode == RIG_ENAVAIL || _errorcode == RIG_ENTARGET \
804 || _errorcode == RIG_EVFO || _errorcode == RIG_EDOM)
805 {
806 //qDebug() << Q_FUNC_INFO << ": Soft error: Invalid parameters - No reason to re-initialize the hardware";
807 }
808
809
810 if (errorCount<10)
811 {
812 errorCount++;
813 //qDebug() << Q_FUNC_INFO << ": RIG NOK for Mode: - " << QString::number(errorCount) << QT_ENDL;
814 return false;
815 }
816 else
817 {
818 //qDebug() << Q_FUNC_INFO << ": RIG NOK for Mode" << QT_ENDL;
819 //qDebug() << Q_FUNC_INFO << ": Calling stop";
820 stop();
821 return false;
822 }
823 }
824