2016-01-14 18:45:04 +00:00
|
|
|
/*
|
2019-01-07 11:03:37 +00:00
|
|
|
* Copyright (C) 2015-2019 by Jonathan Naylor G4KLX
|
2016-01-14 18:45:04 +00:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "MMDVMHost.h"
|
2016-12-21 19:58:46 +00:00
|
|
|
#include "RSSIInterpolator.h"
|
2016-10-06 17:38:16 +00:00
|
|
|
#include "SerialController.h"
|
2016-01-14 18:45:04 +00:00
|
|
|
#include "Version.h"
|
|
|
|
#include "StopWatch.h"
|
|
|
|
#include "Defines.h"
|
2016-06-06 16:40:27 +00:00
|
|
|
#include "Thread.h"
|
2016-10-06 17:38:16 +00:00
|
|
|
#include "Log.h"
|
2017-03-10 04:22:33 +00:00
|
|
|
#include "GitVersion.h"
|
2016-01-14 18:45:04 +00:00
|
|
|
|
|
|
|
#include <cstdio>
|
2016-04-04 18:03:38 +00:00
|
|
|
#include <vector>
|
2016-01-14 18:45:04 +00:00
|
|
|
|
2018-07-04 18:00:51 +00:00
|
|
|
#include <cstdlib>
|
2016-01-14 18:45:04 +00:00
|
|
|
|
2016-01-14 19:58:16 +00:00
|
|
|
#if !defined(_WIN32) && !defined(_WIN64)
|
2016-05-05 17:06:05 +00:00
|
|
|
#include <sys/types.h>
|
2016-01-14 18:45:04 +00:00
|
|
|
#include <unistd.h>
|
|
|
|
#include <signal.h>
|
2016-05-03 22:01:49 +00:00
|
|
|
#include <fcntl.h>
|
2016-05-04 19:06:15 +00:00
|
|
|
#include <pwd.h>
|
2016-05-03 22:01:49 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(_WIN32) || defined(_WIN64)
|
2016-05-05 16:56:18 +00:00
|
|
|
const char* DEFAULT_INI_FILE = "MMDVM.ini";
|
2016-05-03 22:01:49 +00:00
|
|
|
#else
|
2016-05-04 20:00:12 +00:00
|
|
|
const char* DEFAULT_INI_FILE = "/etc/MMDVM.ini";
|
2016-01-14 18:45:04 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
static bool m_killed = false;
|
2016-05-03 22:01:49 +00:00
|
|
|
static int m_signal = 0;
|
2016-01-14 18:45:04 +00:00
|
|
|
|
2016-01-14 19:58:16 +00:00
|
|
|
#if !defined(_WIN32) && !defined(_WIN64)
|
2016-05-03 22:01:49 +00:00
|
|
|
static void sigHandler(int signum)
|
2016-01-14 18:45:04 +00:00
|
|
|
{
|
2017-05-03 13:53:48 +00:00
|
|
|
m_killed = true;
|
|
|
|
m_signal = signum;
|
2016-01-14 18:45:04 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2016-01-23 17:54:23 +00:00
|
|
|
const char* HEADER1 = "This software is for use on amateur radio networks only,";
|
|
|
|
const char* HEADER2 = "it is to be used for educational purposes only. Its use on";
|
|
|
|
const char* HEADER3 = "commercial networks is strictly prohibited.";
|
2018-01-11 19:35:33 +00:00
|
|
|
const char* HEADER4 = "Copyright(C) 2015-2018 by Jonathan Naylor, G4KLX and others";
|
2016-01-14 18:45:04 +00:00
|
|
|
|
|
|
|
int main(int argc, char** argv)
|
|
|
|
{
|
2017-05-03 13:53:48 +00:00
|
|
|
const char* iniFile = DEFAULT_INI_FILE;
|
|
|
|
if (argc > 1) {
|
|
|
|
for (int currentArg = 1; currentArg < argc; ++currentArg) {
|
|
|
|
std::string arg = argv[currentArg];
|
|
|
|
if ((arg == "-v") || (arg == "--version")) {
|
|
|
|
::fprintf(stdout, "MMDVMHost version %s git #%.7s\n", VERSION, gitversion);
|
|
|
|
return 0;
|
|
|
|
} else if (arg.substr(0,1) == "-") {
|
|
|
|
::fprintf(stderr, "Usage: MMDVMHost [-v|--version] [filename]\n");
|
|
|
|
return 1;
|
|
|
|
} else {
|
|
|
|
iniFile = argv[currentArg];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-01-14 18:45:04 +00:00
|
|
|
|
2016-01-14 19:58:16 +00:00
|
|
|
#if !defined(_WIN32) && !defined(_WIN64)
|
2017-06-08 09:17:00 +00:00
|
|
|
::signal(SIGINT, sigHandler);
|
2017-05-03 13:53:48 +00:00
|
|
|
::signal(SIGTERM, sigHandler);
|
|
|
|
::signal(SIGHUP, sigHandler);
|
2016-01-14 18:45:04 +00:00
|
|
|
#endif
|
|
|
|
|
2017-05-03 13:53:48 +00:00
|
|
|
int ret = 0;
|
2016-01-14 18:45:04 +00:00
|
|
|
|
2017-05-03 13:53:48 +00:00
|
|
|
do {
|
|
|
|
m_signal = 0;
|
2016-01-14 18:45:04 +00:00
|
|
|
|
2017-05-03 13:53:48 +00:00
|
|
|
CMMDVMHost* host = new CMMDVMHost(std::string(iniFile));
|
|
|
|
ret = host->run();
|
2016-05-03 22:01:49 +00:00
|
|
|
|
2017-05-03 13:53:48 +00:00
|
|
|
delete host;
|
2016-05-04 05:35:20 +00:00
|
|
|
|
2017-06-08 09:17:00 +00:00
|
|
|
if (m_signal == 2)
|
2017-06-08 10:44:01 +00:00
|
|
|
::LogInfo("MMDVMHost-%s exited on receipt of SIGINT", VERSION);
|
2017-06-08 09:17:00 +00:00
|
|
|
|
2017-05-03 13:53:48 +00:00
|
|
|
if (m_signal == 15)
|
2017-06-08 10:44:01 +00:00
|
|
|
::LogInfo("MMDVMHost-%s exited on receipt of SIGTERM", VERSION);
|
2016-05-04 05:35:20 +00:00
|
|
|
|
2017-05-03 13:53:48 +00:00
|
|
|
if (m_signal == 1)
|
2017-06-08 09:17:00 +00:00
|
|
|
::LogInfo("MMDVMHost-%s is restarting on receipt of SIGHUP", VERSION);
|
2017-05-03 13:53:48 +00:00
|
|
|
} while (m_signal == 1);
|
2016-05-03 22:01:49 +00:00
|
|
|
|
2017-05-03 13:53:48 +00:00
|
|
|
::LogFinalise();
|
2016-01-14 18:45:04 +00:00
|
|
|
|
2017-05-03 13:53:48 +00:00
|
|
|
return ret;
|
2016-01-14 18:45:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
CMMDVMHost::CMMDVMHost(const std::string& confFile) :
|
|
|
|
m_conf(confFile),
|
|
|
|
m_modem(NULL),
|
2019-01-10 09:05:15 +00:00
|
|
|
m_dstar(NULL),
|
|
|
|
m_dmr(NULL),
|
|
|
|
m_ysf(NULL),
|
|
|
|
m_p25(NULL),
|
|
|
|
m_nxdn(NULL),
|
2019-01-10 14:03:23 +00:00
|
|
|
m_pocsag(NULL),
|
2016-01-25 21:00:19 +00:00
|
|
|
m_dstarNetwork(NULL),
|
2016-01-14 18:45:04 +00:00
|
|
|
m_dmrNetwork(NULL),
|
2016-05-16 20:57:32 +00:00
|
|
|
m_ysfNetwork(NULL),
|
2016-09-14 06:41:37 +00:00
|
|
|
m_p25Network(NULL),
|
2018-01-15 21:03:34 +00:00
|
|
|
m_nxdnNetwork(NULL),
|
2018-06-07 17:46:03 +00:00
|
|
|
m_pocsagNetwork(NULL),
|
2016-01-14 18:45:04 +00:00
|
|
|
m_display(NULL),
|
2016-11-03 19:07:44 +00:00
|
|
|
m_ump(NULL),
|
2016-02-02 18:17:36 +00:00
|
|
|
m_mode(MODE_IDLE),
|
2017-09-01 08:25:54 +00:00
|
|
|
m_dstarRFModeHang(10U),
|
|
|
|
m_dmrRFModeHang(10U),
|
|
|
|
m_ysfRFModeHang(10U),
|
|
|
|
m_p25RFModeHang(10U),
|
2018-01-11 19:35:33 +00:00
|
|
|
m_nxdnRFModeHang(10U),
|
2017-09-01 08:25:54 +00:00
|
|
|
m_dstarNetModeHang(3U),
|
|
|
|
m_dmrNetModeHang(3U),
|
|
|
|
m_ysfNetModeHang(3U),
|
|
|
|
m_p25NetModeHang(3U),
|
2018-01-11 19:35:33 +00:00
|
|
|
m_nxdnNetModeHang(3U),
|
2018-06-07 17:46:03 +00:00
|
|
|
m_pocsagNetModeHang(3U),
|
2016-02-02 18:17:36 +00:00
|
|
|
m_modeTimer(1000U),
|
2016-05-05 16:56:18 +00:00
|
|
|
m_dmrTXTimer(1000U),
|
2016-05-09 20:55:44 +00:00
|
|
|
m_cwIdTimer(1000U),
|
2016-03-07 19:45:19 +00:00
|
|
|
m_duplex(false),
|
2016-06-22 17:03:56 +00:00
|
|
|
m_timeout(180U),
|
2016-01-14 18:45:04 +00:00
|
|
|
m_dstarEnabled(false),
|
|
|
|
m_dmrEnabled(false),
|
2016-05-09 20:55:44 +00:00
|
|
|
m_ysfEnabled(false),
|
2016-09-08 17:38:59 +00:00
|
|
|
m_p25Enabled(false),
|
2018-01-11 19:35:33 +00:00
|
|
|
m_nxdnEnabled(false),
|
2018-06-07 17:46:03 +00:00
|
|
|
m_pocsagEnabled(false),
|
2016-10-17 17:01:38 +00:00
|
|
|
m_cwIdTime(0U),
|
2018-01-17 21:21:25 +00:00
|
|
|
m_dmrLookup(NULL),
|
|
|
|
m_nxdnLookup(NULL),
|
2017-04-10 16:55:53 +00:00
|
|
|
m_callsign(),
|
2017-08-19 15:23:37 +00:00
|
|
|
m_id(0U),
|
2018-10-10 19:05:24 +00:00
|
|
|
m_cwCallsign(),
|
|
|
|
m_lockFileEnabled(false),
|
2018-11-06 12:14:57 +00:00
|
|
|
m_lockFileName(),
|
2019-01-10 09:05:15 +00:00
|
|
|
m_mobileGPS(NULL),
|
2019-01-22 14:38:38 +00:00
|
|
|
m_remoteControl(NULL),
|
|
|
|
m_fixedMode(false)
|
2016-01-14 18:45:04 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
CMMDVMHost::~CMMDVMHost()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
int CMMDVMHost::run()
|
|
|
|
{
|
|
|
|
bool ret = m_conf.read();
|
|
|
|
if (!ret) {
|
2016-05-14 22:26:16 +00:00
|
|
|
::fprintf(stderr, "MMDVMHost: cannot read the .ini file\n");
|
2016-01-14 18:45:04 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2016-05-03 22:01:49 +00:00
|
|
|
#if !defined(_WIN32) && !defined(_WIN64)
|
|
|
|
bool m_daemon = m_conf.getDaemon();
|
|
|
|
if (m_daemon) {
|
|
|
|
// Create new process
|
|
|
|
pid_t pid = ::fork();
|
2016-05-04 19:06:15 +00:00
|
|
|
if (pid == -1) {
|
2018-06-18 17:18:09 +00:00
|
|
|
::fprintf(stderr, "Couldn't fork() , exiting\n");
|
2017-05-03 13:53:48 +00:00
|
|
|
return -1;
|
|
|
|
} else if (pid != 0) {
|
2016-05-03 22:01:49 +00:00
|
|
|
exit(EXIT_SUCCESS);
|
2017-05-03 13:53:48 +00:00
|
|
|
}
|
2016-05-03 22:01:49 +00:00
|
|
|
|
|
|
|
// Create new session and process group
|
2016-05-04 19:06:15 +00:00
|
|
|
if (::setsid() == -1){
|
2018-06-18 17:18:09 +00:00
|
|
|
::fprintf(stderr, "Couldn't setsid(), exiting\n");
|
2017-05-03 13:53:48 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2016-05-03 22:01:49 +00:00
|
|
|
|
|
|
|
// Set the working directory to the root directory
|
2016-05-04 19:06:15 +00:00
|
|
|
if (::chdir("/") == -1){
|
2018-06-18 17:18:09 +00:00
|
|
|
::fprintf(stderr, "Couldn't cd /, exiting\n");
|
2017-05-03 13:53:48 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2016-05-03 22:01:49 +00:00
|
|
|
|
2018-07-03 02:01:19 +00:00
|
|
|
#if !defined(HD44780) && !defined(OLED) && !defined(_OPENWRT)
|
2018-06-18 17:18:09 +00:00
|
|
|
// If we are currently root...
|
2016-05-04 19:06:15 +00:00
|
|
|
if (getuid() == 0) {
|
2016-05-05 17:06:05 +00:00
|
|
|
struct passwd* user = ::getpwnam("mmdvm");
|
|
|
|
if (user == NULL) {
|
2018-06-18 17:18:09 +00:00
|
|
|
::fprintf(stderr, "Could not get the mmdvm user, exiting\n");
|
2016-05-05 17:06:05 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2017-05-03 13:53:48 +00:00
|
|
|
|
2016-05-05 17:06:05 +00:00
|
|
|
uid_t mmdvm_uid = user->pw_uid;
|
2017-05-03 13:53:48 +00:00
|
|
|
gid_t mmdvm_gid = user->pw_gid;
|
|
|
|
|
2018-06-18 17:18:09 +00:00
|
|
|
// Set user and group ID's to mmdvm:mmdvm
|
2017-05-03 13:53:48 +00:00
|
|
|
if (::setgid(mmdvm_gid) != 0) {
|
2018-06-18 17:18:09 +00:00
|
|
|
::fprintf(stderr, "Could not set mmdvm GID, exiting\n");
|
2017-05-03 13:53:48 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (::setuid(mmdvm_uid) != 0) {
|
2018-06-18 17:18:09 +00:00
|
|
|
::fprintf(stderr, "Could not set mmdvm UID, exiting\n");
|
2017-05-03 13:53:48 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2018-07-19 13:09:00 +00:00
|
|
|
// Double check it worked (AKA Paranoia)
|
2017-05-03 13:53:48 +00:00
|
|
|
if (::setuid(0) != -1){
|
2018-06-18 17:18:09 +00:00
|
|
|
::fprintf(stderr, "It's possible to regain root - something is wrong!, exiting\n");
|
2017-05-03 13:53:48 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2016-05-04 19:06:15 +00:00
|
|
|
}
|
2016-05-03 22:01:49 +00:00
|
|
|
}
|
2017-05-03 21:39:11 +00:00
|
|
|
#else
|
2018-07-03 02:01:19 +00:00
|
|
|
::fprintf(stderr, "Dropping root permissions in daemon mode is disabled.\n");
|
2017-05-03 21:39:11 +00:00
|
|
|
}
|
2016-05-05 08:47:54 +00:00
|
|
|
#endif
|
2016-05-03 22:01:49 +00:00
|
|
|
#endif
|
|
|
|
|
2018-06-18 17:18:09 +00:00
|
|
|
ret = ::LogInitialise(m_conf.getLogFilePath(), m_conf.getLogFileRoot(), m_conf.getLogFileLevel(), m_conf.getLogDisplayLevel());
|
|
|
|
if (!ret) {
|
|
|
|
::fprintf(stderr, "MMDVMHost: unable to open the log file\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2018-07-26 17:43:57 +00:00
|
|
|
#if !defined(_WIN32) && !defined(_WIN64)
|
|
|
|
if (m_daemon) {
|
|
|
|
::close(STDIN_FILENO);
|
|
|
|
::close(STDOUT_FILENO);
|
2018-07-24 04:29:05 +00:00
|
|
|
::close(STDERR_FILENO);
|
2018-07-26 17:43:57 +00:00
|
|
|
}
|
|
|
|
#endif
|
2018-06-18 17:18:09 +00:00
|
|
|
|
2016-01-14 18:45:04 +00:00
|
|
|
LogInfo(HEADER1);
|
|
|
|
LogInfo(HEADER2);
|
|
|
|
LogInfo(HEADER3);
|
2016-01-23 17:54:23 +00:00
|
|
|
LogInfo(HEADER4);
|
2016-01-14 18:45:04 +00:00
|
|
|
|
|
|
|
LogMessage("MMDVMHost-%s is starting", VERSION);
|
2017-03-09 20:55:41 +00:00
|
|
|
LogMessage("Built %s %s (GitID #%.7s)", __TIME__, __DATE__, gitversion);
|
2016-01-14 18:45:04 +00:00
|
|
|
|
|
|
|
readParams();
|
|
|
|
|
|
|
|
ret = createModem();
|
|
|
|
if (!ret)
|
|
|
|
return 1;
|
|
|
|
|
2016-11-03 19:07:44 +00:00
|
|
|
if (m_conf.getUMPEnabled()) {
|
|
|
|
std::string port = m_conf.getUMPPort();
|
|
|
|
|
|
|
|
LogInfo("Universal MMDVM Peripheral");
|
|
|
|
LogInfo(" Port: %s", port.c_str());
|
|
|
|
|
|
|
|
m_ump = new CUMP(port);
|
|
|
|
bool ret = m_ump->open();
|
|
|
|
if (!ret) {
|
|
|
|
delete m_ump;
|
|
|
|
m_ump = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-31 03:36:37 +00:00
|
|
|
m_display = CDisplay::createDisplay(m_conf,m_ump,m_modem);
|
2016-01-14 18:45:04 +00:00
|
|
|
|
2016-01-25 21:00:19 +00:00
|
|
|
if (m_dstarEnabled && m_conf.getDStarNetworkEnabled()) {
|
|
|
|
ret = createDStarNetwork();
|
|
|
|
if (!ret)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2016-01-18 21:24:41 +00:00
|
|
|
if (m_dmrEnabled && m_conf.getDMRNetworkEnabled()) {
|
2016-01-14 18:45:04 +00:00
|
|
|
ret = createDMRNetwork();
|
|
|
|
if (!ret)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2016-05-16 20:57:32 +00:00
|
|
|
if (m_ysfEnabled && m_conf.getFusionNetworkEnabled()) {
|
|
|
|
ret = createYSFNetwork();
|
|
|
|
if (!ret)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2016-09-14 06:41:37 +00:00
|
|
|
if (m_p25Enabled && m_conf.getP25NetworkEnabled()) {
|
|
|
|
ret = createP25Network();
|
|
|
|
if (!ret)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2018-01-15 21:03:34 +00:00
|
|
|
if (m_nxdnEnabled && m_conf.getNXDNNetworkEnabled()) {
|
|
|
|
ret = createNXDNNetwork();
|
|
|
|
if (!ret)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2018-06-07 17:46:03 +00:00
|
|
|
if (m_pocsagEnabled && m_conf.getPOCSAGNetworkEnabled()) {
|
|
|
|
ret = createPOCSAGNetwork();
|
|
|
|
if (!ret)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2018-03-22 07:13:13 +00:00
|
|
|
in_addr transparentAddress;
|
|
|
|
unsigned int transparentPort = 0U;
|
|
|
|
CUDPSocket* transparentSocket = NULL;
|
|
|
|
|
2018-08-13 18:39:16 +00:00
|
|
|
unsigned int sendFrameType = 0U;
|
2018-03-22 07:13:13 +00:00
|
|
|
if (m_conf.getTransparentEnabled()) {
|
|
|
|
std::string remoteAddress = m_conf.getTransparentRemoteAddress();
|
|
|
|
unsigned int remotePort = m_conf.getTransparentRemotePort();
|
|
|
|
unsigned int localPort = m_conf.getTransparentLocalPort();
|
2018-08-13 18:39:16 +00:00
|
|
|
sendFrameType = m_conf.getTransparentSendFrameType();
|
2018-03-22 07:13:13 +00:00
|
|
|
|
|
|
|
LogInfo("Transparent Data");
|
|
|
|
LogInfo(" Remote Address: %s", remoteAddress.c_str());
|
|
|
|
LogInfo(" Remote Port: %u", remotePort);
|
|
|
|
LogInfo(" Local Port: %u", localPort);
|
2018-08-13 18:39:16 +00:00
|
|
|
LogInfo(" Send Frame Type: %u", sendFrameType);
|
2018-03-22 07:13:13 +00:00
|
|
|
|
|
|
|
transparentAddress = CUDPSocket::lookup(remoteAddress);
|
|
|
|
transparentPort = remotePort;
|
|
|
|
|
|
|
|
transparentSocket = new CUDPSocket(localPort);
|
|
|
|
ret = transparentSocket->open();
|
|
|
|
if (!ret) {
|
|
|
|
LogWarning("Could not open the Transparent data socket, disabling");
|
|
|
|
delete transparentSocket;
|
|
|
|
transparentSocket = NULL;
|
2018-09-13 18:35:12 +00:00
|
|
|
sendFrameType=0;
|
2018-03-22 07:13:13 +00:00
|
|
|
}
|
2018-09-13 18:35:12 +00:00
|
|
|
m_modem->setTransparentDataParams(sendFrameType);
|
2018-03-22 07:13:13 +00:00
|
|
|
}
|
|
|
|
|
2018-10-10 19:05:24 +00:00
|
|
|
if (m_conf.getLockFileEnabled()) {
|
2018-10-11 06:50:30 +00:00
|
|
|
m_lockFileEnabled = true;
|
|
|
|
m_lockFileName = m_conf.getLockFileName();
|
|
|
|
|
2018-10-10 19:05:24 +00:00
|
|
|
LogInfo("Lock File Parameters");
|
|
|
|
LogInfo(" Name: %s", m_lockFileName.c_str());
|
2018-10-11 06:50:30 +00:00
|
|
|
|
|
|
|
removeLockFile();
|
2018-10-10 19:05:24 +00:00
|
|
|
}
|
|
|
|
|
2016-05-09 20:55:44 +00:00
|
|
|
if (m_conf.getCWIdEnabled()) {
|
|
|
|
unsigned int time = m_conf.getCWIdTime();
|
2017-04-11 18:26:44 +00:00
|
|
|
m_cwCallsign = m_conf.getCWIdCallsign();
|
2016-05-09 20:55:44 +00:00
|
|
|
|
|
|
|
LogInfo("CW Id Parameters");
|
|
|
|
LogInfo(" Time: %u mins", time);
|
2017-04-11 18:26:44 +00:00
|
|
|
LogInfo(" Callsign: %s", m_cwCallsign.c_str());
|
2016-05-09 20:55:44 +00:00
|
|
|
|
2016-10-17 17:01:38 +00:00
|
|
|
m_cwIdTime = time * 60U;
|
|
|
|
|
|
|
|
m_cwIdTimer.setTimeout(m_cwIdTime / 4U);
|
2016-06-03 14:28:55 +00:00
|
|
|
m_cwIdTimer.start();
|
2016-05-09 20:55:44 +00:00
|
|
|
}
|
|
|
|
|
2017-01-05 19:15:10 +00:00
|
|
|
// For all modes we handle RSSI
|
|
|
|
std::string rssiMappingFile = m_conf.getModemRSSIMappingFile();
|
|
|
|
|
|
|
|
CRSSIInterpolator* rssi = new CRSSIInterpolator;
|
|
|
|
if (!rssiMappingFile.empty()) {
|
|
|
|
LogInfo("RSSI");
|
|
|
|
LogInfo(" Mapping File: %s", rssiMappingFile.c_str());
|
|
|
|
rssi->load(rssiMappingFile);
|
|
|
|
}
|
|
|
|
|
2016-09-12 22:26:05 +00:00
|
|
|
// For DMR and P25 we try to map IDs to callsigns
|
|
|
|
if (m_dmrEnabled || m_p25Enabled) {
|
2016-10-10 18:15:30 +00:00
|
|
|
std::string lookupFile = m_conf.getDMRIdLookupFile();
|
|
|
|
unsigned int reloadTime = m_conf.getDMRIdLookupTime();
|
2016-09-12 22:26:05 +00:00
|
|
|
|
2016-10-10 18:15:30 +00:00
|
|
|
LogInfo("DMR Id Lookups");
|
|
|
|
LogInfo(" File: %s", lookupFile.length() > 0U ? lookupFile.c_str() : "None");
|
|
|
|
if (reloadTime > 0U)
|
|
|
|
LogInfo(" Reload: %u hours", reloadTime);
|
|
|
|
|
2018-01-17 21:21:25 +00:00
|
|
|
m_dmrLookup = new CDMRLookup(lookupFile, reloadTime);
|
|
|
|
m_dmrLookup->read();
|
2016-09-12 22:26:05 +00:00
|
|
|
}
|
|
|
|
|
2016-01-14 18:45:04 +00:00
|
|
|
CStopWatch stopWatch;
|
|
|
|
stopWatch.start();
|
|
|
|
|
2016-01-27 20:01:50 +00:00
|
|
|
if (m_dstarEnabled) {
|
2017-06-14 10:54:44 +00:00
|
|
|
std::string module = m_conf.getDStarModule();
|
|
|
|
bool selfOnly = m_conf.getDStarSelfOnly();
|
2016-04-06 17:46:05 +00:00
|
|
|
std::vector<std::string> blackList = m_conf.getDStarBlackList();
|
2017-06-14 10:54:44 +00:00
|
|
|
bool ackReply = m_conf.getDStarAckReply();
|
|
|
|
unsigned int ackTime = m_conf.getDStarAckTime();
|
2018-09-14 10:30:48 +00:00
|
|
|
bool ackMessage = m_conf.getDStarAckMessage();
|
2017-06-14 10:54:44 +00:00
|
|
|
bool errorReply = m_conf.getDStarErrorReply();
|
2017-11-09 09:21:22 +00:00
|
|
|
bool remoteGateway = m_conf.getDStarRemoteGateway();
|
2017-09-01 08:25:54 +00:00
|
|
|
m_dstarRFModeHang = m_conf.getDStarModeHang();
|
2016-01-27 20:01:50 +00:00
|
|
|
|
2017-09-01 08:25:54 +00:00
|
|
|
LogInfo("D-Star RF Parameters");
|
2016-01-27 20:01:50 +00:00
|
|
|
LogInfo(" Module: %s", module.c_str());
|
2016-04-04 16:40:05 +00:00
|
|
|
LogInfo(" Self Only: %s", selfOnly ? "yes" : "no");
|
2017-06-10 12:18:18 +00:00
|
|
|
LogInfo(" Ack Reply: %s", ackReply ? "yes" : "no");
|
2018-09-14 10:30:48 +00:00
|
|
|
LogInfo(" Ack message: %s", ackMessage ? "RSSI" : "BER");
|
2017-06-14 10:54:44 +00:00
|
|
|
LogInfo(" Ack Time: %ums", ackTime);
|
2017-02-16 19:49:58 +00:00
|
|
|
LogInfo(" Error Reply: %s", errorReply ? "yes" : "no");
|
2017-11-09 09:21:22 +00:00
|
|
|
LogInfo(" Remote Gateway: %s", remoteGateway ? "yes" : "no");
|
2017-09-01 08:25:54 +00:00
|
|
|
LogInfo(" Mode Hang: %us", m_dstarRFModeHang);
|
2016-08-09 19:05:35 +00:00
|
|
|
|
2016-04-06 17:46:05 +00:00
|
|
|
if (blackList.size() > 0U)
|
|
|
|
LogInfo(" Black List: %u", blackList.size());
|
2016-01-27 20:01:50 +00:00
|
|
|
|
2019-01-10 09:05:15 +00:00
|
|
|
m_dstar = new CDStarControl(m_callsign, module, selfOnly, ackReply, ackTime, ackMessage, errorReply, blackList, m_dstarNetwork, m_display, m_timeout, m_duplex, remoteGateway, rssi);
|
2016-01-27 20:01:50 +00:00
|
|
|
}
|
2016-01-14 18:45:04 +00:00
|
|
|
|
2018-01-16 18:35:29 +00:00
|
|
|
CTimer dmrBeaconIntervalTimer(1000U);
|
|
|
|
CTimer dmrBeaconDurationTimer(1000U);
|
|
|
|
|
2016-01-14 18:45:04 +00:00
|
|
|
if (m_dmrEnabled) {
|
2016-12-21 19:58:46 +00:00
|
|
|
unsigned int id = m_conf.getDMRId();
|
|
|
|
unsigned int colorCode = m_conf.getDMRColorCode();
|
|
|
|
bool selfOnly = m_conf.getDMRSelfOnly();
|
2017-02-27 20:17:55 +00:00
|
|
|
bool embeddedLCOnly = m_conf.getDMREmbeddedLCOnly();
|
|
|
|
bool dumpTAData = m_conf.getDMRDumpTAData();
|
2016-11-10 18:43:54 +00:00
|
|
|
std::vector<unsigned int> prefixes = m_conf.getDMRPrefixes();
|
2016-04-06 17:46:05 +00:00
|
|
|
std::vector<unsigned int> blackList = m_conf.getDMRBlackList();
|
2016-12-21 19:06:29 +00:00
|
|
|
std::vector<unsigned int> whiteList = m_conf.getDMRWhiteList();
|
2017-01-05 19:15:10 +00:00
|
|
|
std::vector<unsigned int> slot1TGWhiteList = m_conf.getDMRSlot1TGWhiteList();
|
|
|
|
std::vector<unsigned int> slot2TGWhiteList = m_conf.getDMRSlot2TGWhiteList();
|
2017-02-27 20:17:55 +00:00
|
|
|
unsigned int callHang = m_conf.getDMRCallHang();
|
2016-12-21 19:58:46 +00:00
|
|
|
unsigned int txHang = m_conf.getDMRTXHang();
|
2017-09-01 08:25:54 +00:00
|
|
|
m_dmrRFModeHang = m_conf.getDMRModeHang();
|
2018-01-16 18:35:29 +00:00
|
|
|
bool dmrBeacons = m_conf.getDMRBeacons();
|
2019-10-11 17:24:25 +00:00
|
|
|
bool ovcm = m_conf.getDMROVCM();
|
2016-01-14 18:45:04 +00:00
|
|
|
|
2017-09-01 08:25:54 +00:00
|
|
|
if (txHang > m_dmrRFModeHang)
|
|
|
|
txHang = m_dmrRFModeHang;
|
|
|
|
|
|
|
|
if (m_conf.getDMRNetworkEnabled()) {
|
|
|
|
if (txHang > m_dmrNetModeHang)
|
|
|
|
txHang = m_dmrNetModeHang;
|
|
|
|
}
|
2016-06-22 17:03:56 +00:00
|
|
|
|
|
|
|
if (callHang > txHang)
|
|
|
|
callHang = txHang;
|
|
|
|
|
2017-09-01 08:25:54 +00:00
|
|
|
LogInfo("DMR RF Parameters");
|
2016-01-14 18:45:04 +00:00
|
|
|
LogInfo(" Id: %u", id);
|
|
|
|
LogInfo(" Color Code: %u", colorCode);
|
2016-04-04 16:40:05 +00:00
|
|
|
LogInfo(" Self Only: %s", selfOnly ? "yes" : "no");
|
2017-01-16 12:10:23 +00:00
|
|
|
LogInfo(" Embedded LC Only: %s", embeddedLCOnly ? "yes" : "no");
|
2017-02-27 20:17:55 +00:00
|
|
|
LogInfo(" Dump Talker Alias Data: %s", dumpTAData ? "yes" : "no");
|
2016-04-04 18:03:38 +00:00
|
|
|
LogInfo(" Prefixes: %u", prefixes.size());
|
2018-07-19 13:09:00 +00:00
|
|
|
|
2016-04-06 17:46:05 +00:00
|
|
|
if (blackList.size() > 0U)
|
2016-07-10 20:37:11 +00:00
|
|
|
LogInfo(" Source ID Black List: %u", blackList.size());
|
2016-12-21 19:06:29 +00:00
|
|
|
if (whiteList.size() > 0U)
|
|
|
|
LogInfo(" Source ID White List: %u", whiteList.size());
|
2017-01-05 19:15:10 +00:00
|
|
|
if (slot1TGWhiteList.size() > 0U)
|
|
|
|
LogInfo(" Slot 1 TG White List: %u", slot1TGWhiteList.size());
|
|
|
|
if (slot2TGWhiteList.size() > 0U)
|
|
|
|
LogInfo(" Slot 2 TG White List: %u", slot2TGWhiteList.size());
|
2016-12-21 19:06:29 +00:00
|
|
|
|
2016-06-16 20:40:05 +00:00
|
|
|
LogInfo(" Call Hang: %us", callHang);
|
2016-05-05 16:56:18 +00:00
|
|
|
LogInfo(" TX Hang: %us", txHang);
|
2017-09-01 08:25:54 +00:00
|
|
|
LogInfo(" Mode Hang: %us", m_dmrRFModeHang);
|
2019-10-11 17:24:25 +00:00
|
|
|
LogInfo(" OVCM: %s", ovcm ? "on" : "off");
|
2016-01-14 18:45:04 +00:00
|
|
|
|
2018-01-16 18:35:29 +00:00
|
|
|
if (dmrBeacons) {
|
|
|
|
unsigned int dmrBeaconInterval = m_conf.getDMRBeaconInterval();
|
|
|
|
unsigned int dmrBeaconDuration = m_conf.getDMRBeaconDuration();
|
|
|
|
|
|
|
|
LogInfo(" DMR Roaming Beacon Interval: %us", dmrBeaconInterval);
|
|
|
|
LogInfo(" DMR Roaming Beacon Duration: %us", dmrBeaconDuration);
|
|
|
|
|
|
|
|
dmrBeaconDurationTimer.setTimeout(dmrBeaconDuration);
|
|
|
|
|
|
|
|
dmrBeaconIntervalTimer.setTimeout(dmrBeaconInterval);
|
|
|
|
dmrBeaconIntervalTimer.start();
|
2018-01-15 19:22:01 +00:00
|
|
|
}
|
|
|
|
|
2019-11-04 13:48:13 +00:00
|
|
|
m_dmr = new CDMRControl(id, colorCode, callHang, selfOnly, embeddedLCOnly, dumpTAData, prefixes, blackList, whiteList, slot1TGWhiteList, slot2TGWhiteList, m_timeout, m_modem, m_dmrNetwork, m_display, m_duplex, m_dmrLookup, rssi, ovcm);
|
2016-05-05 16:56:18 +00:00
|
|
|
|
|
|
|
m_dmrTXTimer.setTimeout(txHang);
|
2016-01-14 18:45:04 +00:00
|
|
|
}
|
|
|
|
|
2016-08-09 19:05:35 +00:00
|
|
|
if (m_ysfEnabled) {
|
2018-05-21 20:32:33 +00:00
|
|
|
bool lowDeviation = m_conf.getFusionLowDeviation();
|
|
|
|
bool remoteGateway = m_conf.getFusionRemoteGateway();
|
|
|
|
unsigned int txHang = m_conf.getFusionTXHang();
|
|
|
|
bool selfOnly = m_conf.getFusionSelfOnly();
|
2019-02-12 11:29:05 +00:00
|
|
|
bool dgIdEnabled = m_conf.getFusionDGIdEnabled();
|
|
|
|
unsigned char dgId = m_conf.getFusionDGId();
|
2018-05-21 20:32:33 +00:00
|
|
|
m_ysfRFModeHang = m_conf.getFusionModeHang();
|
2016-08-09 19:05:35 +00:00
|
|
|
|
2017-09-01 08:25:54 +00:00
|
|
|
LogInfo("YSF RF Parameters");
|
2017-03-23 20:26:17 +00:00
|
|
|
LogInfo(" Low Deviation: %s", lowDeviation ? "yes" : "no");
|
2016-09-26 17:07:06 +00:00
|
|
|
LogInfo(" Remote Gateway: %s", remoteGateway ? "yes" : "no");
|
2018-05-21 20:32:33 +00:00
|
|
|
LogInfo(" TX Hang: %us", txHang);
|
2017-08-15 09:11:05 +00:00
|
|
|
LogInfo(" Self Only: %s", selfOnly ? "yes" : "no");
|
2019-02-12 11:29:05 +00:00
|
|
|
LogInfo(" DG-ID: %s", dgIdEnabled ? "yes" : "no");
|
|
|
|
if (dgIdEnabled)
|
|
|
|
LogInfo(" DG-ID Value: %u", dgId);
|
2017-09-01 08:25:54 +00:00
|
|
|
LogInfo(" Mode Hang: %us", m_ysfRFModeHang);
|
2016-08-09 19:05:35 +00:00
|
|
|
|
2019-01-10 09:05:15 +00:00
|
|
|
m_ysf = new CYSFControl(m_callsign, selfOnly, m_ysfNetwork, m_display, m_timeout, m_duplex, lowDeviation, remoteGateway, rssi);
|
2019-02-12 11:29:05 +00:00
|
|
|
m_ysf->setDGId(dgIdEnabled, dgId);
|
2016-08-09 19:05:35 +00:00
|
|
|
}
|
2016-01-14 18:45:04 +00:00
|
|
|
|
2016-09-08 20:27:21 +00:00
|
|
|
if (m_p25Enabled) {
|
2017-11-09 09:21:22 +00:00
|
|
|
unsigned int id = m_conf.getP25Id();
|
|
|
|
unsigned int nac = m_conf.getP25NAC();
|
|
|
|
bool uidOverride = m_conf.getP25OverrideUID();
|
|
|
|
bool selfOnly = m_conf.getP25SelfOnly();
|
|
|
|
bool remoteGateway = m_conf.getP25RemoteGateway();
|
|
|
|
m_p25RFModeHang = m_conf.getP25ModeHang();
|
2016-09-08 20:27:21 +00:00
|
|
|
|
2017-09-01 08:25:54 +00:00
|
|
|
LogInfo("P25 RF Parameters");
|
2017-08-15 09:30:05 +00:00
|
|
|
LogInfo(" Id: %u", id);
|
2017-08-19 15:23:37 +00:00
|
|
|
LogInfo(" NAC: $%03X", nac);
|
2017-03-29 19:46:27 +00:00
|
|
|
LogInfo(" UID Override: %s", uidOverride ? "yes" : "no");
|
2017-08-15 09:30:05 +00:00
|
|
|
LogInfo(" Self Only: %s", selfOnly ? "yes" : "no");
|
2017-11-09 09:21:22 +00:00
|
|
|
LogInfo(" Remote Gateway: %s", remoteGateway ? "yes" : "no");
|
2017-09-01 08:25:54 +00:00
|
|
|
LogInfo(" Mode Hang: %us", m_p25RFModeHang);
|
2016-09-08 20:27:21 +00:00
|
|
|
|
2019-01-10 09:05:15 +00:00
|
|
|
m_p25 = new CP25Control(nac, id, selfOnly, uidOverride, m_p25Network, m_display, m_timeout, m_duplex, m_dmrLookup, remoteGateway, rssi);
|
2016-09-08 20:27:21 +00:00
|
|
|
}
|
|
|
|
|
2018-01-11 19:35:33 +00:00
|
|
|
if (m_nxdnEnabled) {
|
2018-01-17 21:21:25 +00:00
|
|
|
std::string lookupFile = m_conf.getNXDNIdLookupFile();
|
|
|
|
unsigned int reloadTime = m_conf.getNXDNIdLookupTime();
|
|
|
|
|
|
|
|
LogInfo("NXDN Id Lookups");
|
|
|
|
LogInfo(" File: %s", lookupFile.length() > 0U ? lookupFile.c_str() : "None");
|
|
|
|
if (reloadTime > 0U)
|
|
|
|
LogInfo(" Reload: %u hours", reloadTime);
|
|
|
|
|
|
|
|
m_nxdnLookup = new CNXDNLookup(lookupFile, reloadTime);
|
|
|
|
m_nxdnLookup->read();
|
|
|
|
|
2018-01-11 19:35:33 +00:00
|
|
|
unsigned int id = m_conf.getNXDNId();
|
|
|
|
unsigned int ran = m_conf.getNXDNRAN();
|
|
|
|
bool selfOnly = m_conf.getNXDNSelfOnly();
|
|
|
|
bool remoteGateway = m_conf.getNXDNRemoteGateway();
|
|
|
|
m_nxdnRFModeHang = m_conf.getNXDNModeHang();
|
|
|
|
|
|
|
|
LogInfo("NXDN RF Parameters");
|
|
|
|
LogInfo(" Id: %u", id);
|
|
|
|
LogInfo(" RAN: %u", ran);
|
|
|
|
LogInfo(" Self Only: %s", selfOnly ? "yes" : "no");
|
|
|
|
LogInfo(" Remote Gateway: %s", remoteGateway ? "yes" : "no");
|
2018-01-15 21:03:34 +00:00
|
|
|
LogInfo(" Mode Hang: %us", m_nxdnRFModeHang);
|
2018-01-11 19:35:33 +00:00
|
|
|
|
2019-01-10 09:05:15 +00:00
|
|
|
m_nxdn = new CNXDNControl(ran, id, selfOnly, m_nxdnNetwork, m_display, m_timeout, m_duplex, remoteGateway, m_nxdnLookup, rssi);
|
2018-01-11 19:35:33 +00:00
|
|
|
}
|
|
|
|
|
2018-06-28 06:08:04 +00:00
|
|
|
CTimer pocsagTimer(1000U, 30U);
|
|
|
|
|
2018-06-12 18:40:49 +00:00
|
|
|
if (m_pocsagEnabled) {
|
|
|
|
unsigned int frequency = m_conf.getPOCSAGFrequency();
|
|
|
|
|
|
|
|
LogInfo("POCSAG RF Parameters");
|
|
|
|
LogInfo(" Frequency: %uHz", frequency);
|
|
|
|
|
2019-01-10 14:03:23 +00:00
|
|
|
m_pocsag = new CPOCSAGControl(m_pocsagNetwork, m_display);
|
2018-06-28 06:08:04 +00:00
|
|
|
|
|
|
|
pocsagTimer.start();
|
2018-06-12 18:40:49 +00:00
|
|
|
}
|
2018-06-07 17:46:03 +00:00
|
|
|
|
2019-01-07 11:03:37 +00:00
|
|
|
bool remoteControlEnabled = m_conf.getRemoteControlEnabled();
|
|
|
|
if (remoteControlEnabled) {
|
|
|
|
unsigned int port = m_conf.getRemoteControlPort();
|
|
|
|
|
|
|
|
LogInfo("Remote Control Parameters");
|
2019-01-23 09:09:34 +00:00
|
|
|
LogInfo(" Port: %u", port);
|
2019-01-07 11:03:37 +00:00
|
|
|
|
2019-01-10 09:05:15 +00:00
|
|
|
m_remoteControl = new CRemoteControl(port);
|
2019-01-07 11:03:37 +00:00
|
|
|
|
2019-01-10 09:05:15 +00:00
|
|
|
ret = m_remoteControl->open();
|
2019-01-07 11:03:37 +00:00
|
|
|
if (!ret) {
|
2019-01-10 09:05:15 +00:00
|
|
|
delete m_remoteControl;
|
|
|
|
m_remoteControl = NULL;
|
2019-01-07 11:03:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-21 08:42:32 +00:00
|
|
|
setMode(MODE_IDLE);
|
2016-01-14 18:45:04 +00:00
|
|
|
|
2016-05-14 20:31:17 +00:00
|
|
|
LogMessage("MMDVMHost-%s is running", VERSION);
|
2016-05-12 17:04:50 +00:00
|
|
|
|
2016-01-14 18:45:04 +00:00
|
|
|
while (!m_killed) {
|
2016-11-03 19:07:44 +00:00
|
|
|
bool lockout1 = m_modem->hasLockout();
|
|
|
|
bool lockout2 = false;
|
2018-10-10 19:05:24 +00:00
|
|
|
|
2016-11-03 19:07:44 +00:00
|
|
|
if (m_ump != NULL)
|
|
|
|
lockout2 = m_ump->getLockout();
|
|
|
|
if ((lockout1 || lockout2) && m_mode != MODE_LOCKOUT)
|
2016-03-03 21:45:20 +00:00
|
|
|
setMode(MODE_LOCKOUT);
|
2016-11-03 19:07:44 +00:00
|
|
|
else if ((!lockout1 && !lockout2) && m_mode == MODE_LOCKOUT)
|
2016-03-03 21:45:20 +00:00
|
|
|
setMode(MODE_IDLE);
|
|
|
|
|
2016-03-21 22:47:58 +00:00
|
|
|
bool error = m_modem->hasError();
|
|
|
|
if (error && m_mode != MODE_ERROR)
|
|
|
|
setMode(MODE_ERROR);
|
|
|
|
else if (!error && m_mode == MODE_ERROR)
|
|
|
|
setMode(MODE_IDLE);
|
|
|
|
|
2016-11-03 19:07:44 +00:00
|
|
|
if (m_ump != NULL) {
|
|
|
|
bool tx = m_modem->hasTX();
|
|
|
|
m_ump->setTX(tx);
|
2016-11-17 10:48:42 +00:00
|
|
|
bool cd = m_modem->hasCD();
|
|
|
|
m_ump->setCD(cd);
|
2016-11-03 19:07:44 +00:00
|
|
|
}
|
|
|
|
|
2019-09-03 19:18:10 +00:00
|
|
|
unsigned char data[220U];
|
2016-01-14 18:45:04 +00:00
|
|
|
unsigned int len;
|
|
|
|
bool ret;
|
|
|
|
|
|
|
|
len = m_modem->readDStarData(data);
|
2019-01-10 21:50:57 +00:00
|
|
|
if (m_dstar != NULL && len > 0U) {
|
2016-02-02 18:17:36 +00:00
|
|
|
if (m_mode == MODE_IDLE) {
|
2019-01-10 09:05:15 +00:00
|
|
|
bool ret = m_dstar->writeModem(data, len);
|
2016-06-22 17:03:56 +00:00
|
|
|
if (ret) {
|
2017-09-01 08:25:54 +00:00
|
|
|
m_modeTimer.setTimeout(m_dstarRFModeHang);
|
2016-02-02 18:17:36 +00:00
|
|
|
setMode(MODE_DSTAR);
|
2016-06-22 17:03:56 +00:00
|
|
|
}
|
2016-02-02 18:17:36 +00:00
|
|
|
} else if (m_mode == MODE_DSTAR) {
|
2019-01-10 09:05:15 +00:00
|
|
|
m_dstar->writeModem(data, len);
|
2016-02-02 18:17:36 +00:00
|
|
|
m_modeTimer.start();
|
2016-03-07 19:45:19 +00:00
|
|
|
} else if (m_mode != MODE_LOCKOUT) {
|
2016-02-03 09:55:08 +00:00
|
|
|
LogWarning("D-Star modem data received when in mode %u", m_mode);
|
2016-01-14 18:45:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
len = m_modem->readDMRData1(data);
|
2019-01-10 09:05:15 +00:00
|
|
|
if (m_dmr != NULL && len > 0U) {
|
2016-02-02 18:17:36 +00:00
|
|
|
if (m_mode == MODE_IDLE) {
|
2016-03-07 19:45:19 +00:00
|
|
|
if (m_duplex) {
|
2019-01-10 09:05:15 +00:00
|
|
|
bool ret = m_dmr->processWakeup(data);
|
2016-05-05 16:56:18 +00:00
|
|
|
if (ret) {
|
2017-09-01 08:25:54 +00:00
|
|
|
m_modeTimer.setTimeout(m_dmrRFModeHang);
|
2016-03-07 19:45:19 +00:00
|
|
|
setMode(MODE_DMR);
|
2018-01-16 18:35:29 +00:00
|
|
|
dmrBeaconDurationTimer.stop();
|
2016-05-05 16:56:18 +00:00
|
|
|
}
|
2016-03-07 19:45:19 +00:00
|
|
|
} else {
|
2017-09-01 08:25:54 +00:00
|
|
|
m_modeTimer.setTimeout(m_dmrRFModeHang);
|
2016-02-02 18:17:36 +00:00
|
|
|
setMode(MODE_DMR);
|
2019-01-10 09:05:15 +00:00
|
|
|
m_dmr->writeModemSlot1(data, len);
|
2018-01-16 18:35:29 +00:00
|
|
|
dmrBeaconDurationTimer.stop();
|
2016-03-07 19:45:19 +00:00
|
|
|
}
|
2016-02-02 18:17:36 +00:00
|
|
|
} else if (m_mode == MODE_DMR) {
|
2016-05-05 16:56:18 +00:00
|
|
|
if (m_duplex && !m_modem->hasTX()) {
|
2019-01-10 09:05:15 +00:00
|
|
|
bool ret = m_dmr->processWakeup(data);
|
2016-05-05 16:56:18 +00:00
|
|
|
if (ret) {
|
|
|
|
m_modem->writeDMRStart(true);
|
|
|
|
m_dmrTXTimer.start();
|
|
|
|
}
|
|
|
|
} else {
|
2019-01-10 09:05:15 +00:00
|
|
|
bool ret = m_dmr->writeModemSlot1(data, len);
|
2017-03-12 19:06:47 +00:00
|
|
|
if (ret) {
|
2018-01-16 18:35:29 +00:00
|
|
|
dmrBeaconDurationTimer.stop();
|
2017-03-12 19:06:47 +00:00
|
|
|
m_modeTimer.start();
|
|
|
|
if (m_duplex)
|
|
|
|
m_dmrTXTimer.start();
|
|
|
|
}
|
2016-05-05 16:56:18 +00:00
|
|
|
}
|
2016-03-07 19:45:19 +00:00
|
|
|
} else if (m_mode != MODE_LOCKOUT) {
|
2016-02-03 09:55:08 +00:00
|
|
|
LogWarning("DMR modem data received when in mode %u", m_mode);
|
2016-01-14 18:45:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
len = m_modem->readDMRData2(data);
|
2019-01-10 09:05:15 +00:00
|
|
|
if (m_dmr != NULL && len > 0U) {
|
2016-02-02 18:17:36 +00:00
|
|
|
if (m_mode == MODE_IDLE) {
|
2016-03-07 19:45:19 +00:00
|
|
|
if (m_duplex) {
|
2019-01-10 09:05:15 +00:00
|
|
|
bool ret = m_dmr->processWakeup(data);
|
2016-05-05 16:56:18 +00:00
|
|
|
if (ret) {
|
2017-09-01 08:25:54 +00:00
|
|
|
m_modeTimer.setTimeout(m_dmrRFModeHang);
|
2016-03-07 19:45:19 +00:00
|
|
|
setMode(MODE_DMR);
|
2018-01-16 18:35:29 +00:00
|
|
|
dmrBeaconDurationTimer.stop();
|
2016-05-05 16:56:18 +00:00
|
|
|
}
|
2016-03-07 19:45:19 +00:00
|
|
|
} else {
|
2017-09-01 08:25:54 +00:00
|
|
|
m_modeTimer.setTimeout(m_dmrRFModeHang);
|
2016-02-02 18:17:36 +00:00
|
|
|
setMode(MODE_DMR);
|
2019-01-10 09:05:15 +00:00
|
|
|
m_dmr->writeModemSlot2(data, len);
|
2018-01-16 18:35:29 +00:00
|
|
|
dmrBeaconDurationTimer.stop();
|
2016-03-07 19:45:19 +00:00
|
|
|
}
|
2016-02-02 18:17:36 +00:00
|
|
|
} else if (m_mode == MODE_DMR) {
|
2016-05-05 16:56:18 +00:00
|
|
|
if (m_duplex && !m_modem->hasTX()) {
|
2019-01-10 09:05:15 +00:00
|
|
|
bool ret = m_dmr->processWakeup(data);
|
2016-05-05 16:56:18 +00:00
|
|
|
if (ret) {
|
|
|
|
m_modem->writeDMRStart(true);
|
|
|
|
m_dmrTXTimer.start();
|
|
|
|
}
|
|
|
|
} else {
|
2019-01-10 09:05:15 +00:00
|
|
|
bool ret = m_dmr->writeModemSlot2(data, len);
|
2017-03-12 19:06:47 +00:00
|
|
|
if (ret) {
|
2018-01-16 18:35:29 +00:00
|
|
|
dmrBeaconDurationTimer.stop();
|
2017-03-12 19:06:47 +00:00
|
|
|
m_modeTimer.start();
|
|
|
|
if (m_duplex)
|
|
|
|
m_dmrTXTimer.start();
|
|
|
|
}
|
2016-05-05 16:56:18 +00:00
|
|
|
}
|
2016-03-07 19:45:19 +00:00
|
|
|
} else if (m_mode != MODE_LOCKOUT) {
|
2016-02-03 09:55:08 +00:00
|
|
|
LogWarning("DMR modem data received when in mode %u", m_mode);
|
2016-01-14 18:45:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
len = m_modem->readYSFData(data);
|
2019-01-10 09:05:15 +00:00
|
|
|
if (m_ysf != NULL && len > 0U) {
|
2016-02-02 18:17:36 +00:00
|
|
|
if (m_mode == MODE_IDLE) {
|
2019-01-10 09:05:15 +00:00
|
|
|
bool ret = m_ysf->writeModem(data, len);
|
2016-06-22 17:03:56 +00:00
|
|
|
if (ret) {
|
2017-09-01 08:25:54 +00:00
|
|
|
m_modeTimer.setTimeout(m_ysfRFModeHang);
|
2016-02-02 18:17:36 +00:00
|
|
|
setMode(MODE_YSF);
|
2016-06-22 17:03:56 +00:00
|
|
|
}
|
2016-02-02 18:17:36 +00:00
|
|
|
} else if (m_mode == MODE_YSF) {
|
2019-01-10 09:05:15 +00:00
|
|
|
m_ysf->writeModem(data, len);
|
2016-02-02 18:17:36 +00:00
|
|
|
m_modeTimer.start();
|
2016-03-07 19:45:19 +00:00
|
|
|
} else if (m_mode != MODE_LOCKOUT) {
|
2016-02-03 09:55:08 +00:00
|
|
|
LogWarning("System Fusion modem data received when in mode %u", m_mode);
|
2016-01-14 18:45:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-09-08 20:27:21 +00:00
|
|
|
len = m_modem->readP25Data(data);
|
2019-01-10 09:05:15 +00:00
|
|
|
if (m_p25 != NULL && len > 0U) {
|
2016-09-08 20:27:21 +00:00
|
|
|
if (m_mode == MODE_IDLE) {
|
2019-01-10 09:05:15 +00:00
|
|
|
bool ret = m_p25->writeModem(data, len);
|
2016-09-08 20:27:21 +00:00
|
|
|
if (ret) {
|
2017-09-01 08:25:54 +00:00
|
|
|
m_modeTimer.setTimeout(m_p25RFModeHang);
|
2016-09-08 20:27:21 +00:00
|
|
|
setMode(MODE_P25);
|
|
|
|
}
|
|
|
|
} else if (m_mode == MODE_P25) {
|
2019-01-10 09:05:15 +00:00
|
|
|
m_p25->writeModem(data, len);
|
2016-09-08 20:27:21 +00:00
|
|
|
m_modeTimer.start();
|
|
|
|
} else if (m_mode != MODE_LOCKOUT) {
|
|
|
|
LogWarning("P25 modem data received when in mode %u", m_mode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-11 19:35:33 +00:00
|
|
|
len = m_modem->readNXDNData(data);
|
2019-01-10 09:05:15 +00:00
|
|
|
if (m_nxdn != NULL && len > 0U) {
|
2018-01-11 19:35:33 +00:00
|
|
|
if (m_mode == MODE_IDLE) {
|
2019-01-10 09:05:15 +00:00
|
|
|
bool ret = m_nxdn->writeModem(data, len);
|
2018-01-11 19:35:33 +00:00
|
|
|
if (ret) {
|
|
|
|
m_modeTimer.setTimeout(m_nxdnRFModeHang);
|
|
|
|
setMode(MODE_NXDN);
|
|
|
|
}
|
|
|
|
} else if (m_mode == MODE_NXDN) {
|
2019-01-10 09:05:15 +00:00
|
|
|
m_nxdn->writeModem(data, len);
|
2018-01-11 19:35:33 +00:00
|
|
|
m_modeTimer.start();
|
|
|
|
} else if (m_mode != MODE_LOCKOUT) {
|
|
|
|
LogWarning("NXDN modem data received when in mode %u", m_mode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-22 07:13:13 +00:00
|
|
|
len = m_modem->readTransparentData(data);
|
|
|
|
if (transparentSocket != NULL && len > 0U)
|
|
|
|
transparentSocket->write(data, len, transparentAddress, transparentPort);
|
|
|
|
|
2019-01-22 14:38:38 +00:00
|
|
|
if (!m_fixedMode) {
|
|
|
|
if (m_modeTimer.isRunning() && m_modeTimer.hasExpired())
|
|
|
|
setMode(MODE_IDLE);
|
|
|
|
}
|
2016-01-14 18:45:04 +00:00
|
|
|
|
2019-01-10 21:50:57 +00:00
|
|
|
if (m_dstar != NULL) {
|
2016-01-25 19:59:37 +00:00
|
|
|
ret = m_modem->hasDStarSpace();
|
2016-01-14 18:45:04 +00:00
|
|
|
if (ret) {
|
2019-01-10 09:05:15 +00:00
|
|
|
len = m_dstar->readModem(data);
|
2016-02-03 09:55:08 +00:00
|
|
|
if (len > 0U) {
|
2016-06-22 17:03:56 +00:00
|
|
|
if (m_mode == MODE_IDLE) {
|
2017-09-01 08:25:54 +00:00
|
|
|
m_modeTimer.setTimeout(m_dstarNetModeHang);
|
2016-02-03 09:55:08 +00:00
|
|
|
setMode(MODE_DSTAR);
|
2016-06-22 17:03:56 +00:00
|
|
|
}
|
2016-03-07 19:45:19 +00:00
|
|
|
if (m_mode == MODE_DSTAR) {
|
2016-02-03 09:55:08 +00:00
|
|
|
m_modem->writeDStarData(data, len);
|
|
|
|
m_modeTimer.start();
|
2016-03-07 19:45:19 +00:00
|
|
|
} else if (m_mode != MODE_LOCKOUT) {
|
2016-02-03 09:55:08 +00:00
|
|
|
LogWarning("D-Star data received when in mode %u", m_mode);
|
|
|
|
}
|
2016-01-14 18:45:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-10 09:05:15 +00:00
|
|
|
if (m_dmr != NULL) {
|
2016-01-14 18:45:04 +00:00
|
|
|
ret = m_modem->hasDMRSpace1();
|
|
|
|
if (ret) {
|
2019-01-10 09:05:15 +00:00
|
|
|
len = m_dmr->readModemSlot1(data);
|
2016-02-03 09:55:08 +00:00
|
|
|
if (len > 0U) {
|
2016-06-22 17:03:56 +00:00
|
|
|
if (m_mode == MODE_IDLE) {
|
2017-09-01 08:25:54 +00:00
|
|
|
m_modeTimer.setTimeout(m_dmrNetModeHang);
|
2016-02-03 09:55:08 +00:00
|
|
|
setMode(MODE_DMR);
|
2016-06-22 17:03:56 +00:00
|
|
|
}
|
2016-03-07 19:45:19 +00:00
|
|
|
if (m_mode == MODE_DMR) {
|
2016-05-05 16:56:18 +00:00
|
|
|
if (m_duplex) {
|
|
|
|
m_modem->writeDMRStart(true);
|
|
|
|
m_dmrTXTimer.start();
|
|
|
|
}
|
2016-02-03 09:55:08 +00:00
|
|
|
m_modem->writeDMRData1(data, len);
|
2018-01-16 18:35:29 +00:00
|
|
|
dmrBeaconDurationTimer.stop();
|
2016-02-03 09:55:08 +00:00
|
|
|
m_modeTimer.start();
|
2016-03-07 19:45:19 +00:00
|
|
|
} else if (m_mode != MODE_LOCKOUT) {
|
2016-02-03 09:55:08 +00:00
|
|
|
LogWarning("DMR data received when in mode %u", m_mode);
|
|
|
|
}
|
2016-01-14 18:45:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = m_modem->hasDMRSpace2();
|
|
|
|
if (ret) {
|
2019-01-10 09:05:15 +00:00
|
|
|
len = m_dmr->readModemSlot2(data);
|
2016-02-03 09:55:08 +00:00
|
|
|
if (len > 0U) {
|
2016-06-22 17:03:56 +00:00
|
|
|
if (m_mode == MODE_IDLE) {
|
2017-09-01 08:25:54 +00:00
|
|
|
m_modeTimer.setTimeout(m_dmrNetModeHang);
|
2016-02-03 09:55:08 +00:00
|
|
|
setMode(MODE_DMR);
|
2016-06-22 17:03:56 +00:00
|
|
|
}
|
2016-03-07 19:45:19 +00:00
|
|
|
if (m_mode == MODE_DMR) {
|
2016-05-05 16:56:18 +00:00
|
|
|
if (m_duplex) {
|
|
|
|
m_modem->writeDMRStart(true);
|
|
|
|
m_dmrTXTimer.start();
|
|
|
|
}
|
2016-02-03 09:55:08 +00:00
|
|
|
m_modem->writeDMRData2(data, len);
|
2018-01-16 18:35:29 +00:00
|
|
|
dmrBeaconDurationTimer.stop();
|
2016-02-03 09:55:08 +00:00
|
|
|
m_modeTimer.start();
|
2016-03-07 19:45:19 +00:00
|
|
|
} else if (m_mode != MODE_LOCKOUT) {
|
2016-02-03 09:55:08 +00:00
|
|
|
LogWarning("DMR data received when in mode %u", m_mode);
|
|
|
|
}
|
2016-01-14 18:45:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-10 09:05:15 +00:00
|
|
|
if (m_ysf != NULL) {
|
2016-01-25 19:59:37 +00:00
|
|
|
ret = m_modem->hasYSFSpace();
|
2016-01-14 18:45:04 +00:00
|
|
|
if (ret) {
|
2019-01-10 09:05:15 +00:00
|
|
|
len = m_ysf->readModem(data);
|
2016-02-03 09:55:08 +00:00
|
|
|
if (len > 0U) {
|
2016-06-22 17:03:56 +00:00
|
|
|
if (m_mode == MODE_IDLE) {
|
2017-09-01 08:25:54 +00:00
|
|
|
m_modeTimer.setTimeout(m_ysfNetModeHang);
|
2016-02-03 09:55:08 +00:00
|
|
|
setMode(MODE_YSF);
|
2016-06-22 17:03:56 +00:00
|
|
|
}
|
2016-03-07 19:45:19 +00:00
|
|
|
if (m_mode == MODE_YSF) {
|
2016-02-03 09:55:08 +00:00
|
|
|
m_modem->writeYSFData(data, len);
|
|
|
|
m_modeTimer.start();
|
2016-03-07 19:45:19 +00:00
|
|
|
} else if (m_mode != MODE_LOCKOUT) {
|
2016-02-03 09:55:08 +00:00
|
|
|
LogWarning("System Fusion data received when in mode %u", m_mode);
|
|
|
|
}
|
2016-01-14 18:45:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-10 09:05:15 +00:00
|
|
|
if (m_p25 != NULL) {
|
2016-09-08 20:27:21 +00:00
|
|
|
ret = m_modem->hasP25Space();
|
|
|
|
if (ret) {
|
2019-01-10 09:05:15 +00:00
|
|
|
len = m_p25->readModem(data);
|
2016-09-08 20:27:21 +00:00
|
|
|
if (len > 0U) {
|
|
|
|
if (m_mode == MODE_IDLE) {
|
2017-09-01 08:25:54 +00:00
|
|
|
m_modeTimer.setTimeout(m_p25NetModeHang);
|
2016-09-08 20:27:21 +00:00
|
|
|
setMode(MODE_P25);
|
|
|
|
}
|
|
|
|
if (m_mode == MODE_P25) {
|
|
|
|
m_modem->writeP25Data(data, len);
|
|
|
|
m_modeTimer.start();
|
2017-09-01 08:25:54 +00:00
|
|
|
} else if (m_mode != MODE_LOCKOUT) {
|
2016-09-08 20:27:21 +00:00
|
|
|
LogWarning("P25 data received when in mode %u", m_mode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-10 09:05:15 +00:00
|
|
|
if (m_nxdn != NULL) {
|
2018-01-11 19:35:33 +00:00
|
|
|
ret = m_modem->hasNXDNSpace();
|
|
|
|
if (ret) {
|
2019-01-10 09:05:15 +00:00
|
|
|
len = m_nxdn->readModem(data);
|
2018-01-11 19:35:33 +00:00
|
|
|
if (len > 0U) {
|
|
|
|
if (m_mode == MODE_IDLE) {
|
|
|
|
m_modeTimer.setTimeout(m_nxdnNetModeHang);
|
|
|
|
setMode(MODE_NXDN);
|
|
|
|
}
|
|
|
|
if (m_mode == MODE_NXDN) {
|
|
|
|
m_modem->writeNXDNData(data, len);
|
|
|
|
m_modeTimer.start();
|
2018-01-16 20:10:35 +00:00
|
|
|
} else if (m_mode != MODE_LOCKOUT) {
|
2018-01-11 19:35:33 +00:00
|
|
|
LogWarning("NXDN data received when in mode %u", m_mode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-10 14:03:23 +00:00
|
|
|
if (m_pocsag != NULL) {
|
2018-06-07 17:46:03 +00:00
|
|
|
ret = m_modem->hasPOCSAGSpace();
|
|
|
|
if (ret) {
|
2019-01-10 14:03:23 +00:00
|
|
|
len = m_pocsag->readModem(data);
|
2018-06-07 17:46:03 +00:00
|
|
|
if (len > 0U) {
|
|
|
|
if (m_mode == MODE_IDLE) {
|
|
|
|
m_modeTimer.setTimeout(m_pocsagNetModeHang);
|
|
|
|
setMode(MODE_POCSAG);
|
|
|
|
}
|
|
|
|
if (m_mode == MODE_POCSAG) {
|
|
|
|
m_modem->writePOCSAGData(data, len);
|
|
|
|
m_modeTimer.start();
|
|
|
|
} else if (m_mode != MODE_LOCKOUT) {
|
|
|
|
LogWarning("POCSAG data received when in mode %u", m_mode);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-22 07:13:13 +00:00
|
|
|
if (transparentSocket != NULL) {
|
|
|
|
in_addr address;
|
|
|
|
unsigned int port = 0U;
|
|
|
|
len = transparentSocket->read(data, 200U, address, port);
|
|
|
|
if (len > 0U)
|
2018-09-13 18:35:12 +00:00
|
|
|
m_modem->writeTransparentData(data, len);
|
2018-03-22 07:13:13 +00:00
|
|
|
}
|
|
|
|
|
2019-01-10 09:05:15 +00:00
|
|
|
remoteControl();
|
2019-01-07 11:03:37 +00:00
|
|
|
|
2016-01-14 18:45:04 +00:00
|
|
|
unsigned int ms = stopWatch.elapsed();
|
2016-02-19 06:21:40 +00:00
|
|
|
stopWatch.start();
|
|
|
|
|
2016-05-09 17:14:27 +00:00
|
|
|
m_display->clock(ms);
|
|
|
|
|
2016-01-14 18:45:04 +00:00
|
|
|
m_modem->clock(ms);
|
2019-01-18 15:57:05 +00:00
|
|
|
|
2019-01-22 14:38:38 +00:00
|
|
|
if (!m_fixedMode)
|
|
|
|
m_modeTimer.clock(ms);
|
2016-02-19 06:21:40 +00:00
|
|
|
|
2019-01-10 09:05:15 +00:00
|
|
|
if (m_dstar != NULL)
|
|
|
|
m_dstar->clock();
|
|
|
|
if (m_dmr != NULL)
|
|
|
|
m_dmr->clock();
|
|
|
|
if (m_ysf != NULL)
|
|
|
|
m_ysf->clock(ms);
|
|
|
|
if (m_p25 != NULL)
|
|
|
|
m_p25->clock(ms);
|
|
|
|
if (m_nxdn != NULL)
|
|
|
|
m_nxdn->clock(ms);
|
2019-01-10 14:03:23 +00:00
|
|
|
if (m_pocsag != NULL)
|
|
|
|
m_pocsag->clock(ms);
|
2016-02-19 06:21:40 +00:00
|
|
|
|
2016-01-26 19:56:10 +00:00
|
|
|
if (m_dstarNetwork != NULL)
|
|
|
|
m_dstarNetwork->clock(ms);
|
|
|
|
if (m_dmrNetwork != NULL)
|
|
|
|
m_dmrNetwork->clock(ms);
|
2016-05-16 20:57:32 +00:00
|
|
|
if (m_ysfNetwork != NULL)
|
|
|
|
m_ysfNetwork->clock(ms);
|
2016-09-14 06:41:37 +00:00
|
|
|
if (m_p25Network != NULL)
|
|
|
|
m_p25Network->clock(ms);
|
2018-01-15 21:03:34 +00:00
|
|
|
if (m_nxdnNetwork != NULL)
|
|
|
|
m_nxdnNetwork->clock(ms);
|
2018-06-07 17:46:03 +00:00
|
|
|
if (m_pocsagNetwork != NULL)
|
|
|
|
m_pocsagNetwork->clock(ms);
|
2016-01-14 18:45:04 +00:00
|
|
|
|
2018-11-06 12:14:57 +00:00
|
|
|
if (m_mobileGPS != NULL)
|
|
|
|
m_mobileGPS->clock(ms);
|
|
|
|
|
2016-05-09 20:55:44 +00:00
|
|
|
m_cwIdTimer.clock(ms);
|
|
|
|
if (m_cwIdTimer.isRunning() && m_cwIdTimer.hasExpired()) {
|
2019-01-22 14:38:38 +00:00
|
|
|
if (!m_modem->hasTX()){
|
2016-06-03 14:28:55 +00:00
|
|
|
LogDebug("sending CW ID");
|
2016-09-15 13:17:51 +00:00
|
|
|
m_display->writeCW();
|
2017-04-10 16:55:53 +00:00
|
|
|
m_modem->sendCWId(m_cwCallsign);
|
2016-06-03 14:28:55 +00:00
|
|
|
|
2016-10-17 17:01:38 +00:00
|
|
|
m_cwIdTimer.setTimeout(m_cwIdTime);
|
|
|
|
m_cwIdTimer.start();
|
2016-06-03 14:28:55 +00:00
|
|
|
}
|
2016-05-09 20:55:44 +00:00
|
|
|
}
|
|
|
|
|
2018-01-16 18:35:29 +00:00
|
|
|
dmrBeaconIntervalTimer.clock(ms);
|
|
|
|
if (dmrBeaconIntervalTimer.isRunning() && dmrBeaconIntervalTimer.hasExpired()) {
|
2019-01-22 14:38:38 +00:00
|
|
|
if ((m_mode == MODE_IDLE || m_mode == MODE_DMR) && !m_modem->hasTX()) {
|
2019-01-26 12:56:24 +00:00
|
|
|
if (!m_fixedMode && m_mode == MODE_IDLE)
|
2019-01-22 14:38:38 +00:00
|
|
|
setMode(MODE_DMR);
|
2018-01-16 18:35:29 +00:00
|
|
|
dmrBeaconIntervalTimer.start();
|
|
|
|
dmrBeaconDurationTimer.start();
|
2018-01-15 19:22:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-16 18:35:29 +00:00
|
|
|
dmrBeaconDurationTimer.clock(ms);
|
|
|
|
if (dmrBeaconDurationTimer.isRunning() && dmrBeaconDurationTimer.hasExpired()) {
|
2019-01-22 14:38:38 +00:00
|
|
|
if (!m_fixedMode)
|
|
|
|
setMode(MODE_IDLE);
|
2018-01-16 18:35:29 +00:00
|
|
|
dmrBeaconDurationTimer.stop();
|
2016-01-14 19:58:16 +00:00
|
|
|
}
|
|
|
|
|
2016-05-05 16:56:18 +00:00
|
|
|
m_dmrTXTimer.clock(ms);
|
|
|
|
if (m_dmrTXTimer.isRunning() && m_dmrTXTimer.hasExpired()) {
|
|
|
|
m_modem->writeDMRStart(false);
|
|
|
|
m_dmrTXTimer.stop();
|
|
|
|
}
|
|
|
|
|
2018-06-28 06:08:04 +00:00
|
|
|
pocsagTimer.clock(ms);
|
|
|
|
if (pocsagTimer.isRunning() && pocsagTimer.hasExpired()) {
|
|
|
|
assert(m_pocsagNetwork != NULL);
|
|
|
|
m_pocsagNetwork->enable(m_mode == MODE_IDLE || m_mode == MODE_POCSAG);
|
|
|
|
pocsagTimer.start();
|
|
|
|
}
|
|
|
|
|
2016-11-03 19:07:44 +00:00
|
|
|
if (m_ump != NULL)
|
|
|
|
m_ump->clock(ms);
|
|
|
|
|
2016-06-06 16:40:27 +00:00
|
|
|
if (ms < 5U)
|
|
|
|
CThread::sleep(5U);
|
2016-01-14 18:45:04 +00:00
|
|
|
}
|
|
|
|
|
2018-08-15 16:17:42 +00:00
|
|
|
setMode(MODE_QUIT);
|
2016-01-14 18:45:04 +00:00
|
|
|
|
|
|
|
m_modem->close();
|
|
|
|
delete m_modem;
|
|
|
|
|
|
|
|
m_display->close();
|
|
|
|
delete m_display;
|
|
|
|
|
2018-11-06 12:14:57 +00:00
|
|
|
if (m_mobileGPS != NULL) {
|
|
|
|
m_mobileGPS->close();
|
|
|
|
delete m_mobileGPS;
|
|
|
|
}
|
|
|
|
|
2016-11-03 19:07:44 +00:00
|
|
|
if (m_ump != NULL) {
|
|
|
|
m_ump->close();
|
|
|
|
delete m_ump;
|
|
|
|
}
|
|
|
|
|
2018-01-17 21:21:25 +00:00
|
|
|
if (m_dmrLookup != NULL)
|
|
|
|
m_dmrLookup->stop();
|
|
|
|
|
|
|
|
if (m_nxdnLookup != NULL)
|
|
|
|
m_nxdnLookup->stop();
|
2016-10-10 18:15:30 +00:00
|
|
|
|
2016-01-25 21:00:19 +00:00
|
|
|
if (m_dstarNetwork != NULL) {
|
|
|
|
m_dstarNetwork->close();
|
|
|
|
delete m_dstarNetwork;
|
|
|
|
}
|
|
|
|
|
2016-01-14 18:45:04 +00:00
|
|
|
if (m_dmrNetwork != NULL) {
|
|
|
|
m_dmrNetwork->close();
|
|
|
|
delete m_dmrNetwork;
|
|
|
|
}
|
|
|
|
|
2016-05-16 20:57:32 +00:00
|
|
|
if (m_ysfNetwork != NULL) {
|
|
|
|
m_ysfNetwork->close();
|
|
|
|
delete m_ysfNetwork;
|
|
|
|
}
|
|
|
|
|
2016-09-14 06:41:37 +00:00
|
|
|
if (m_p25Network != NULL) {
|
|
|
|
m_p25Network->close();
|
|
|
|
delete m_p25Network;
|
|
|
|
}
|
|
|
|
|
2018-01-15 21:03:34 +00:00
|
|
|
if (m_nxdnNetwork != NULL) {
|
|
|
|
m_nxdnNetwork->close();
|
|
|
|
delete m_nxdnNetwork;
|
|
|
|
}
|
|
|
|
|
2018-06-07 17:46:03 +00:00
|
|
|
if (m_pocsagNetwork != NULL) {
|
|
|
|
m_pocsagNetwork->close();
|
|
|
|
delete m_pocsagNetwork;
|
|
|
|
}
|
|
|
|
|
2018-03-22 07:13:13 +00:00
|
|
|
if (transparentSocket != NULL) {
|
|
|
|
transparentSocket->close();
|
|
|
|
delete transparentSocket;
|
|
|
|
}
|
|
|
|
|
2019-01-10 09:05:15 +00:00
|
|
|
if (m_remoteControl != NULL) {
|
|
|
|
m_remoteControl->close();
|
|
|
|
delete m_remoteControl;
|
2019-01-07 11:03:37 +00:00
|
|
|
}
|
|
|
|
|
2019-01-10 09:05:15 +00:00
|
|
|
delete m_dstar;
|
|
|
|
delete m_dmr;
|
|
|
|
delete m_ysf;
|
|
|
|
delete m_p25;
|
|
|
|
delete m_nxdn;
|
2019-01-10 14:03:23 +00:00
|
|
|
delete m_pocsag;
|
2016-01-14 18:45:04 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CMMDVMHost::createModem()
|
|
|
|
{
|
2018-06-12 18:40:49 +00:00
|
|
|
std::string port = m_conf.getModemPort();
|
2018-07-19 13:09:00 +00:00
|
|
|
std::string protocol = m_conf.getModemProtocol();
|
|
|
|
unsigned int address = m_conf.getModemAddress();
|
2018-06-12 18:40:49 +00:00
|
|
|
bool rxInvert = m_conf.getModemRXInvert();
|
|
|
|
bool txInvert = m_conf.getModemTXInvert();
|
|
|
|
bool pttInvert = m_conf.getModemPTTInvert();
|
|
|
|
unsigned int txDelay = m_conf.getModemTXDelay();
|
|
|
|
unsigned int dmrDelay = m_conf.getModemDMRDelay();
|
|
|
|
float rxLevel = m_conf.getModemRXLevel();
|
|
|
|
float cwIdTXLevel = m_conf.getModemCWIdTXLevel();
|
|
|
|
float dstarTXLevel = m_conf.getModemDStarTXLevel();
|
|
|
|
float dmrTXLevel = m_conf.getModemDMRTXLevel();
|
|
|
|
float ysfTXLevel = m_conf.getModemYSFTXLevel();
|
|
|
|
float p25TXLevel = m_conf.getModemP25TXLevel();
|
|
|
|
float nxdnTXLevel = m_conf.getModemNXDNTXLevel();
|
|
|
|
float pocsagTXLevel = m_conf.getModemPOCSAGTXLevel();
|
|
|
|
bool trace = m_conf.getModemTrace();
|
|
|
|
bool debug = m_conf.getModemDebug();
|
|
|
|
unsigned int colorCode = m_conf.getDMRColorCode();
|
|
|
|
bool lowDeviation = m_conf.getFusionLowDeviation();
|
|
|
|
unsigned int txHang = m_conf.getFusionTXHang();
|
|
|
|
unsigned int rxFrequency = m_conf.getRXFrequency();
|
|
|
|
unsigned int txFrequency = m_conf.getTXFrequency();
|
|
|
|
unsigned int pocsagFrequency = m_conf.getPOCSAGFrequency();
|
|
|
|
int rxOffset = m_conf.getModemRXOffset();
|
|
|
|
int txOffset = m_conf.getModemTXOffset();
|
|
|
|
int rxDCOffset = m_conf.getModemRXDCOffset();
|
|
|
|
int txDCOffset = m_conf.getModemTXDCOffset();
|
|
|
|
float rfLevel = m_conf.getModemRFLevel();
|
2016-01-14 18:45:04 +00:00
|
|
|
|
|
|
|
LogInfo("Modem Parameters");
|
|
|
|
LogInfo(" Port: %s", port.c_str());
|
2018-07-19 13:09:00 +00:00
|
|
|
LogInfo(" Protocol: %s", protocol.c_str());
|
2018-07-19 17:42:23 +00:00
|
|
|
if (protocol == "i2c")
|
|
|
|
LogInfo(" i2c Address: %02X", address);
|
2016-01-14 18:45:04 +00:00
|
|
|
LogInfo(" RX Invert: %s", rxInvert ? "yes" : "no");
|
|
|
|
LogInfo(" TX Invert: %s", txInvert ? "yes" : "no");
|
|
|
|
LogInfo(" PTT Invert: %s", pttInvert ? "yes" : "no");
|
2016-03-17 18:12:14 +00:00
|
|
|
LogInfo(" TX Delay: %ums", txDelay);
|
2017-06-14 15:44:23 +00:00
|
|
|
LogInfo(" RX Offset: %dHz", rxOffset);
|
|
|
|
LogInfo(" TX Offset: %dHz", txOffset);
|
2017-10-28 11:37:32 +00:00
|
|
|
LogInfo(" RX DC Offset: %d", rxDCOffset);
|
2017-08-20 11:07:57 +00:00
|
|
|
LogInfo(" TX DC Offset: %d", txDCOffset);
|
2017-12-30 15:05:11 +00:00
|
|
|
LogInfo(" RF Level: %.1f%%", rfLevel);
|
2016-03-21 21:50:45 +00:00
|
|
|
LogInfo(" DMR Delay: %u (%.1fms)", dmrDelay, float(dmrDelay) * 0.0416666F);
|
2017-06-02 15:34:55 +00:00
|
|
|
LogInfo(" RX Level: %.1f%%", rxLevel);
|
|
|
|
LogInfo(" CW Id TX Level: %.1f%%", cwIdTXLevel);
|
|
|
|
LogInfo(" D-Star TX Level: %.1f%%", dstarTXLevel);
|
|
|
|
LogInfo(" DMR TX Level: %.1f%%", dmrTXLevel);
|
|
|
|
LogInfo(" YSF TX Level: %.1f%%", ysfTXLevel);
|
|
|
|
LogInfo(" P25 TX Level: %.1f%%", p25TXLevel);
|
2018-01-11 19:35:33 +00:00
|
|
|
LogInfo(" NXDN TX Level: %.1f%%", nxdnTXLevel);
|
2018-06-07 17:46:03 +00:00
|
|
|
LogInfo(" POCSAG TX Level: %.1f%%", pocsagTXLevel);
|
2017-06-14 15:44:23 +00:00
|
|
|
LogInfo(" RX Frequency: %uHz (%uHz)", rxFrequency, rxFrequency + rxOffset);
|
|
|
|
LogInfo(" TX Frequency: %uHz (%uHz)", txFrequency, txFrequency + txOffset);
|
2016-01-14 18:45:04 +00:00
|
|
|
|
2018-12-07 09:36:11 +00:00
|
|
|
m_modem = CModem::createModem(port, m_duplex, rxInvert, txInvert, pttInvert, txDelay, dmrDelay, trace, debug);
|
2018-07-30 13:58:35 +00:00
|
|
|
m_modem->setSerialParams(protocol,address);
|
2018-06-07 17:46:03 +00:00
|
|
|
m_modem->setModeParams(m_dstarEnabled, m_dmrEnabled, m_ysfEnabled, m_p25Enabled, m_nxdnEnabled, m_pocsagEnabled);
|
|
|
|
m_modem->setLevels(rxLevel, cwIdTXLevel, dstarTXLevel, dmrTXLevel, ysfTXLevel, p25TXLevel, nxdnTXLevel, pocsagTXLevel);
|
2018-06-12 18:40:49 +00:00
|
|
|
m_modem->setRFParams(rxFrequency, rxOffset, txFrequency, txOffset, txDCOffset, rxDCOffset, rfLevel, pocsagFrequency);
|
2016-01-14 18:45:04 +00:00
|
|
|
m_modem->setDMRParams(colorCode);
|
2018-05-21 20:32:33 +00:00
|
|
|
m_modem->setYSFParams(lowDeviation, txHang);
|
2016-01-14 18:45:04 +00:00
|
|
|
|
|
|
|
bool ret = m_modem->open();
|
|
|
|
if (!ret) {
|
|
|
|
delete m_modem;
|
|
|
|
m_modem = NULL;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-01-25 21:00:19 +00:00
|
|
|
bool CMMDVMHost::createDStarNetwork()
|
|
|
|
{
|
|
|
|
std::string gatewayAddress = m_conf.getDStarGatewayAddress();
|
2017-09-01 08:25:54 +00:00
|
|
|
unsigned int gatewayPort = m_conf.getDStarGatewayPort();
|
|
|
|
unsigned int localPort = m_conf.getDStarLocalPort();
|
|
|
|
bool debug = m_conf.getDStarNetworkDebug();
|
|
|
|
m_dstarNetModeHang = m_conf.getDStarNetworkModeHang();
|
2016-01-25 21:00:19 +00:00
|
|
|
|
|
|
|
LogInfo("D-Star Network Parameters");
|
|
|
|
LogInfo(" Gateway Address: %s", gatewayAddress.c_str());
|
|
|
|
LogInfo(" Gateway Port: %u", gatewayPort);
|
|
|
|
LogInfo(" Local Port: %u", localPort);
|
2017-09-01 08:25:54 +00:00
|
|
|
LogInfo(" Mode Hang: %us", m_dstarNetModeHang);
|
2016-01-25 21:00:19 +00:00
|
|
|
|
2016-03-08 17:26:51 +00:00
|
|
|
m_dstarNetwork = new CDStarNetwork(gatewayAddress, gatewayPort, localPort, m_duplex, VERSION, debug);
|
2016-01-25 21:00:19 +00:00
|
|
|
|
|
|
|
bool ret = m_dstarNetwork->open();
|
|
|
|
if (!ret) {
|
|
|
|
delete m_dstarNetwork;
|
|
|
|
m_dstarNetwork = NULL;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
m_dstarNetwork->enable(true);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-01-14 18:45:04 +00:00
|
|
|
bool CMMDVMHost::createDMRNetwork()
|
|
|
|
{
|
|
|
|
std::string address = m_conf.getDMRNetworkAddress();
|
|
|
|
unsigned int port = m_conf.getDMRNetworkPort();
|
2016-04-03 18:11:45 +00:00
|
|
|
unsigned int local = m_conf.getDMRNetworkLocal();
|
2016-01-14 18:45:04 +00:00
|
|
|
unsigned int id = m_conf.getDMRId();
|
|
|
|
std::string password = m_conf.getDMRNetworkPassword();
|
|
|
|
bool debug = m_conf.getDMRNetworkDebug();
|
2016-09-06 18:42:15 +00:00
|
|
|
unsigned int jitter = m_conf.getDMRNetworkJitter();
|
2016-02-15 20:36:05 +00:00
|
|
|
bool slot1 = m_conf.getDMRNetworkSlot1();
|
|
|
|
bool slot2 = m_conf.getDMRNetworkSlot2();
|
2016-09-05 16:40:43 +00:00
|
|
|
HW_TYPE hwType = m_modem->getHWType();
|
2017-09-01 08:25:54 +00:00
|
|
|
m_dmrNetModeHang = m_conf.getDMRNetworkModeHang();
|
2016-01-14 18:45:04 +00:00
|
|
|
|
|
|
|
LogInfo("DMR Network Parameters");
|
|
|
|
LogInfo(" Address: %s", address.c_str());
|
|
|
|
LogInfo(" Port: %u", port);
|
2016-04-03 18:11:45 +00:00
|
|
|
if (local > 0U)
|
|
|
|
LogInfo(" Local: %u", local);
|
|
|
|
else
|
|
|
|
LogInfo(" Local: random");
|
2016-09-06 18:42:15 +00:00
|
|
|
LogInfo(" Jitter: %ums", jitter);
|
2016-02-15 20:36:05 +00:00
|
|
|
LogInfo(" Slot 1: %s", slot1 ? "enabled" : "disabled");
|
|
|
|
LogInfo(" Slot 2: %s", slot2 ? "enabled" : "disabled");
|
2017-09-01 08:25:54 +00:00
|
|
|
LogInfo(" Mode Hang: %us", m_dmrNetModeHang);
|
2016-01-14 18:45:04 +00:00
|
|
|
|
2019-11-03 22:17:51 +00:00
|
|
|
m_dmrNetwork = new CDMRNetwork(address, port, local, id, password, m_duplex, VERSION, debug, slot1, slot2, hwType, jitter);
|
2016-01-14 18:45:04 +00:00
|
|
|
|
2016-11-03 19:27:52 +00:00
|
|
|
std::string options = m_conf.getDMRNetworkOptions();
|
|
|
|
if (!options.empty()) {
|
|
|
|
LogInfo(" Options: %s", options.c_str());
|
|
|
|
m_dmrNetwork->setOptions(options);
|
|
|
|
}
|
|
|
|
|
2017-08-20 11:07:57 +00:00
|
|
|
unsigned int rxFrequency = m_conf.getRXFrequency();
|
|
|
|
unsigned int txFrequency = m_conf.getTXFrequency();
|
2016-01-14 18:45:04 +00:00
|
|
|
unsigned int power = m_conf.getPower();
|
|
|
|
unsigned int colorCode = m_conf.getDMRColorCode();
|
|
|
|
float latitude = m_conf.getLatitude();
|
|
|
|
float longitude = m_conf.getLongitude();
|
|
|
|
int height = m_conf.getHeight();
|
|
|
|
std::string location = m_conf.getLocation();
|
|
|
|
std::string description = m_conf.getDescription();
|
|
|
|
std::string url = m_conf.getURL();
|
|
|
|
|
|
|
|
LogInfo("Info Parameters");
|
2016-05-09 20:55:44 +00:00
|
|
|
LogInfo(" Callsign: %s", m_callsign.c_str());
|
2016-01-14 18:45:04 +00:00
|
|
|
LogInfo(" RX Frequency: %uHz", rxFrequency);
|
|
|
|
LogInfo(" TX Frequency: %uHz", txFrequency);
|
|
|
|
LogInfo(" Power: %uW", power);
|
|
|
|
LogInfo(" Latitude: %fdeg N", latitude);
|
|
|
|
LogInfo(" Longitude: %fdeg E", longitude);
|
|
|
|
LogInfo(" Height: %um", height);
|
|
|
|
LogInfo(" Location: \"%s\"", location.c_str());
|
|
|
|
LogInfo(" Description: \"%s\"", description.c_str());
|
|
|
|
LogInfo(" URL: \"%s\"", url.c_str());
|
|
|
|
|
2016-05-09 20:55:44 +00:00
|
|
|
m_dmrNetwork->setConfig(m_callsign, rxFrequency, txFrequency, power, colorCode, latitude, longitude, height, location, description, url);
|
2016-01-14 18:45:04 +00:00
|
|
|
|
|
|
|
bool ret = m_dmrNetwork->open();
|
|
|
|
if (!ret) {
|
|
|
|
delete m_dmrNetwork;
|
|
|
|
m_dmrNetwork = NULL;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-11-06 12:14:57 +00:00
|
|
|
bool mobileGPSEnabled = m_conf.getMobileGPSEnabled();
|
|
|
|
if (mobileGPSEnabled) {
|
|
|
|
std::string mobileGPSAddress = m_conf.getMobileGPSAddress();
|
|
|
|
unsigned int mobileGPSPort = m_conf.getMobileGPSPort();
|
|
|
|
|
|
|
|
LogInfo("Mobile GPS Parameters");
|
|
|
|
LogInfo(" Address: %s", mobileGPSAddress.c_str());
|
2019-01-23 09:09:34 +00:00
|
|
|
LogInfo(" Port: %u", mobileGPSPort);
|
2018-11-06 12:14:57 +00:00
|
|
|
|
|
|
|
m_mobileGPS = new CMobileGPS(address, port, m_dmrNetwork);
|
|
|
|
|
|
|
|
ret = m_mobileGPS->open();
|
|
|
|
if (!ret) {
|
|
|
|
delete m_mobileGPS;
|
|
|
|
m_mobileGPS = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-25 18:11:44 +00:00
|
|
|
m_dmrNetwork->enable(true);
|
|
|
|
|
2016-01-14 18:45:04 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-05-16 20:57:32 +00:00
|
|
|
bool CMMDVMHost::createYSFNetwork()
|
|
|
|
{
|
2016-06-07 20:17:57 +00:00
|
|
|
std::string myAddress = m_conf.getFusionNetworkMyAddress();
|
|
|
|
unsigned int myPort = m_conf.getFusionNetworkMyPort();
|
2017-11-09 22:17:25 +00:00
|
|
|
std::string gatewayAddress = m_conf.getFusionNetworkGatewayAddress();
|
|
|
|
unsigned int gatewayPort = m_conf.getFusionNetworkGatewayPort();
|
2017-09-01 08:25:54 +00:00
|
|
|
m_ysfNetModeHang = m_conf.getFusionNetworkModeHang();
|
2016-06-07 20:17:57 +00:00
|
|
|
bool debug = m_conf.getFusionNetworkDebug();
|
2016-05-16 20:57:32 +00:00
|
|
|
|
|
|
|
LogInfo("System Fusion Network Parameters");
|
2016-06-07 20:17:57 +00:00
|
|
|
LogInfo(" Local Address: %s", myAddress.c_str());
|
|
|
|
LogInfo(" Local Port: %u", myPort);
|
2017-11-09 22:17:25 +00:00
|
|
|
LogInfo(" Gateway Address: %s", gatewayAddress.c_str());
|
|
|
|
LogInfo(" Gateway Port: %u", gatewayPort);
|
2017-09-01 08:25:54 +00:00
|
|
|
LogInfo(" Mode Hang: %us", m_ysfNetModeHang);
|
2016-05-16 20:57:32 +00:00
|
|
|
|
2017-11-09 22:17:25 +00:00
|
|
|
m_ysfNetwork = new CYSFNetwork(myAddress, myPort, gatewayAddress, gatewayPort, m_callsign, debug);
|
2016-05-16 20:57:32 +00:00
|
|
|
|
|
|
|
bool ret = m_ysfNetwork->open();
|
|
|
|
if (!ret) {
|
|
|
|
delete m_ysfNetwork;
|
|
|
|
m_ysfNetwork = NULL;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
m_ysfNetwork->enable(true);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-09-14 06:41:37 +00:00
|
|
|
bool CMMDVMHost::createP25Network()
|
|
|
|
{
|
|
|
|
std::string gatewayAddress = m_conf.getP25GatewayAddress();
|
|
|
|
unsigned int gatewayPort = m_conf.getP25GatewayPort();
|
|
|
|
unsigned int localPort = m_conf.getP25LocalPort();
|
2017-09-01 08:25:54 +00:00
|
|
|
m_p25NetModeHang = m_conf.getP25NetworkModeHang();
|
2016-09-14 06:41:37 +00:00
|
|
|
bool debug = m_conf.getP25NetworkDebug();
|
|
|
|
|
|
|
|
LogInfo("P25 Network Parameters");
|
|
|
|
LogInfo(" Gateway Address: %s", gatewayAddress.c_str());
|
|
|
|
LogInfo(" Gateway Port: %u", gatewayPort);
|
|
|
|
LogInfo(" Local Port: %u", localPort);
|
2017-09-01 08:25:54 +00:00
|
|
|
LogInfo(" Mode Hang: %us", m_p25NetModeHang);
|
2016-09-14 06:41:37 +00:00
|
|
|
|
|
|
|
m_p25Network = new CP25Network(gatewayAddress, gatewayPort, localPort, debug);
|
|
|
|
|
|
|
|
bool ret = m_p25Network->open();
|
|
|
|
if (!ret) {
|
|
|
|
delete m_p25Network;
|
|
|
|
m_p25Network = NULL;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
m_p25Network->enable(true);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-01-15 21:03:34 +00:00
|
|
|
bool CMMDVMHost::createNXDNNetwork()
|
|
|
|
{
|
2018-03-12 20:55:53 +00:00
|
|
|
std::string gatewayAddress = m_conf.getNXDNGatewayAddress();
|
|
|
|
unsigned int gatewayPort = m_conf.getNXDNGatewayPort();
|
|
|
|
std::string localAddress = m_conf.getNXDNLocalAddress();
|
|
|
|
unsigned int localPort = m_conf.getNXDNLocalPort();
|
|
|
|
m_nxdnNetModeHang = m_conf.getNXDNNetworkModeHang();
|
|
|
|
bool debug = m_conf.getNXDNNetworkDebug();
|
2018-01-15 21:03:34 +00:00
|
|
|
|
|
|
|
LogInfo("NXDN Network Parameters");
|
2018-03-12 20:55:53 +00:00
|
|
|
LogInfo(" Gateway Address: %s", gatewayAddress.c_str());
|
|
|
|
LogInfo(" Gateway Port: %u", gatewayPort);
|
|
|
|
LogInfo(" Local Address: %s", localAddress.c_str());
|
|
|
|
LogInfo(" Local Port: %u", localPort);
|
2018-01-15 21:03:34 +00:00
|
|
|
LogInfo(" Mode Hang: %us", m_nxdnNetModeHang);
|
|
|
|
|
2018-03-12 20:55:53 +00:00
|
|
|
m_nxdnNetwork = new CNXDNNetwork(localAddress, localPort, gatewayAddress, gatewayPort, debug);
|
2018-01-15 21:03:34 +00:00
|
|
|
|
|
|
|
bool ret = m_nxdnNetwork->open();
|
|
|
|
if (!ret) {
|
|
|
|
delete m_nxdnNetwork;
|
|
|
|
m_nxdnNetwork = NULL;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
m_nxdnNetwork->enable(true);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-06-07 17:46:03 +00:00
|
|
|
bool CMMDVMHost::createPOCSAGNetwork()
|
|
|
|
{
|
|
|
|
std::string gatewayAddress = m_conf.getPOCSAGGatewayAddress();
|
|
|
|
unsigned int gatewayPort = m_conf.getPOCSAGGatewayPort();
|
|
|
|
std::string localAddress = m_conf.getPOCSAGLocalAddress();
|
|
|
|
unsigned int localPort = m_conf.getPOCSAGLocalPort();
|
|
|
|
m_pocsagNetModeHang = m_conf.getPOCSAGNetworkModeHang();
|
|
|
|
bool debug = m_conf.getPOCSAGNetworkDebug();
|
|
|
|
|
|
|
|
LogInfo("POCSAG Network Parameters");
|
|
|
|
LogInfo(" Gateway Address: %s", gatewayAddress.c_str());
|
|
|
|
LogInfo(" Gateway Port: %u", gatewayPort);
|
|
|
|
LogInfo(" Local Address: %s", localAddress.c_str());
|
|
|
|
LogInfo(" Local Port: %u", localPort);
|
|
|
|
LogInfo(" Mode Hang: %us", m_pocsagNetModeHang);
|
|
|
|
|
|
|
|
m_pocsagNetwork = new CPOCSAGNetwork(localAddress, localPort, gatewayAddress, gatewayPort, debug);
|
|
|
|
|
|
|
|
bool ret = m_pocsagNetwork->open();
|
|
|
|
if (!ret) {
|
|
|
|
delete m_pocsagNetwork;
|
|
|
|
m_pocsagNetwork = NULL;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
m_pocsagNetwork->enable(true);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-01-14 18:45:04 +00:00
|
|
|
void CMMDVMHost::readParams()
|
|
|
|
{
|
2018-06-07 17:46:03 +00:00
|
|
|
m_dstarEnabled = m_conf.getDStarEnabled();
|
|
|
|
m_dmrEnabled = m_conf.getDMREnabled();
|
|
|
|
m_ysfEnabled = m_conf.getFusionEnabled();
|
|
|
|
m_p25Enabled = m_conf.getP25Enabled();
|
|
|
|
m_nxdnEnabled = m_conf.getNXDNEnabled();
|
|
|
|
m_pocsagEnabled = m_conf.getPOCSAGEnabled();
|
|
|
|
m_duplex = m_conf.getDuplex();
|
|
|
|
m_callsign = m_conf.getCallsign();
|
|
|
|
m_id = m_conf.getId();
|
|
|
|
m_timeout = m_conf.getTimeout();
|
2016-06-22 17:03:56 +00:00
|
|
|
|
|
|
|
LogInfo("General Parameters");
|
|
|
|
LogInfo(" Callsign: %s", m_callsign.c_str());
|
2017-08-19 15:23:37 +00:00
|
|
|
LogInfo(" Id: %u", m_id);
|
2016-06-22 17:03:56 +00:00
|
|
|
LogInfo(" Duplex: %s", m_duplex ? "yes" : "no");
|
|
|
|
LogInfo(" Timeout: %us", m_timeout);
|
|
|
|
LogInfo(" D-Star: %s", m_dstarEnabled ? "enabled" : "disabled");
|
|
|
|
LogInfo(" DMR: %s", m_dmrEnabled ? "enabled" : "disabled");
|
|
|
|
LogInfo(" YSF: %s", m_ysfEnabled ? "enabled" : "disabled");
|
2016-09-08 17:38:59 +00:00
|
|
|
LogInfo(" P25: %s", m_p25Enabled ? "enabled" : "disabled");
|
2018-01-11 19:35:33 +00:00
|
|
|
LogInfo(" NXDN: %s", m_nxdnEnabled ? "enabled" : "disabled");
|
2018-06-07 17:46:03 +00:00
|
|
|
LogInfo(" POCSAG: %s", m_pocsagEnabled ? "enabled" : "disabled");
|
2016-01-14 18:45:04 +00:00
|
|
|
}
|
|
|
|
|
2016-05-10 17:26:52 +00:00
|
|
|
void CMMDVMHost::setMode(unsigned char mode)
|
2016-02-02 18:17:36 +00:00
|
|
|
{
|
|
|
|
assert(m_modem != NULL);
|
|
|
|
assert(m_display != NULL);
|
|
|
|
|
|
|
|
switch (mode) {
|
|
|
|
case MODE_DSTAR:
|
2019-01-19 21:28:58 +00:00
|
|
|
if (m_dstarNetwork != NULL)
|
|
|
|
m_dstarNetwork->enable(true);
|
2016-02-02 18:17:36 +00:00
|
|
|
if (m_dmrNetwork != NULL)
|
|
|
|
m_dmrNetwork->enable(false);
|
2016-05-16 20:57:32 +00:00
|
|
|
if (m_ysfNetwork != NULL)
|
|
|
|
m_ysfNetwork->enable(false);
|
2016-09-14 06:41:37 +00:00
|
|
|
if (m_p25Network != NULL)
|
|
|
|
m_p25Network->enable(false);
|
2018-01-15 21:03:34 +00:00
|
|
|
if (m_nxdnNetwork != NULL)
|
|
|
|
m_nxdnNetwork->enable(false);
|
2018-06-07 17:46:03 +00:00
|
|
|
if (m_pocsagNetwork != NULL)
|
|
|
|
m_pocsagNetwork->enable(false);
|
2019-01-19 21:28:58 +00:00
|
|
|
if (m_dstar != NULL)
|
|
|
|
m_dstar->enable(true);
|
2019-01-19 17:15:24 +00:00
|
|
|
if (m_dmr != NULL)
|
|
|
|
m_dmr->enable(false);
|
|
|
|
if (m_ysf != NULL)
|
|
|
|
m_ysf->enable(false);
|
|
|
|
if (m_p25 != NULL)
|
|
|
|
m_p25->enable(false);
|
|
|
|
if (m_nxdn != NULL)
|
|
|
|
m_nxdn->enable(false);
|
|
|
|
if (m_pocsag != NULL)
|
|
|
|
m_pocsag->enable(false);
|
2016-02-02 18:17:36 +00:00
|
|
|
m_modem->setMode(MODE_DSTAR);
|
2016-11-03 19:07:44 +00:00
|
|
|
if (m_ump != NULL)
|
|
|
|
m_ump->setMode(MODE_DSTAR);
|
2016-02-02 18:17:36 +00:00
|
|
|
m_mode = MODE_DSTAR;
|
|
|
|
m_modeTimer.start();
|
2016-10-17 17:01:38 +00:00
|
|
|
m_cwIdTimer.stop();
|
2018-10-11 06:50:30 +00:00
|
|
|
createLockFile("D-Star");
|
2016-02-02 18:17:36 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case MODE_DMR:
|
|
|
|
if (m_dstarNetwork != NULL)
|
|
|
|
m_dstarNetwork->enable(false);
|
2019-01-19 21:28:58 +00:00
|
|
|
if (m_dmrNetwork != NULL)
|
|
|
|
m_dmrNetwork->enable(true);
|
2016-05-16 20:57:32 +00:00
|
|
|
if (m_ysfNetwork != NULL)
|
|
|
|
m_ysfNetwork->enable(false);
|
2016-09-14 06:41:37 +00:00
|
|
|
if (m_p25Network != NULL)
|
|
|
|
m_p25Network->enable(false);
|
2018-01-15 21:03:34 +00:00
|
|
|
if (m_nxdnNetwork != NULL)
|
|
|
|
m_nxdnNetwork->enable(false);
|
2018-06-07 17:46:03 +00:00
|
|
|
if (m_pocsagNetwork != NULL)
|
|
|
|
m_pocsagNetwork->enable(false);
|
2019-01-19 17:15:24 +00:00
|
|
|
if (m_dstar != NULL)
|
|
|
|
m_dstar->enable(false);
|
2019-01-19 21:28:58 +00:00
|
|
|
if (m_dmr != NULL)
|
|
|
|
m_dmr->enable(true);
|
2019-01-19 17:15:24 +00:00
|
|
|
if (m_ysf != NULL)
|
|
|
|
m_ysf->enable(false);
|
|
|
|
if (m_p25 != NULL)
|
|
|
|
m_p25->enable(false);
|
|
|
|
if (m_nxdn != NULL)
|
|
|
|
m_nxdn->enable(false);
|
|
|
|
if (m_pocsag != NULL)
|
|
|
|
m_pocsag->enable(false);
|
2016-03-29 16:59:15 +00:00
|
|
|
m_modem->setMode(MODE_DMR);
|
2016-11-03 19:07:44 +00:00
|
|
|
if (m_ump != NULL)
|
|
|
|
m_ump->setMode(MODE_DMR);
|
2016-05-05 16:56:18 +00:00
|
|
|
if (m_duplex) {
|
2016-03-25 20:54:51 +00:00
|
|
|
m_modem->writeDMRStart(true);
|
2016-05-05 16:56:18 +00:00
|
|
|
m_dmrTXTimer.start();
|
|
|
|
}
|
2016-02-02 18:17:36 +00:00
|
|
|
m_mode = MODE_DMR;
|
|
|
|
m_modeTimer.start();
|
2016-10-17 17:01:38 +00:00
|
|
|
m_cwIdTimer.stop();
|
2018-10-11 06:50:30 +00:00
|
|
|
createLockFile("DMR");
|
2016-02-02 18:17:36 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case MODE_YSF:
|
|
|
|
if (m_dstarNetwork != NULL)
|
|
|
|
m_dstarNetwork->enable(false);
|
|
|
|
if (m_dmrNetwork != NULL)
|
|
|
|
m_dmrNetwork->enable(false);
|
2019-01-19 21:28:58 +00:00
|
|
|
if (m_ysfNetwork != NULL)
|
|
|
|
m_ysfNetwork->enable(true);
|
2016-09-14 06:41:37 +00:00
|
|
|
if (m_p25Network != NULL)
|
|
|
|
m_p25Network->enable(false);
|
2018-01-15 21:03:34 +00:00
|
|
|
if (m_nxdnNetwork != NULL)
|
|
|
|
m_nxdnNetwork->enable(false);
|
2018-06-07 17:46:03 +00:00
|
|
|
if (m_pocsagNetwork != NULL)
|
|
|
|
m_pocsagNetwork->enable(false);
|
2019-01-19 17:15:24 +00:00
|
|
|
if (m_dstar != NULL)
|
|
|
|
m_dstar->enable(false);
|
|
|
|
if (m_dmr != NULL)
|
|
|
|
m_dmr->enable(false);
|
2019-01-19 21:28:58 +00:00
|
|
|
if (m_ysf != NULL)
|
|
|
|
m_ysf->enable(true);
|
2019-01-19 17:15:24 +00:00
|
|
|
if (m_p25 != NULL)
|
|
|
|
m_p25->enable(false);
|
|
|
|
if (m_nxdn != NULL)
|
|
|
|
m_nxdn->enable(false);
|
|
|
|
if (m_pocsag != NULL)
|
|
|
|
m_pocsag->enable(false);
|
2016-02-02 18:17:36 +00:00
|
|
|
m_modem->setMode(MODE_YSF);
|
2016-11-03 19:07:44 +00:00
|
|
|
if (m_ump != NULL)
|
|
|
|
m_ump->setMode(MODE_YSF);
|
2016-02-02 18:17:36 +00:00
|
|
|
m_mode = MODE_YSF;
|
|
|
|
m_modeTimer.start();
|
2016-10-17 17:01:38 +00:00
|
|
|
m_cwIdTimer.stop();
|
2018-10-11 06:50:30 +00:00
|
|
|
createLockFile("System Fusion");
|
2016-02-02 18:17:36 +00:00
|
|
|
break;
|
|
|
|
|
2016-09-08 17:38:59 +00:00
|
|
|
case MODE_P25:
|
|
|
|
if (m_dstarNetwork != NULL)
|
|
|
|
m_dstarNetwork->enable(false);
|
|
|
|
if (m_dmrNetwork != NULL)
|
|
|
|
m_dmrNetwork->enable(false);
|
|
|
|
if (m_ysfNetwork != NULL)
|
|
|
|
m_ysfNetwork->enable(false);
|
2019-01-19 21:28:58 +00:00
|
|
|
if (m_p25Network != NULL)
|
|
|
|
m_p25Network->enable(true);
|
2018-01-15 21:03:34 +00:00
|
|
|
if (m_nxdnNetwork != NULL)
|
|
|
|
m_nxdnNetwork->enable(false);
|
2018-06-07 17:46:03 +00:00
|
|
|
if (m_pocsagNetwork != NULL)
|
|
|
|
m_pocsagNetwork->enable(false);
|
2019-01-19 17:15:24 +00:00
|
|
|
if (m_dstar != NULL)
|
|
|
|
m_dstar->enable(false);
|
|
|
|
if (m_dmr != NULL)
|
|
|
|
m_dmr->enable(false);
|
|
|
|
if (m_ysf != NULL)
|
|
|
|
m_ysf->enable(false);
|
2019-01-19 21:28:58 +00:00
|
|
|
if (m_p25 != NULL)
|
|
|
|
m_p25->enable(true);
|
2019-01-19 17:15:24 +00:00
|
|
|
if (m_nxdn != NULL)
|
|
|
|
m_nxdn->enable(false);
|
|
|
|
if (m_pocsag != NULL)
|
|
|
|
m_pocsag->enable(false);
|
2016-09-08 17:38:59 +00:00
|
|
|
m_modem->setMode(MODE_P25);
|
2016-11-03 19:07:44 +00:00
|
|
|
if (m_ump != NULL)
|
|
|
|
m_ump->setMode(MODE_P25);
|
2016-09-08 17:38:59 +00:00
|
|
|
m_mode = MODE_P25;
|
|
|
|
m_modeTimer.start();
|
2016-10-17 17:01:38 +00:00
|
|
|
m_cwIdTimer.stop();
|
2018-10-11 06:50:30 +00:00
|
|
|
createLockFile("P25");
|
2016-09-08 17:38:59 +00:00
|
|
|
break;
|
|
|
|
|
2018-01-11 19:35:33 +00:00
|
|
|
case MODE_NXDN:
|
|
|
|
if (m_dstarNetwork != NULL)
|
|
|
|
m_dstarNetwork->enable(false);
|
|
|
|
if (m_dmrNetwork != NULL)
|
|
|
|
m_dmrNetwork->enable(false);
|
|
|
|
if (m_ysfNetwork != NULL)
|
|
|
|
m_ysfNetwork->enable(false);
|
|
|
|
if (m_p25Network != NULL)
|
|
|
|
m_p25Network->enable(false);
|
2019-01-19 21:28:58 +00:00
|
|
|
if (m_nxdnNetwork != NULL)
|
|
|
|
m_nxdnNetwork->enable(true);
|
2018-06-07 17:46:03 +00:00
|
|
|
if (m_pocsagNetwork != NULL)
|
|
|
|
m_pocsagNetwork->enable(false);
|
2019-01-19 17:15:24 +00:00
|
|
|
if (m_dstar != NULL)
|
|
|
|
m_dstar->enable(false);
|
|
|
|
if (m_dmr != NULL)
|
|
|
|
m_dmr->enable(false);
|
|
|
|
if (m_ysf != NULL)
|
|
|
|
m_ysf->enable(false);
|
|
|
|
if (m_p25 != NULL)
|
|
|
|
m_p25->enable(false);
|
2019-01-19 21:28:58 +00:00
|
|
|
if (m_nxdn != NULL)
|
|
|
|
m_nxdn->enable(true);
|
2019-01-19 17:15:24 +00:00
|
|
|
if (m_pocsag != NULL)
|
|
|
|
m_pocsag->enable(false);
|
2018-01-11 19:35:33 +00:00
|
|
|
m_modem->setMode(MODE_NXDN);
|
|
|
|
if (m_ump != NULL)
|
|
|
|
m_ump->setMode(MODE_NXDN);
|
|
|
|
m_mode = MODE_NXDN;
|
|
|
|
m_modeTimer.start();
|
|
|
|
m_cwIdTimer.stop();
|
2018-10-11 06:50:30 +00:00
|
|
|
createLockFile("NXDN");
|
2018-01-11 19:35:33 +00:00
|
|
|
break;
|
|
|
|
|
2018-06-07 17:46:03 +00:00
|
|
|
case MODE_POCSAG:
|
|
|
|
if (m_dstarNetwork != NULL)
|
|
|
|
m_dstarNetwork->enable(false);
|
|
|
|
if (m_dmrNetwork != NULL)
|
|
|
|
m_dmrNetwork->enable(false);
|
|
|
|
if (m_ysfNetwork != NULL)
|
|
|
|
m_ysfNetwork->enable(false);
|
|
|
|
if (m_p25Network != NULL)
|
|
|
|
m_p25Network->enable(false);
|
|
|
|
if (m_nxdnNetwork != NULL)
|
|
|
|
m_nxdnNetwork->enable(false);
|
2019-01-19 21:28:58 +00:00
|
|
|
if (m_pocsagNetwork != NULL)
|
|
|
|
m_pocsagNetwork->enable(true);
|
2019-01-19 17:15:24 +00:00
|
|
|
if (m_dstar != NULL)
|
|
|
|
m_dstar->enable(false);
|
|
|
|
if (m_dmr != NULL)
|
|
|
|
m_dmr->enable(false);
|
|
|
|
if (m_ysf != NULL)
|
|
|
|
m_ysf->enable(false);
|
|
|
|
if (m_p25 != NULL)
|
|
|
|
m_p25->enable(false);
|
|
|
|
if (m_nxdn != NULL)
|
|
|
|
m_nxdn->enable(false);
|
2019-01-19 21:28:58 +00:00
|
|
|
if (m_pocsag != NULL)
|
|
|
|
m_pocsag->enable(true);
|
2018-06-07 17:46:03 +00:00
|
|
|
m_modem->setMode(MODE_POCSAG);
|
|
|
|
if (m_ump != NULL)
|
|
|
|
m_ump->setMode(MODE_POCSAG);
|
|
|
|
m_mode = MODE_POCSAG;
|
|
|
|
m_modeTimer.start();
|
|
|
|
m_cwIdTimer.stop();
|
2018-10-11 06:50:30 +00:00
|
|
|
createLockFile("POCSAG");
|
2018-06-07 17:46:03 +00:00
|
|
|
break;
|
|
|
|
|
2016-03-03 18:01:01 +00:00
|
|
|
case MODE_LOCKOUT:
|
2016-05-10 17:26:52 +00:00
|
|
|
LogMessage("Mode set to Lockout");
|
2016-03-03 18:01:01 +00:00
|
|
|
if (m_dstarNetwork != NULL)
|
|
|
|
m_dstarNetwork->enable(false);
|
|
|
|
if (m_dmrNetwork != NULL)
|
|
|
|
m_dmrNetwork->enable(false);
|
2016-05-16 20:57:32 +00:00
|
|
|
if (m_ysfNetwork != NULL)
|
|
|
|
m_ysfNetwork->enable(false);
|
2016-09-14 06:41:37 +00:00
|
|
|
if (m_p25Network != NULL)
|
|
|
|
m_p25Network->enable(false);
|
2018-01-15 21:03:34 +00:00
|
|
|
if (m_nxdnNetwork != NULL)
|
|
|
|
m_nxdnNetwork->enable(false);
|
2018-06-07 17:46:03 +00:00
|
|
|
if (m_pocsagNetwork != NULL)
|
|
|
|
m_pocsagNetwork->enable(false);
|
2019-01-19 17:15:24 +00:00
|
|
|
if (m_dstar != NULL)
|
|
|
|
m_dstar->enable(false);
|
|
|
|
if (m_dmr != NULL)
|
|
|
|
m_dmr->enable(false);
|
|
|
|
if (m_ysf != NULL)
|
|
|
|
m_ysf->enable(false);
|
|
|
|
if (m_p25 != NULL)
|
|
|
|
m_p25->enable(false);
|
|
|
|
if (m_nxdn != NULL)
|
|
|
|
m_nxdn->enable(false);
|
|
|
|
if (m_pocsag != NULL)
|
|
|
|
m_pocsag->enable(false);
|
2016-05-05 16:56:18 +00:00
|
|
|
if (m_mode == MODE_DMR && m_duplex && m_modem->hasTX()) {
|
2016-03-03 18:01:01 +00:00
|
|
|
m_modem->writeDMRStart(false);
|
2016-05-05 16:56:18 +00:00
|
|
|
m_dmrTXTimer.stop();
|
|
|
|
}
|
2016-03-29 16:59:15 +00:00
|
|
|
m_modem->setMode(MODE_IDLE);
|
2016-11-03 19:07:44 +00:00
|
|
|
if (m_ump != NULL)
|
|
|
|
m_ump->setMode(MODE_IDLE);
|
2016-03-03 18:01:01 +00:00
|
|
|
m_display->setLockout();
|
|
|
|
m_mode = MODE_LOCKOUT;
|
|
|
|
m_modeTimer.stop();
|
2016-05-09 20:55:44 +00:00
|
|
|
m_cwIdTimer.stop();
|
2018-10-11 06:50:30 +00:00
|
|
|
removeLockFile();
|
2016-03-03 18:01:01 +00:00
|
|
|
break;
|
|
|
|
|
2016-03-21 22:47:58 +00:00
|
|
|
case MODE_ERROR:
|
2016-05-10 17:26:52 +00:00
|
|
|
LogMessage("Mode set to Error");
|
2016-03-21 22:47:58 +00:00
|
|
|
if (m_dstarNetwork != NULL)
|
|
|
|
m_dstarNetwork->enable(false);
|
|
|
|
if (m_dmrNetwork != NULL)
|
|
|
|
m_dmrNetwork->enable(false);
|
2016-05-16 20:57:32 +00:00
|
|
|
if (m_ysfNetwork != NULL)
|
|
|
|
m_ysfNetwork->enable(false);
|
2016-09-14 06:41:37 +00:00
|
|
|
if (m_p25Network != NULL)
|
|
|
|
m_p25Network->enable(false);
|
2018-01-15 21:03:34 +00:00
|
|
|
if (m_nxdnNetwork != NULL)
|
|
|
|
m_nxdnNetwork->enable(false);
|
2018-06-07 17:46:03 +00:00
|
|
|
if (m_pocsagNetwork != NULL)
|
|
|
|
m_pocsagNetwork->enable(false);
|
2019-01-19 17:15:24 +00:00
|
|
|
if (m_dstar != NULL)
|
|
|
|
m_dstar->enable(false);
|
|
|
|
if (m_dmr != NULL)
|
|
|
|
m_dmr->enable(false);
|
|
|
|
if (m_ysf != NULL)
|
|
|
|
m_ysf->enable(false);
|
|
|
|
if (m_p25 != NULL)
|
|
|
|
m_p25->enable(false);
|
|
|
|
if (m_nxdn != NULL)
|
|
|
|
m_nxdn->enable(false);
|
|
|
|
if (m_pocsag != NULL)
|
|
|
|
m_pocsag->enable(false);
|
2016-05-05 16:56:18 +00:00
|
|
|
if (m_mode == MODE_DMR && m_duplex && m_modem->hasTX()) {
|
|
|
|
m_modem->writeDMRStart(false);
|
|
|
|
m_dmrTXTimer.stop();
|
|
|
|
}
|
2016-11-03 19:07:44 +00:00
|
|
|
if (m_ump != NULL)
|
|
|
|
m_ump->setMode(MODE_IDLE);
|
2016-03-21 22:47:58 +00:00
|
|
|
m_display->setError("MODEM");
|
|
|
|
m_mode = MODE_ERROR;
|
|
|
|
m_modeTimer.stop();
|
2016-05-09 20:55:44 +00:00
|
|
|
m_cwIdTimer.stop();
|
2018-10-11 06:50:30 +00:00
|
|
|
removeLockFile();
|
2016-03-21 22:47:58 +00:00
|
|
|
break;
|
|
|
|
|
2016-02-02 18:17:36 +00:00
|
|
|
default:
|
|
|
|
if (m_dstarNetwork != NULL)
|
|
|
|
m_dstarNetwork->enable(true);
|
|
|
|
if (m_dmrNetwork != NULL)
|
|
|
|
m_dmrNetwork->enable(true);
|
2016-05-16 20:57:32 +00:00
|
|
|
if (m_ysfNetwork != NULL)
|
|
|
|
m_ysfNetwork->enable(true);
|
2016-09-14 06:41:37 +00:00
|
|
|
if (m_p25Network != NULL)
|
|
|
|
m_p25Network->enable(true);
|
2018-01-15 21:03:34 +00:00
|
|
|
if (m_nxdnNetwork != NULL)
|
2018-02-08 00:19:51 +00:00
|
|
|
m_nxdnNetwork->enable(true);
|
2018-06-07 17:46:03 +00:00
|
|
|
if (m_pocsagNetwork != NULL)
|
|
|
|
m_pocsagNetwork->enable(true);
|
2019-01-19 17:15:24 +00:00
|
|
|
if (m_dstar != NULL)
|
2019-01-19 21:28:58 +00:00
|
|
|
m_dstar->enable(true);
|
2019-01-19 17:15:24 +00:00
|
|
|
if (m_dmr != NULL)
|
2019-01-19 21:28:58 +00:00
|
|
|
m_dmr->enable(true);
|
2019-01-19 17:15:24 +00:00
|
|
|
if (m_ysf != NULL)
|
2019-01-19 21:28:58 +00:00
|
|
|
m_ysf->enable(true);
|
2019-01-19 17:15:24 +00:00
|
|
|
if (m_p25 != NULL)
|
2019-01-19 21:28:58 +00:00
|
|
|
m_p25->enable(true);
|
2019-01-19 17:15:24 +00:00
|
|
|
if (m_nxdn != NULL)
|
2019-01-19 21:28:58 +00:00
|
|
|
m_nxdn->enable(true);
|
2019-01-19 17:15:24 +00:00
|
|
|
if (m_pocsag != NULL)
|
2019-01-19 21:28:58 +00:00
|
|
|
m_pocsag->enable(true);
|
2016-05-05 16:56:18 +00:00
|
|
|
if (m_mode == MODE_DMR && m_duplex && m_modem->hasTX()) {
|
2016-02-02 18:17:36 +00:00
|
|
|
m_modem->writeDMRStart(false);
|
2016-05-05 16:56:18 +00:00
|
|
|
m_dmrTXTimer.stop();
|
|
|
|
}
|
2016-03-29 16:59:15 +00:00
|
|
|
m_modem->setMode(MODE_IDLE);
|
2016-11-03 19:07:44 +00:00
|
|
|
if (m_ump != NULL)
|
|
|
|
m_ump->setMode(MODE_IDLE);
|
2017-03-07 13:39:41 +00:00
|
|
|
if (m_mode == MODE_ERROR) {
|
2016-05-12 17:04:50 +00:00
|
|
|
m_modem->sendCWId(m_callsign);
|
2016-10-17 17:01:38 +00:00
|
|
|
m_cwIdTimer.setTimeout(m_cwIdTime);
|
|
|
|
m_cwIdTimer.start();
|
|
|
|
} else {
|
|
|
|
m_cwIdTimer.setTimeout(m_cwIdTime / 4U);
|
2016-05-12 17:04:50 +00:00
|
|
|
m_cwIdTimer.start();
|
|
|
|
}
|
2016-02-02 18:17:36 +00:00
|
|
|
m_display->setIdle();
|
2018-10-11 06:50:30 +00:00
|
|
|
if (mode == MODE_QUIT)
|
2018-08-15 16:17:42 +00:00
|
|
|
m_display->setQuit();
|
2016-02-02 18:17:36 +00:00
|
|
|
m_mode = MODE_IDLE;
|
|
|
|
m_modeTimer.stop();
|
2018-10-10 19:05:24 +00:00
|
|
|
removeLockFile();
|
2016-02-02 18:17:36 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2018-10-10 19:05:24 +00:00
|
|
|
|
2018-10-11 06:50:30 +00:00
|
|
|
void CMMDVMHost::createLockFile(const char* mode) const
|
2018-10-10 19:05:24 +00:00
|
|
|
{
|
|
|
|
if (m_lockFileEnabled) {
|
2018-10-11 06:50:30 +00:00
|
|
|
FILE* fp = ::fopen(m_lockFileName.c_str(), "wt");
|
|
|
|
if (fp != NULL) {
|
|
|
|
::fprintf(fp, "%s\n", mode);
|
2018-10-10 19:05:24 +00:00
|
|
|
::fclose(fp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-11 06:50:30 +00:00
|
|
|
void CMMDVMHost::removeLockFile() const
|
2018-10-10 19:05:24 +00:00
|
|
|
{
|
2018-10-11 06:50:30 +00:00
|
|
|
if (m_lockFileEnabled)
|
|
|
|
::remove(m_lockFileName.c_str());
|
2018-10-10 19:05:24 +00:00
|
|
|
}
|
2018-10-11 06:50:30 +00:00
|
|
|
|
2019-01-10 09:05:15 +00:00
|
|
|
void CMMDVMHost::remoteControl()
|
|
|
|
{
|
2019-01-11 13:02:33 +00:00
|
|
|
if (m_remoteControl == NULL)
|
2019-01-10 09:05:15 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
REMOTE_COMMAND command = m_remoteControl->getCommand();
|
2019-01-22 14:56:15 +00:00
|
|
|
switch (command) {
|
2019-01-10 09:05:15 +00:00
|
|
|
case RCD_MODE_IDLE:
|
2019-01-22 14:38:38 +00:00
|
|
|
m_fixedMode = false;
|
|
|
|
setMode(MODE_IDLE);
|
2019-01-10 09:05:15 +00:00
|
|
|
break;
|
|
|
|
case RCD_MODE_LOCKOUT:
|
2019-01-22 14:38:38 +00:00
|
|
|
m_fixedMode = false;
|
|
|
|
setMode(MODE_LOCKOUT);
|
2019-01-10 09:05:15 +00:00
|
|
|
break;
|
|
|
|
case RCD_MODE_DSTAR:
|
2019-01-22 14:38:38 +00:00
|
|
|
if (m_dstar != NULL)
|
|
|
|
processModeCommand(MODE_DSTAR, m_dstarRFModeHang);
|
2019-01-10 09:05:15 +00:00
|
|
|
break;
|
|
|
|
case RCD_MODE_DMR:
|
2019-01-22 14:56:15 +00:00
|
|
|
if (m_dmr != NULL)
|
2019-01-22 14:38:38 +00:00
|
|
|
processModeCommand(MODE_DMR, m_dmrRFModeHang);
|
2019-01-10 09:05:15 +00:00
|
|
|
break;
|
|
|
|
case RCD_MODE_YSF:
|
2019-01-22 14:38:38 +00:00
|
|
|
if (m_ysf != NULL)
|
|
|
|
processModeCommand(MODE_YSF, m_ysfRFModeHang);
|
2019-01-10 09:05:15 +00:00
|
|
|
break;
|
|
|
|
case RCD_MODE_P25:
|
2019-01-22 14:38:38 +00:00
|
|
|
if (m_p25 != NULL)
|
|
|
|
processModeCommand(MODE_P25, m_p25RFModeHang);
|
2019-01-10 09:05:15 +00:00
|
|
|
break;
|
|
|
|
case RCD_MODE_NXDN:
|
2019-01-22 14:38:38 +00:00
|
|
|
if (m_nxdn != NULL)
|
|
|
|
processModeCommand(MODE_NXDN, m_nxdnRFModeHang);
|
2019-01-10 09:05:15 +00:00
|
|
|
break;
|
2019-01-22 21:33:49 +00:00
|
|
|
case RCD_PAGE:
|
|
|
|
if (m_pocsag != NULL) {
|
|
|
|
unsigned int ric = m_remoteControl->getArgUInt(0U);
|
|
|
|
std::string text;
|
|
|
|
for (unsigned int i = 1U; i < m_remoteControl->getArgCount(); i++) {
|
|
|
|
if (i > 1U)
|
|
|
|
text += " ";
|
|
|
|
text += m_remoteControl->getArgString(i);
|
|
|
|
}
|
|
|
|
m_pocsag->sendPage(ric, text);
|
|
|
|
}
|
2019-01-10 09:05:15 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2019-01-22 14:38:38 +00:00
|
|
|
|
|
|
|
void CMMDVMHost::processModeCommand(unsigned char mode, unsigned int timeout)
|
|
|
|
{
|
|
|
|
m_fixedMode = false;
|
|
|
|
m_modeTimer.setTimeout(timeout);
|
|
|
|
|
|
|
|
if (m_remoteControl->getArgCount() > 0U) {
|
|
|
|
if (m_remoteControl->getArgString(0U) == "fixed") {
|
|
|
|
m_fixedMode = true;
|
|
|
|
} else {
|
|
|
|
unsigned int t = m_remoteControl->getArgUInt(0U);
|
|
|
|
if (t > 0U)
|
|
|
|
m_modeTimer.setTimeout(t);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
setMode(mode);
|
|
|
|
}
|