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