enhance available options for P25 control data (enable/disable broadcast, enable/disable dedicated); enhance availablt options for RCON for enabling/disabling P25 CC dedicated and broadcast, as well as some remote debug enable/disable commands;

config.yml

@@ -46,8 +46,9 @@ protocols:
         control:
             enable: false
             ackRequests: true
-            continuous: false
+            dedicated: false
-            interval: 60
+            broadcast: true
+            interval: 300
             duration: 1
         voiceOnControl: false
         inhibitIllegal: false

dmr/Control.cpp

@@ -256,3 +256,16 @@ void Control::writeRF_Call_Alrt(uint32_t slotNo, uint32_t srcId, uint32_t dstId)
         break;
     }
 }
+
+/// <summary>
+/// Helper to change the debug and verbose state.
+/// </summary>
+/// <param name="debug">Flag indicating whether DMR debug is enabled.</param>
+/// <param name="verbose">Flag indicating whether DMR verbose logging is enabled.</param>
+void Control::setDebugVerbose(bool debug, bool verbose)
+{
+    m_debug = debug;
+    m_verbose = verbose;
+    m_slot1->setDebugVerbose(debug, verbose);
+    m_slot2->setDebugVerbose(debug, verbose);
+}

dmr/Control.h

@@ -83,6 +83,9 @@ namespace dmr
         /// <summary>Helper to write a DMR call alert packet on the RF interface.</summary>
         void writeRF_Call_Alrt(uint32_t slotNo, uint32_t srcId, uint32_t dstId);
 
+        /// <summary>Helper to change the debug and verbose state.</summary>
+        void setDebugVerbose(bool debug, bool verbose);
+
     private:
         uint32_t m_colorCode;
 

dmr/Slot.cpp

@@ -434,6 +434,17 @@ void Slot::init(uint32_t colorCode, bool embeddedLCOnly, bool dumpTAData, uint32
 // ---------------------------------------------------------------------------
 //  Private Class Members
 // ---------------------------------------------------------------------------
+/// <summary>
+/// Helper to change the debug and verbose state.
+/// </summary>
+/// <param name="debug">Flag indicating whether DMR debug is enabled.</param>
+/// <param name="verbose">Flag indicating whether DMR verbose logging is enabled.</param>
+void Slot::setDebugVerbose(bool debug, bool verbose)
+{
+    m_debug = m_voice->m_debug = m_data->m_debug = debug;
+    m_verbose = m_voice->m_verbose = m_data->m_verbose = verbose;
+}
+
 /// <summary>
 /// Write data processed from RF to the data ring buffer.
 /// </summary>

dmr/Slot.h

@@ -164,6 +164,9 @@ namespace dmr
         static uint8_t m_id2;
         static bool m_voice2;
 
+        /// <summary>Helper to change the debug and verbose state.</summary>
+        void setDebugVerbose(bool debug, bool verbose);
+
         /// <summary>Write data processed from RF to the data ring buffer.</summary>
         void writeQueueRF(const uint8_t* data);
         /// <summary>Write data processed from the network to the data ring buffer.</summary>

host/Host.cpp

@@ -74,7 +74,7 @@ Host::Host(const std::string& confFile) :
     m_cwIdTimer(1000U),
     m_dmrEnabled(false),
     m_p25Enabled(false),
-    m_p25CtrlBcstContinuous(false),
+    m_p25CtrlChannel(false),
     m_duplex(false),
     m_fixedMode(false),
     m_timeout(180U),
@@ -341,7 +341,8 @@ int Host::run()
         yaml::Node p25Protocol = protocolConf["p25"];
         uint32_t tduPreambleCount = p25Protocol["tduPreambleCount"].as<uint32_t>(8U);
         m_controlData = p25Protocol["control"]["enable"].as<bool>(false);
-        bool controlBcstContinuous = p25Protocol["control"]["continuous"].as<bool>(false);
+        bool p25CtrlChannel = p25Protocol["control"]["dedicated"].as<bool>(false);
+        bool p25CtrlBroadcast = p25Protocol["control"]["broadcast"].as<bool>(true);
         bool p25DumpDataPacket = p25Protocol["dumpDataPacket"].as<bool>(false);
         bool p25RepeatDataPacket = p25Protocol["repeatDataPacket"].as<bool>(true);
         bool p25DumpTsbkData = p25Protocol["dumpTsbkData"].as<bool>(false);
@@ -359,28 +360,36 @@ int Host::run()
 
         LogInfo("    Control: %s", m_controlData ? "yes" : "no");
 
-        uint32_t p25ControlBcstInterval = p25Protocol["control"]["interval"].as<uint32_t>(60U);
+        uint32_t p25ControlBcstInterval = p25Protocol["control"]["interval"].as<uint32_t>(300U);
         uint32_t p25ControlBcstDuration = p25Protocol["control"]["duration"].as<uint32_t>(1U);
         if (m_controlData) {
-            LogInfo("    Control Broadcast Continuous: %s", controlBcstContinuous ? "yes" : "no");
+            LogInfo("    Control Broadcast: %s", p25CtrlBroadcast ? "yes" : "no");
-            if (controlBcstContinuous) {
+            LogInfo("    Control Channel: %s", p25CtrlChannel ? "yes" : "no");
+            if (p25CtrlChannel) {
                 p25ControlBcstInterval = 30U;
                 p25ControlBcstDuration = 120U;
-                m_p25CtrlBcstContinuous = controlBcstContinuous;
+                m_p25CtrlChannel = p25CtrlChannel;
             }
             else {
                 LogInfo("    Control Broadcast Interval: %us", p25ControlBcstInterval);
                 LogInfo("    Control Broadcast Duration: %us", p25ControlBcstDuration);
             }
 
+            m_p25CtrlBroadcast = p25CtrlBroadcast;
             p25CCIntervalTimer.setTimeout(p25ControlBcstInterval);
             p25CCIntervalTimer.start();
 
             p25CCDurationTimer.setTimeout(p25ControlBcstDuration);
 
+            if (p25CtrlBroadcast) {
                 g_fireP25Control = true;
                 g_interruptP25Control = false;
             }
+            else {
+                g_fireP25Control = false;
+                g_interruptP25Control = false;
+            }
+        }
 
         p25 = new p25::Control(m_p25NAC, callHang, p25QueueSize, m_modem, m_network, m_timeout, m_rfTalkgroupHang,
             p25ControlBcstInterval, m_duplex, m_ridLookup, m_tidLookup, m_idenTable, rssi, p25DumpDataPacket, p25RepeatDataPacket,
@@ -401,7 +410,7 @@ int Host::run()
         g_killed = true;
     }
 
-    if (m_dmrEnabled && m_p25CtrlBcstContinuous) {
+    if (m_dmrEnabled && m_p25CtrlChannel) {
         ::LogError(LOG_HOST, "Cannot have DMR enabled when using dedicated P25 control!");
         g_killed = true;
     }
@@ -422,7 +431,21 @@ int Host::run()
     }
 
     if (!g_killed) {
+        // fixed more or P25 control channel will force a mode change
+        if (m_fixedMode || m_p25CtrlChannel) {
+            if (m_p25CtrlChannel) {
+                m_fixedMode = true;
+            }
+
+            if (dmr != NULL)
+                setMode(STATE_DMR);
+            if (p25 != NULL)
+                setMode(STATE_P25);
+        }
+        else {
             setMode(STATE_IDLE);
+        }
+
         ::LogInfoEx(LOG_HOST, "Host is performing late initialization and warmup");
 
         // perform early pumping of the modem clock (this is so the DSP has time to setup its buffers),
@@ -925,6 +948,7 @@ int Host::run()
 
         /** P25 */
         if (p25 != NULL) {
+            if (m_p25CtrlBroadcast) {
                 // clock and check P25 CC broadcast interval timer
                 p25CCIntervalTimer.clock(ms);
                 if ((p25CCIntervalTimer.isRunning() && p25CCIntervalTimer.hasExpired()) || g_fireP25Control) {
@@ -950,7 +974,7 @@ int Host::run()
                             p25->setCCRunning(true);
 
                             // hide this message for continuous CC -- otherwise display every time we process
-                        if (!m_p25CtrlBcstContinuous) {
+                            if (!m_p25CtrlChannel) {
                                 LogMessage(LOG_HOST, "P25, start CC broadcast");
                             }
 
@@ -959,7 +983,7 @@ int Host::run()
                             p25CCDurationTimer.start();
 
                             // if the CC is continuous -- clock one cycle into the duration timer
-                        if (m_p25CtrlBcstContinuous) {
+                            if (m_p25CtrlChannel) {
                                 p25CCDurationTimer.clock(ms);
                             }
                         }
@@ -968,7 +992,7 @@ int Host::run()
 
                 // if the CC is continuous -- we don't clock the CC duration timer (which results in the CC
                 // broadcast running infinitely until stopped)
-            if (!m_p25CtrlBcstContinuous) {
+                if (!m_p25CtrlChannel) {
                     // clock and check P25 CC broadcast duration timer
                     p25CCDurationTimer.clock(ms);
                     if (p25CCDurationTimer.isRunning() && p25CCDurationTimer.hasExpired()) {
@@ -988,10 +1012,11 @@ int Host::run()
                     }
                 }
             }
+        }
 
         if (g_killed) {
             if (p25 != NULL) {
-                if (m_p25CtrlBcstContinuous && !hasTxShutdown) {
+                if (m_p25CtrlChannel && !hasTxShutdown) {
                     m_modem->clearP25Data();
                     p25->reset();
 
@@ -1374,9 +1399,9 @@ void Host::setMode(uint8_t mode)
 {
     assert(m_modem != NULL);
 
-    if (m_mode != mode) {
+    //if (m_mode != mode) {
-        LogDebug(LOG_HOST, "setMode, m_mode = %u, mode = %u", m_mode, mode);
+    //    LogDebug(LOG_HOST, "setMode, m_mode = %u, mode = %u", m_mode, mode);
-    }
+    //}
 
     switch (mode) {
         case STATE_DMR:
@@ -1403,7 +1428,7 @@ void Host::setMode(uint8_t mode)
             break;
 
         case HOST_STATE_LOCKOUT:
-            LogWarning(LOG_HOST, "Mode change, MODE_LOCKOUT");
+            LogWarning(LOG_HOST, "Mode change, HOST_STATE_LOCKOUT");
             if (m_network != NULL)
                 m_network->enable(false);
 
@@ -1420,7 +1445,7 @@ void Host::setMode(uint8_t mode)
             break;
 
         case HOST_STATE_ERROR:
-            LogWarning(LOG_HOST, "Mode change, MODE_ERROR");
+            LogWarning(LOG_HOST, "Mode change, HOST_STATE_ERROR");
             if (m_network != NULL)
                 m_network->enable(false);
 

host/Host.h

@@ -79,7 +79,8 @@ private:
     bool m_dmrEnabled;
     bool m_p25Enabled;
 
-    bool m_p25CtrlBcstContinuous;
+    bool m_p25CtrlChannel;
+    bool m_p25CtrlBroadcast;
 
     bool m_duplex;
     bool m_fixedMode;

network/RemoteControl.cpp

@@ -83,8 +83,15 @@ using namespace modem;
 
 #define RCD_P25_PATCH_CMD               "p25-patch"
 
-#define RCD_P25_RELEASE_GRANTS      "p25-rel-grnts"
+#define RCD_P25_RELEASE_GRANTS_CMD      "p25-rel-grnts"
-#define RCD_P25_RELEASE_AFFS        "p25-rel-affs"
+#define RCD_P25_RELEASE_AFFS_CMD        "p25-rel-affs"
+
+#define RCD_P25_CC_DEDICATED_CMD        "p25-cc-dedicated"
+#define RCD_P25_CC_BCAST_CMD            "p25-cc-bcast"
+
+#define RCD_DMR_DEBUG                   "dmr-debug"
+#define RCD_P25_DEBUG                   "p25-debug"
+#define RCD_P25_DUMP_TSBK               "p25-dump-tsbk"
 
 const uint32_t START_OF_TEXT = 0x02;
 const uint32_t REC_SEPARATOR = 0x1E;
@@ -224,15 +231,18 @@ void RemoteControl::process(Host* host, dmr::Control* dmr, p25::Control* p25)
                 if (mode == RCD_MODE_OPT_IDLE) {
                     host->m_fixedMode = false;
                     host->setMode(STATE_IDLE);
+                    LogInfoEx(LOG_RCON, "Dynamic mode, mode %u", host->m_mode);
                 }
                 else if (mode == RCD_MODE_OPT_LCKOUT) {
                     host->m_fixedMode = false;
                     host->setMode(HOST_STATE_LOCKOUT);
+                    LogInfoEx(LOG_RCON, "Lockout mode, mode %u", host->m_mode);
                 }
                 else if (mode == RCD_MODE_OPT_FDMR) {
                     if (dmr != NULL) {
                         host->m_fixedMode = true;
                         host->setMode(STATE_DMR);
+                        LogInfoEx(LOG_RCON, "Fixed mode, mode %u", host->m_mode);
                     }
                     else {
                         LogError(LOG_RCON, CMD_FAILED_STR "DMR mode is not enabled!");
@@ -242,6 +252,7 @@ void RemoteControl::process(Host* host, dmr::Control* dmr, p25::Control* p25)
                     if (p25 != NULL) {
                         host->m_fixedMode = true;
                         host->setMode(STATE_P25);
+                        LogInfoEx(LOG_RCON, "Fixed mode, mode %u", host->m_mode);
                     }
                     else {
                         LogError(LOG_RCON, CMD_FAILED_STR "P25 mode is not enabled!");
@@ -276,8 +287,13 @@ void RemoteControl::process(Host* host, dmr::Control* dmr, p25::Control* p25)
             else if (rcom == RCD_DMR_BEACON_CMD) {
                 // Command is in the form of: "dmr-beacon"
                 if (dmr != NULL) {
+                    if (host->m_dmrBeacons) {
                         g_fireDMRBeacon = true;
                     }
+                    else {
+                        LogError(LOG_RCON, CMD_FAILED_STR "DMR beacons is not enabled!");
+                    }
+                }
                 else {
                     LogError(LOG_RCON, CMD_FAILED_STR "DMR mode is not enabled!");
                 }
@@ -285,8 +301,13 @@ void RemoteControl::process(Host* host, dmr::Control* dmr, p25::Control* p25)
             else if (rcom == RCD_P25_CC_CMD) {
                 // Command is in the form of: "p25-cc"
                 if (p25 != NULL) {
+                    if (host->m_controlData) {
                         g_fireP25Control = true;
                     }
+                    else {
+                        LogError(LOG_RCON, CMD_FAILED_STR "P25 control data is not enabled!");
+                    }
+                }
                 else {
                     LogError(LOG_RCON, CMD_FAILED_STR "P25 mode is not enabled!");
                 }
@@ -626,7 +647,7 @@ void RemoteControl::process(Host* host, dmr::Control* dmr, p25::Control* p25)
                     LogError(LOG_RCON, CMD_FAILED_STR "P25 mode is not enabled!");
                 }
             }
-            else if (rcom == RCD_P25_RELEASE_GRANTS) {
+            else if (rcom == RCD_P25_RELEASE_GRANTS_CMD) {
                 // Command is in the form of: "p25-rel-grnts"
                 if (p25 != NULL) {
                     p25->trunk()->releaseDstIdGrant(0, true);
@@ -635,7 +656,7 @@ void RemoteControl::process(Host* host, dmr::Control* dmr, p25::Control* p25)
                     LogError(LOG_RCON, CMD_FAILED_STR "P25 mode is not enabled!");
                 }
             }
-            else if (rcom == RCD_P25_RELEASE_AFFS) {
+            else if (rcom == RCD_P25_RELEASE_AFFS_CMD) {
                 // Command is in the form of: "p25-rel-affs <group>"
                 if (p25 != NULL) {
                     uint32_t grp = getArgUInt32(args, 0U);
@@ -651,6 +672,87 @@ void RemoteControl::process(Host* host, dmr::Control* dmr, p25::Control* p25)
                     LogError(LOG_RCON, CMD_FAILED_STR "P25 mode is not enabled!");
                 }
             }
+            else if (rcom == RCD_P25_CC_DEDICATED_CMD) {
+                // Command is in the form of: "p25-cc-dedicated"
+                if (p25 != NULL) {
+                    if (host->m_controlData) {
+                        if (dmr != NULL) {
+                            LogError(LOG_RCON, CMD_FAILED_STR "Can't enable P25 control channel while DMR is enabled!");
+                        }
+                        else {
+                            host->m_p25CtrlChannel = !host->m_p25CtrlChannel;
+                            host->m_p25CtrlBroadcast = true;
+                            g_fireP25Control = true;
+                            g_interruptP25Control = false;
+
+                            LogInfoEx(LOG_RCON, "P25 CC is %s", host->m_p25CtrlChannel ? "enabled" : "disabled");
+                        }
+                    }
+                    else {
+                        LogError(LOG_RCON, CMD_FAILED_STR "P25 control data is not enabled!");
+                    }
+                }
+                else {
+                    LogError(LOG_RCON, CMD_FAILED_STR "P25 mode is not enabled!");
+                }
+            }
+            else if (rcom == RCD_P25_CC_BCAST_CMD) {
+                // Command is in the form of: "p25-cc-bcast"
+                if (p25 != NULL) {
+                    if (host->m_controlData) {
+                        host->m_p25CtrlBroadcast = !host->m_p25CtrlBroadcast;
+
+                        if (!host->m_p25CtrlBroadcast) {
+                            g_fireP25Control = false;
+                            g_interruptP25Control = true;
+                        }
+                        else {
+                            g_fireP25Control = true;
+                            g_interruptP25Control = false;
+                        }
+
+                        LogInfoEx(LOG_RCON, "P25 CC broadcast is %s", host->m_p25CtrlBroadcast ? "enabled" : "disabled");
+                    }
+                    else {
+                        LogError(LOG_RCON, CMD_FAILED_STR "P25 control data is not enabled!");
+                    }
+                }
+                else {
+                    LogError(LOG_RCON, CMD_FAILED_STR "P25 mode is not enabled!");
+                }
+            }
+            else if (rcom == RCD_DMR_DEBUG) {
+                // Command is in the form of: "dmr-debug <debug 0/1> <trace 0/1>"
+                uint8_t debug = getArgUInt8(args, 0U);
+                uint8_t verbose = getArgUInt8(args, 1U);
+                if (dmr != NULL) {
+                    dmr->setDebugVerbose((debug == 1U) ? true : false, (verbose == 1U) ? true : false);
+                }
+                else {
+                    LogError(LOG_RCON, CMD_FAILED_STR "DMR mode is not enabled!");
+                }
+            }
+            else if (rcom == RCD_P25_DEBUG) {
+                // Command is in the form of: "p25-debug <debug 0/1> <trace 0/1>"
+                uint8_t debug = getArgUInt8(args, 0U);
+                uint8_t verbose = getArgUInt8(args, 1U);
+                if (p25 != NULL) {
+                    p25->setDebugVerbose((debug == 1U) ? true : false, (verbose == 1U) ? true : false);
+                }
+                else {
+                    LogError(LOG_RCON, CMD_FAILED_STR "P25 mode is not enabled!");
+                }
+            }
+            else if (rcom == RCD_P25_DUMP_TSBK) {
+                // Command is in the form of: "p25-dump-tsbk 0/1"
+                uint8_t verbose = getArgUInt8(args, 0U);
+                if (p25 != NULL) {
+                    p25->trunk()->setTSBKVerbose((verbose == 1U) ? true : false);
+                }
+                else {
+                    LogError(LOG_RCON, CMD_FAILED_STR "P25 mode is not enabled!");
+                }
+            }
             else {
                 args.clear();
                 LogError(LOG_RCON, BAD_CMD_STR " (\"%s\")", rcom.c_str());

p25/Control.cpp

@@ -612,6 +612,17 @@ void Control::clock(uint32_t ms)
     m_trunk->clock(ms);
 }
 
+/// <summary>
+/// Helper to change the debug and verbose state.
+/// </summary>
+/// <param name="debug">Flag indicating whether DMR debug is enabled.</param>
+/// <param name="verbose">Flag indicating whether DMR verbose logging is enabled.</param>
+void Control::setDebugVerbose(bool debug, bool verbose)
+{
+    m_debug = m_voice->m_debug = m_data->m_debug = m_trunk->m_debug = debug;
+    m_verbose = m_voice->m_verbose = m_data->m_verbose = m_trunk->m_verbose = verbose;
+}
+
 // ---------------------------------------------------------------------------
 //  Private Class Members
 // ---------------------------------------------------------------------------

p25/Control.h

@@ -106,6 +106,9 @@ namespace p25
         /// <summary></summary>
         TrunkPacket* trunk() { return m_trunk; }
 
+        /// <summary>Helper to change the debug and verbose state.</summary>
+        void setDebugVerbose(bool debug, bool verbose);
+
     private:
         friend class VoicePacket;
         VoicePacket* m_voice;

p25/TrunkPacket.cpp

@@ -1251,6 +1251,19 @@ void TrunkPacket::writeRF_TSDU_Mot_Patch(uint32_t group1, uint32_t group2, uint3
     m_rfTSBK.setMFId(P25_MFG_STANDARD);
 }
 
+/// <summary>
+/// Helper to change the TSBK verbose state.
+/// </summary>
+/// <param name="verbose">Flag indicating whether TSBK dumping is enabled.</param>
+void TrunkPacket::setTSBKVerbose(bool verbose)
+{
+    m_rfTSBK.setVerbose(verbose);
+    m_netTSBK.setVerbose(verbose);
+
+    m_rfTDULC.setVerbose(verbose);
+    m_netTDULC.setVerbose(verbose);
+}
+
 // ---------------------------------------------------------------------------
 //  Private Class Members
 // ---------------------------------------------------------------------------

p25/TrunkPacket.h

@@ -123,6 +123,9 @@ namespace p25
         /// <summary>Helper to write a Motorola patch packet.</summary>
         void writeRF_TSDU_Mot_Patch(uint32_t group1, uint32_t group2, uint32_t group3);
 
+        /// <summary>Helper to change the TSBK verbose state.</summary>
+        void setTSBKVerbose(bool verbose);
+
     private:
         friend class VoicePacket;
         friend class DataPacket;