correct interpacket CC delay for NXDN; undo a horrible idea for handling logging strings for NXDN;

pull/12/head
Bryan Biedenkapp 4 years ago
parent c3a90dd790
commit c1010e95b0

@ -35,7 +35,6 @@
#include "nxdn/channel/UDCH.h"
#include "nxdn/lc/RTCH.h"
#include "nxdn/Sync.h"
#include "nxdn/NXDNUtils.h"
#include "edac/AMBEFEC.h"
#include "HostMain.h"
#include "Log.h"
@ -118,7 +117,7 @@ Control::Control(uint32_t ran, uint32_t callHang, uint32_t queueSize, uint32_t t
m_rfTGHang(1000U, tgHang),
m_netTimeout(1000U, timeout),
m_networkWatchdog(1000U, 0U, 1500U),
m_ccPacketInterval(1000U, 0U, 5U),
m_ccPacketInterval(1000U, 0U, 250U),
m_ccFrameCnt(0U),
m_ccSeq(0U),
m_siteData(),
@ -301,8 +300,8 @@ bool Control::processFrame(uint8_t* data, uint32_t len)
float(m_voice->m_rfFrames) / 12.5F, float(m_voice->m_rfErrs * 100U) / float(m_voice->m_rfBits));
}
LogMessage(LOG_RF, "NXDN %s, total frames: %d, bits: %d, undecodable LC: %d, errors: %d, BER: %.4f%%",
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_TX_REL), m_voice->m_rfFrames, m_voice->m_rfBits, m_voice->m_rfUndecodableLC, m_voice->m_rfErrs, float(m_voice->m_rfErrs * 100U) / float(m_voice->m_rfBits));
LogMessage(LOG_RF, "NXDN, " NXDN_RTCH_MSG_TYPE_TX_REL ", total frames: %d, bits: %d, undecodable LC: %d, errors: %d, BER: %.4f%%",
m_voice->m_rfFrames, m_voice->m_rfBits, m_voice->m_rfUndecodableLC, m_voice->m_rfErrs, float(m_voice->m_rfErrs * 100U) / float(m_voice->m_rfBits));
if (m_control) {
m_affiliations.releaseGrant(m_rfLC.getDstId(), false);

@ -33,6 +33,33 @@
#include "Defines.h"
// Message Type Strings
#define NXDN_RTCH_MSG_TYPE_VCALL "VCALL (Voice Call)"
#define NXDN_RTCH_MSG_TYPE_VCALL_REQ "VCALL_REQ (Voice Call Request)"
#define NXDN_RTCH_MSG_TYPE_VCALL_RESP "VCALL_RESP (Voice Call Response)"
#define NXDN_RTCH_MSG_TYPE_VCALL_IV "VCALL_IV (Voice Call Init Vector)"
#define NXDN_RCCH_MSG_TYPE_VCALL_CONN_REQ "VCALL_CONN_REQ (Voice Call Connection Request)"
#define NXDN_RCCH_MSG_TYPE_VCALL_CONN_RESP "VCALL_CONN_RESP (Voice Call Connection Response)"
#define NXDN_RCCH_MSG_TYPE_VCALL_ASSGN "VCALL_ASSGN (Voice Call Assignment)"
#define NXDN_RTCH_MSG_TYPE_TX_REL_EX "TX_REL_EX (Transmission Release Extension)"
#define NXDN_RTCH_MSG_TYPE_TX_REL "TX_REL (Transmission Release)"
#define NXDN_RTCH_MSG_TYPE_DCALL_HDR "DCALL (Data Call Header)"
#define NXDN_RCCH_MSG_TYPE_DCALL_REQ "DCALL_REQ (Data Call Request)"
#define NXDN_RCCH_MSG_TYPE_DCALL_RESP "DCALL_RESP (Data Call Response)"
#define NXDN_RTCH_MSG_TYPE_DCALL_DATA "DCALL (Data Call User Data)"
#define NXDN_RTCH_MSG_TYPE_DCALL_ACK "DCALL_ACL (Data Call Acknowledge)"
#define NXDN_RTCH_MSG_TYPE_HEAD_DLY "HEAD_DLY (Header Delay)"
#define NXDN_MSG_TYPE_IDLE "IDLE (Idle)"
#define NXDN_MSG_TYPE_DISC "DISC (Disconnect)"
#define NXDN_RCCH_MSG_TYPE_DCALL_ASSGN "DCALL_ASSGN (Data Call Assignment)"
#define NXDN_RCCH_MSG_TYPE_REG_REQ "REG_REQ (Registration Request)"
#define NXDN_RCCH_MSG_TYPE_REG_RESP "REG_RESP (Registration Response)"
#define NXDN_RCCH_MSG_TYPE_REG_C_REQ "REG_C_REQ (Registration Clear Request)"
#define NXDN_RCCH_MSG_TYPE_REG_C_RESP "REG_C_RESP (Registration Clear Response)"
#define NXDN_RCCH_MSG_TYPE_REG_COMM "REG_COMM (Registration Command)"
#define NXDN_RCCH_MSG_TYPE_GRP_REG_REQ "GRP_REG_REQ (Group Registration Request)"
#define NXDN_RCCH_MSG_TYPE_GRP_REG_RESP "GRP_REG_RESP (Group Registration Response)"
namespace nxdn
{
// ---------------------------------------------------------------------------

@ -1,180 +0,0 @@
/**
* Digital Voice Modem - Host Software
* GPLv2 Open Source. Use is subject to license terms.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* @package DVM / Host Software
*
*/
//
// Based on code from the MMDVMHost project. (https://github.com/g4klx/MMDVMHost)
// Licensed under the GPLv2 License (https://opensource.org/licenses/GPL-2.0)
//
/*
* Copyright (C) 2021 by Bryan Biedenkapp N2PLL
*
* 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.
*/
#if !defined(__NXDN_UTILS_H__)
#define __NXDN_UTILS_H__
#include "Defines.h"
#include "nxdn/NXDNDefines.h"
#include <cstring>
namespace nxdn
{
// ---------------------------------------------------------------------------
// Class Declaration
// This class implements various helper functions for NXDN.
// ---------------------------------------------------------------------------
class HOST_SW_API NXDNUtils {
public:
/// <summary>Helper to convert a NXDN message type to a textual string.</summary>
static const char* messageTypeToString(uint8_t messageType, bool rcch = false, bool outbound = false)
{
std::string ret = std::string();
switch (messageType)
{
case RTCH_MESSAGE_TYPE_VCALL:
if (rcch) {
if (outbound) {
ret = "VCALL_RESP (Voice Call Response)";
}
else {
ret = "VCALL_REQ (Voice Call Request)";
}
}
else {
ret = "VCALL (Voice Call)";
}
break;
case RTCH_MESSAGE_TYPE_VCALL_IV:
if (rcch) {
if (outbound) {
ret = "VCALL_CONN_RESP (Voice Call Connection Response)";
}
else {
ret = "VCALL_CONN_REQ (Voice Call Connection Request)";
}
}
else {
ret = "VCALL_IV (Voice Call Init Vector)";
}
break;
case RCCH_MESSAGE_TYPE_VCALL_ASSGN:
if (rcch) {
if (outbound) {
ret = "VCALL_ASSGN (Voice Call Assignment)";
}
}
break;
case RTCH_MESSAGE_TYPE_TX_REL_EX:
ret = "TX_REL_EX (Transmission Release Extension)";
break;
case RTCH_MESSAGE_TYPE_TX_REL:
ret = "TX_REL (Transmission Release)";
break;
case RTCH_MESSAGE_TYPE_DCALL_HDR:
if (rcch) {
if (outbound) {
ret = "DCALL_RESP (Data Call Response)";
}
else {
ret = "DCALL_REQ (Data Call Request)";
}
}
else {
ret = "DCALL (Data Call Header)";
}
break;
case RTCH_MESSAGE_TYPE_DCALL_DATA:
ret = "DCALL (Data Call User Data)";
break;
case RTCH_MESSAGE_TYPE_DCALL_ACK:
ret = "DCALL_ACL (Data Call Acknowledge)";
break;
case RTCH_MESSAGE_TYPE_HEAD_DLY:
ret = "HEAD_DLY (Header Delay)";
break;
case MESSAGE_TYPE_IDLE:
ret = "IDLE (Idle)";
break;
case MESSAGE_TYPE_DISC:
ret = "DISC (Disconnect)";
break;
case RCCH_MESSAGE_TYPE_DCALL_ASSGN:
if (outbound) {
ret = "DCALL_ASSGN (Data Call Assignment)";
}
break;
case MESSAGE_TYPE_DST_ID_INFO:
ret = "DST_ID_INFO (Digital Station ID)";
break;
case RCCH_MESSAGE_TYPE_SITE_INFO:
ret = "SITE_INFO (Site Information)";
break;
case MESSAGE_TYPE_SRV_INFO:
ret = "SRV_INFO (Service Information)";
break;
case MESSAGE_TYPE_CCH_INFO:
ret = "CCH_INFO (Control Channel Information)";
break;
case MESSAGE_TYPE_ADJ_SITE_INFO:
ret = "ADJ_SITE_INFO (Adjacent Site Information)";
break;
case RCCH_MESSAGE_TYPE_REG:
if (outbound) {
ret = "REG_RESP (Registration Response)";
}
else {
ret = "REG_REQ (Registration Request)";
}
break;
case RCCH_MESSAGE_TYPE_REG_C:
if (outbound) {
ret = "REG_C_RESP (Registration Clear Response)";
}
else {
ret = "REG_C_REQ (Registration Clear Request)";
}
break;
case RCCH_MESSAGE_TYPE_REG_COMM:
ret = "REG_COMM (Registration Command)";
break;
case RCCH_MESSAGE_TYPE_GRP_REG:
if (outbound) {
ret = "GRP_REG_RESP (Group Registration Response)";
}
else {
ret = "GRP_REG_REQ (Group Registration Request)";
}
break;
case RCCH_MESSAGE_TYPE_PROP_FORM:
ret = "PROP_FORM (Proprietary Form)";
break;
default:
ret = "UNKNOWN - Unknown";
break;
}
return ret.c_str();
}
};
} // namespace nxdn
#endif // __NXDN_UTILS_H__

@ -34,7 +34,6 @@
#include "nxdn/packet/Data.h"
#include "nxdn/acl/AccessControl.h"
#include "nxdn/Sync.h"
#include "nxdn/NXDNUtils.h"
#include "edac/CRC.h"
#include "HostMain.h"
#include "Log.h"
@ -109,8 +108,7 @@ using namespace nxdn::packet;
#define VALID_SRCID(_SRC_ID, _DST_ID, _GROUP) \
if (!acl::AccessControl::validateSrcId(_SRC_ID)) { \
if (m_lastRejectId == 0U || m_lastRejectId != _SRC_ID) { \
LogWarning(LOG_RF, "NXDN %s denial, RID rejection, srcId = %u", \
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_DCALL_HDR), _SRC_ID); \
LogWarning(LOG_RF, "NXDN, " NXDN_RTCH_MSG_TYPE_DCALL_HDR " denial, RID rejection, srcId = %u", _SRC_ID); \
::ActivityLog("NXDN", true, "RF voice rejection from %u to %s%u ", _SRC_ID, _GROUP ? "TG " : "", _DST_ID); \
m_lastRejectId = _SRC_ID; \
} \
@ -126,8 +124,7 @@ using namespace nxdn::packet;
if (!_GROUP) { \
if (!acl::AccessControl::validateSrcId(_DST_ID)) { \
if (m_lastRejectId == 0 || m_lastRejectId != _DST_ID) { \
LogWarning(LOG_RF, "NXDN %s denial, RID rejection, dstId = %u", \
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_DCALL_HDR), _DST_ID); \
LogWarning(LOG_RF, "NXDN, " NXDN_RTCH_MSG_TYPE_DCALL_HDR " denial, RID rejection, dstId = %u", _DST_ID); \
::ActivityLog("NXDN", true, "RF voice rejection from %u to %s%u ", _SRC_ID, _GROUP ? "TG " : "", _DST_ID); \
m_lastRejectId = _DST_ID; \
} \
@ -141,8 +138,7 @@ using namespace nxdn::packet;
else { \
if (!acl::AccessControl::validateTGId(_DST_ID)) { \
if (m_lastRejectId == 0 || m_lastRejectId != _DST_ID) { \
LogWarning(LOG_RF, "NXDN %s denial, TGID rejection, dstId = %u", \
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_DCALL_HDR), _DST_ID); \
LogWarning(LOG_RF, "NXDN, " NXDN_RTCH_MSG_TYPE_DCALL_HDR " denial, TGID rejection, dstId = %u", _DST_ID); \
::ActivityLog("NXDN", true, "RF voice rejection from %u to %s%u ", _SRC_ID, _GROUP ? "TG " : "", _DST_ID); \
m_lastRejectId = _DST_ID; \
} \
@ -220,8 +216,8 @@ bool Data::process(uint8_t option, uint8_t* data, uint32_t len)
VALID_DSTID(srcId, dstId, group);
if (m_verbose) {
LogMessage(LOG_RF, "NXDN %s, srcId = %u, dstId = %u, ack = %u, blocksToFollow = %u, padCount = %u, firstFragment = %u, fragmentCount = %u",
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_DCALL_HDR), srcId, dstId, lc.getPacketInfo().getDelivery(), lc.getPacketInfo().getBlockCount(), lc.getPacketInfo().getPadCount(), lc.getPacketInfo().getStart(), lc.getPacketInfo().getFragmentCount());
LogMessage(LOG_RF, "NXDN, " NXDN_RTCH_MSG_TYPE_DCALL_HDR ", srcId = %u, dstId = %u, ack = %u, blocksToFollow = %u, padCount = %u, firstFragment = %u, fragmentCount = %u",
srcId, dstId, lc.getPacketInfo().getDelivery(), lc.getPacketInfo().getBlockCount(), lc.getPacketInfo().getPadCount(), lc.getPacketInfo().getStart(), lc.getPacketInfo().getFragmentCount());
}
::ActivityLog("NXDN", true, "RF data transmission from %u to %s%u", srcId, group ? "TG " : "", dstId);
@ -271,8 +267,8 @@ bool Data::process(uint8_t option, uint8_t* data, uint32_t len)
if (data[0U] == modem::TAG_EOT) {
::ActivityLog("NXDN", true, "RF ended RF data transmission");
LogMessage(LOG_RF, "NXDN %s, total frames: %d",
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_TX_REL), m_nxdn->m_voice->m_rfFrames);
LogMessage(LOG_RF, "NXDN, " NXDN_RTCH_MSG_TYPE_TX_REL ", total frames: %d",
m_nxdn->m_voice->m_rfFrames);
m_nxdn->writeEndRF();
}
@ -328,8 +324,8 @@ bool Data::processNetwork(uint8_t option, lc::RTCH& netLC, uint8_t* data, uint32
VALID_DSTID(srcId, dstId, group);
if (m_verbose) {
LogMessage(LOG_NET, "NXDN %s, srcId = %u, dstId = %u, ack = %u, blocksToFollow = %u, padCount = %u, firstFragment = %u, fragmentCount = %u",
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_DCALL_HDR), srcId, dstId, lc.getPacketInfo().getDelivery(), lc.getPacketInfo().getBlockCount(), lc.getPacketInfo().getPadCount(), lc.getPacketInfo().getStart(), lc.getPacketInfo().getFragmentCount());
LogMessage(LOG_NET, "NXDN, " NXDN_RTCH_MSG_TYPE_DCALL_HDR ", srcId = %u, dstId = %u, ack = %u, blocksToFollow = %u, padCount = %u, firstFragment = %u, fragmentCount = %u",
srcId, dstId, lc.getPacketInfo().getDelivery(), lc.getPacketInfo().getBlockCount(), lc.getPacketInfo().getPadCount(), lc.getPacketInfo().getStart(), lc.getPacketInfo().getFragmentCount());
}
::ActivityLog("NXDN", false, "network data transmission from %u to %s%u", srcId, group ? "TG " : "", dstId);
@ -375,8 +371,8 @@ bool Data::processNetwork(uint8_t option, lc::RTCH& netLC, uint8_t* data, uint32
if (data[0U] == modem::TAG_EOT) {
::ActivityLog("NXDN", true, "network ended RF data transmission");
LogMessage(LOG_NET, "NXDN %s, total frames: %d",
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_TX_REL), m_nxdn->m_voice->m_netFrames);
LogMessage(LOG_NET, "NXDN, " NXDN_RTCH_MSG_TYPE_TX_REL ", total frames: %d",
m_nxdn->m_voice->m_netFrames);
m_nxdn->writeEndNet();
}

@ -33,7 +33,6 @@
#include "nxdn/packet/Trunk.h"
#include "nxdn/acl/AccessControl.h"
#include "nxdn/Sync.h"
#include "nxdn/NXDNUtils.h"
#include "edac/CRC.h"
#include "HostMain.h"
#include "Log.h"
@ -52,60 +51,54 @@ using namespace nxdn::packet;
// ---------------------------------------------------------------------------
// Make sure control data is supported.
#define IS_SUPPORT_CONTROL_CHECK(_PCKT, _SRCID) \
#define IS_SUPPORT_CONTROL_CHECK(_PCKT_STR, _PCKT, _SRCID) \
if (!m_nxdn->m_control) { \
LogWarning(LOG_RF, "NXDN, %s denial, unsupported service, srcId = %u", \
NXDNUtils::messageTypeToString(_PCKT, true), _SRCID); \
LogWarning(LOG_RF, "NXDN, " _PCKT_STR " denial, unsupported service, srcId = %u", _SRCID); \
writeRF_Message_Deny(NXDN_CAUSE_SVC_UNAVAILABLE, _PCKT); \
m_nxdn->m_rfState = RS_RF_REJECTED; \
return false; \
}
// Validate the source RID.
#define VALID_SRCID(_PCKT, _SRCID, _RSN) \
#define VALID_SRCID(_PCKT_STR, _PCKT, _SRCID, _RSN) \
if (!acl::AccessControl::validateSrcId(_SRCID)) { \
LogWarning(LOG_RF, "NXDN, %s denial, RID rejection, srcId = %u", \
NXDNUtils::messageTypeToString(_PCKT, true), _SRCID); \
LogWarning(LOG_RF, "NXDN, " _PCKT_STR " denial, RID rejection, srcId = %u", _SRCID); \
writeRF_Message_Deny(_RSN, _PCKT); \
m_nxdn->m_rfState = RS_RF_REJECTED; \
return false; \
}
// Validate the target RID.
#define VALID_DSTID(_PCKT, _DSTID, _RSN) \
#define VALID_DSTID(_PCKT_STR, _PCKT, _DSTID, _RSN) \
if (!acl::AccessControl::validateSrcId(_DSTID)) { \
LogWarning(LOG_RF, "NXDN, %s denial, RID rejection, dstId = %u", \
NXDNUtils::messageTypeToString(_PCKT, true), _DSTID); \
LogWarning(LOG_RF, "NXDN, " _PCKT_STR " denial, RID rejection, dstId = %u", _DSTID); \
writeRF_Message_Deny(_RSN, _PCKT); \
m_nxdn->m_rfState = RS_RF_REJECTED; \
return false; \
}
// Validate the talkgroup ID.
#define VALID_TGID(_PCKT, _DSTID, _RSN) \
#define VALID_TGID(_PCKT_STR, _PCKT, _DSTID, _RSN) \
if (!acl::AccessControl::validateTGId(_DSTID)) { \
LogWarning(LOG_RF, "NXDN, %s denial, TGID rejection, dstId = %u", \
NXDNUtils::messageTypeToString(_PCKT, true), _DSTID); \
LogWarning(LOG_RF, "NXDN, " _PCKT_STR " denial, TGID rejection, dstId = %u", _DSTID); \
writeRF_Message_Deny(_RSN, _PCKT); \
m_nxdn->m_rfState = RS_RF_REJECTED; \
return false; \
}
// Verify the source RID is registered.
#define VERIFY_SRCID_REG(_PCKT, _SRCID, _RSN) \
#define VERIFY_SRCID_REG(_PCKT_STR, _PCKT, _SRCID, _RSN) \
if (!m_nxdn->m_affiliations.isUnitReg(_SRCID) && m_verifyReg) { \
LogWarning(LOG_RF, "NXDN, %s denial, RID not registered, srcId = %u", \
NXDNUtils::messageTypeToString(_PCKT, true), _SRCID); \
LogWarning(LOG_RF, "NXDN, " _PCKT_STR " denial, RID not registered, srcId = %u", _SRCID); \
writeRF_Message_Deny(_RSN, _PCKT); \
m_nxdn->m_rfState = RS_RF_REJECTED; \
return false; \
}
// Verify the source RID is affiliated.
#define VERIFY_SRCID_AFF(_PCKT, _SRCID, _DSTID, _RSN) \
#define VERIFY_SRCID_AFF(_PCKT_STR, _PCKT, _SRCID, _DSTID, _RSN) \
if (!m_nxdn->m_affiliations.isGroupAff(_SRCID, _DSTID) && m_verifyAff) { \
LogWarning(LOG_RF, "NXDN, %s denial, RID not affiliated to TGID, srcId = %u, dstId = %u", \
NXDNUtils::messageTypeToString(_PCKT, true), _SRCID, _DSTID); \
LogWarning(LOG_RF, "NXDN, " _PCKT_STR " denial, RID not affiliated to TGID, srcId = %u, dstId = %u", _SRCID, _DSTID); \
writeRF_Message_Deny(_RSN, _PCKT); \
m_nxdn->m_rfState = RS_RF_REJECTED; \
return false; \
@ -181,39 +174,39 @@ bool Trunk::process(uint8_t fct, uint8_t option, uint8_t* data, uint32_t len)
switch (m_rfLC.getMessageType()) {
case RTCH_MESSAGE_TYPE_VCALL:
// make sure control data is supported
IS_SUPPORT_CONTROL_CHECK(RTCH_MESSAGE_TYPE_VCALL, srcId);
IS_SUPPORT_CONTROL_CHECK(NXDN_RTCH_MSG_TYPE_VCALL_REQ, RTCH_MESSAGE_TYPE_VCALL, srcId);
// validate the source RID
VALID_SRCID(RTCH_MESSAGE_TYPE_VCALL, srcId, NXDN_CAUSE_VD_REQ_UNIT_NOT_PERM);
VALID_SRCID(NXDN_RTCH_MSG_TYPE_VCALL_REQ, RTCH_MESSAGE_TYPE_VCALL, srcId, NXDN_CAUSE_VD_REQ_UNIT_NOT_PERM);
// validate the talkgroup ID
VALID_TGID(RTCH_MESSAGE_TYPE_VCALL, dstId, NXDN_CAUSE_VD_TGT_UNIT_NOT_PERM);
VALID_TGID(NXDN_RTCH_MSG_TYPE_VCALL_REQ, RTCH_MESSAGE_TYPE_VCALL, dstId, NXDN_CAUSE_VD_TGT_UNIT_NOT_PERM);
// verify the source RID is affiliated
VERIFY_SRCID_AFF(RTCH_MESSAGE_TYPE_VCALL, srcId, dstId, NXDN_CAUSE_VD_REQ_UNIT_NOT_REG);
VERIFY_SRCID_AFF(NXDN_RTCH_MSG_TYPE_VCALL_REQ, RTCH_MESSAGE_TYPE_VCALL, srcId, dstId, NXDN_CAUSE_VD_REQ_UNIT_NOT_REG);
if (m_verbose) {
LogMessage(LOG_RF, "NXDN, %s, srcId = %u, dstId = %u", NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_VCALL, true), srcId, dstId);
LogMessage(LOG_RF, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL_REQ ", srcId = %u, dstId = %u", srcId, dstId);
}
writeRF_Message_Grant(true);
break;
case RCCH_MESSAGE_TYPE_REG:
// make sure control data is supported
IS_SUPPORT_CONTROL_CHECK(RCCH_MESSAGE_TYPE_REG, srcId);
IS_SUPPORT_CONTROL_CHECK(NXDN_RCCH_MSG_TYPE_REG_REQ, RCCH_MESSAGE_TYPE_REG, srcId);
if (m_verbose) {
LogMessage(LOG_RF, "NXDN %s, srcId = %u", NXDNUtils::messageTypeToString(RCCH_MESSAGE_TYPE_REG, true), srcId);
LogMessage(LOG_RF, "NXDN, " NXDN_RCCH_MSG_TYPE_REG_REQ ", srcId = %u", srcId);
}
writeRF_Message_U_Reg_Rsp(srcId);
break;
case RCCH_MESSAGE_TYPE_GRP_REG:
// make sure control data is supported
IS_SUPPORT_CONTROL_CHECK(RCCH_MESSAGE_TYPE_GRP_REG, srcId);
IS_SUPPORT_CONTROL_CHECK(NXDN_RCCH_MSG_TYPE_GRP_REG_REQ, RCCH_MESSAGE_TYPE_GRP_REG, srcId);
if (m_verbose) {
LogMessage(LOG_RF, "NXDN %s, srcId = %u, dstId = %u", NXDNUtils::messageTypeToString(RCCH_MESSAGE_TYPE_GRP_REG, true), srcId, dstId);
LogMessage(LOG_RF, "NXDN, " NXDN_RCCH_MSG_TYPE_GRP_REG_REQ ", srcId = %u, dstId = %u", srcId, dstId);
}
writeRF_Message_Grp_Reg_Rsp(srcId, dstId);
@ -449,8 +442,7 @@ bool Trunk::writeRF_Message_Grant(bool grp, bool skip, bool net, bool skipNetChe
if (!skip) {
if (m_nxdn->m_rfState != RS_RF_LISTENING && m_nxdn->m_rfState != RS_RF_DATA) {
if (!net) {
LogWarning(LOG_RF, "NXDN, %s denied, traffic in progress, dstId = %u",
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_VCALL, true), m_rfLC.getDstId());
LogWarning(LOG_RF, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL_REQ " denied, traffic in progress, dstId = %u", m_rfLC.getDstId());
writeRF_Message_Deny(NXDN_CAUSE_VD_QUE_GRP_BUSY, RTCH_MESSAGE_TYPE_VCALL);
::ActivityLog("NXDN", true, "group grant request from %u to TG %u denied", m_rfLC.getSrcId(), m_rfLC.getDstId());
@ -463,8 +455,7 @@ bool Trunk::writeRF_Message_Grant(bool grp, bool skip, bool net, bool skipNetChe
if (m_nxdn->m_netState != RS_NET_IDLE && m_rfLC.getDstId() == m_nxdn->m_netLastDstId) {
if (!net) {
LogWarning(LOG_RF, "NXDN, %s denied, traffic in progress, dstId = %u",
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_VCALL, true), m_rfLC.getDstId());
LogWarning(LOG_RF, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL_REQ " denied, traffic in progress, dstId = %u", m_rfLC.getDstId());
writeRF_Message_Deny(NXDN_CAUSE_VD_QUE_GRP_BUSY, RTCH_MESSAGE_TYPE_VCALL);
::ActivityLog("NXDN", true, "group grant request from %u to TG %u denied", m_rfLC.getSrcId(), m_rfLC.getDstId());
@ -492,8 +483,7 @@ bool Trunk::writeRF_Message_Grant(bool grp, bool skip, bool net, bool skipNetChe
if (!m_nxdn->m_affiliations.isRFChAvailable()) {
if (grp) {
if (!net) {
LogWarning(LOG_RF, "NXDN, %s queued, no channels available, dstId = %u",
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_VCALL, true), m_rfLC.getDstId());
LogWarning(LOG_RF, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL_REQ " queued, no channels available, dstId = %u", m_rfLC.getDstId());
writeRF_Message_Deny(NXDN_CAUSE_VD_QUE_CHN_RESOURCE_NOT_AVAIL, RTCH_MESSAGE_TYPE_VCALL);
::ActivityLog("NXDN", true, "group grant request from %u to TG %u queued", m_rfLC.getSrcId(), m_rfLC.getDstId());
@ -505,8 +495,7 @@ bool Trunk::writeRF_Message_Grant(bool grp, bool skip, bool net, bool skipNetChe
}
else {
if (!net) {
LogWarning(LOG_RF, "NXDN, %s queued, no channels available, dstId = %u",
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_VCALL, true), m_rfLC.getDstId());
LogWarning(LOG_RF, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL_REQ " queued, no channels available, dstId = %u", m_rfLC.getDstId());
writeRF_Message_Deny(NXDN_CAUSE_VD_QUE_CHN_RESOURCE_NOT_AVAIL, RTCH_MESSAGE_TYPE_VCALL);
::ActivityLog("P25", true, "unit-to-unit grant request from %u to %u queued", m_rfLC.getSrcId(), m_rfLC.getDstId());
@ -542,9 +531,8 @@ bool Trunk::writeRF_Message_Grant(bool grp, bool skip, bool net, bool skipNetChe
}
if (m_verbose) {
LogMessage((net) ? LOG_NET : LOG_RF, "NXDN, %s, emerg = %u, encrypt = %u, prio = %u, chNo = %u, srcId = %u, dstId = %u",
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_VCALL, true, true), m_rfLC.getEmergency(), m_rfLC.getEncrypted(),
m_rfLC.getPriority(), m_rfLC.getGrpVchNo(), m_rfLC.getSrcId(), m_rfLC.getDstId());
LogMessage((net) ? LOG_NET : LOG_RF, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL_RESP ", emerg = %u, encrypt = %u, prio = %u, chNo = %u, srcId = %u, dstId = %u",
m_rfLC.getEmergency(), m_rfLC.getEncrypted(), m_rfLC.getPriority(), m_rfLC.getGrpVchNo(), m_rfLC.getSrcId(), m_rfLC.getDstId());
}
// transmit group grant
@ -568,8 +556,8 @@ void Trunk::writeRF_Message_Deny(uint8_t reason, uint8_t service)
m_rfLC.setCauseResponse(reason);
if (m_verbose) {
LogMessage(LOG_RF, "NXDN, %s, reason = $%02X, service = $%02X, srcId = %u, dstId = %u",
NXDNUtils::messageTypeToString(service, true), service, m_rfLC.getSrcId(), m_rfLC.getDstId());
LogMessage(LOG_RF, "NXDN, MSG_DENIAL (Message Denial), reason = $%02X, service = $%02X, srcId = %u, dstId = %u",
service, m_rfLC.getSrcId(), m_rfLC.getDstId());
}
writeRF_Message(false);
@ -591,24 +579,21 @@ bool Trunk::writeRF_Message_Grp_Reg_Rsp(uint32_t srcId, uint32_t dstId)
// validate the location ID
if (m_rfLC.getLocId() != m_nxdn->m_siteData.locId()) {
LogWarning(LOG_RF, "NXDN %s denial, LOCID rejection, locId = $%04X",
NXDNUtils::messageTypeToString(RCCH_MESSAGE_TYPE_GRP_REG, true), m_rfLC.getLocId());
LogWarning(LOG_RF, "NXDN, " NXDN_RCCH_MSG_TYPE_GRP_REG_REQ " denial, LOCID rejection, locId = $%04X", m_rfLC.getLocId());
::ActivityLog("NXDN", true, "group affiliation request from %u denied", srcId);
m_rfLC.setCauseResponse(NXDN_CAUSE_MM_REG_FAILED);
}
// validate the source RID
if (!acl::AccessControl::validateSrcId(srcId)) {
LogWarning(LOG_RF, "NXDN %s denial, RID rejection, srcId = %u",
NXDNUtils::messageTypeToString(RCCH_MESSAGE_TYPE_GRP_REG, true), srcId);
LogWarning(LOG_RF, "NXDN, " NXDN_RCCH_MSG_TYPE_GRP_REG_REQ " denial, RID rejection, srcId = %u", srcId);
::ActivityLog("NXDN", true, "group affiliation request from %u to %s %u denied", srcId, "TG ", dstId);
m_rfLC.setCauseResponse(NXDN_CAUSE_MM_REG_FAILED);
}
// validate the source RID is registered
if (!m_nxdn->m_affiliations.isUnitReg(srcId) && m_verifyReg) {
LogWarning(LOG_RF, "NXDN %s denial, RID not registered, srcId = %u",
NXDNUtils::messageTypeToString(RCCH_MESSAGE_TYPE_GRP_REG, true), srcId);
LogWarning(LOG_RF, "NXDN, " NXDN_RCCH_MSG_TYPE_GRP_REG_REQ " denial, RID not registered, srcId = %u", srcId);
::ActivityLog("NXDN", true, "group affiliation request from %u to %s %u denied", srcId, "TG ", dstId);
m_rfLC.setCauseResponse(NXDN_CAUSE_MM_REG_REFUSED);
}
@ -616,13 +601,11 @@ bool Trunk::writeRF_Message_Grp_Reg_Rsp(uint32_t srcId, uint32_t dstId)
// validate the talkgroup ID
if (m_rfLC.getGroup()) {
if (dstId == 0U) {
LogWarning(LOG_RF, "NXDN %s, TGID 0, dstId = %u",
NXDNUtils::messageTypeToString(RCCH_MESSAGE_TYPE_GRP_REG, true), dstId);
LogWarning(LOG_RF, "NXDN, " NXDN_RCCH_MSG_TYPE_GRP_REG_REQ ", TGID 0, dstId = %u", dstId);
}
else {
if (!acl::AccessControl::validateTGId(dstId)) {
LogWarning(LOG_RF, "NXDN %s denial, TGID rejection, dstId = %u",
NXDNUtils::messageTypeToString(RCCH_MESSAGE_TYPE_GRP_REG, true), dstId);
LogWarning(LOG_RF, "NXDN, " NXDN_RCCH_MSG_TYPE_GRP_REG_REQ " denial, TGID rejection, dstId = %u", dstId);
::ActivityLog("NXDN", true, "group affiliation request from %u to %s %u denied", srcId, "TG ", dstId);
m_rfLC.setCauseResponse(NXDN_CAUSE_MM_LOC_ACPT_GRP_REFUSE);
}
@ -631,8 +614,7 @@ bool Trunk::writeRF_Message_Grp_Reg_Rsp(uint32_t srcId, uint32_t dstId)
if (m_rfLC.getCauseResponse() == NXDN_CAUSE_MM_REG_ACCEPTED) {
if (m_verbose) {
LogMessage(LOG_RF, "NXDN %s, srcId = %u, dstId = %u",
NXDNUtils::messageTypeToString(RCCH_MESSAGE_TYPE_GRP_REG, true, true), srcId, dstId);
LogMessage(LOG_RF, "NXDN, " NXDN_RCCH_MSG_TYPE_GRP_REG_REQ ", srcId = %u, dstId = %u", srcId, dstId);
}
::ActivityLog("NXDN", true, "group affiliation request from %u to %s %u", srcId, "TG ", dstId);
@ -657,24 +639,21 @@ void Trunk::writeRF_Message_U_Reg_Rsp(uint32_t srcId)
// validate the location ID
if (m_rfLC.getLocId() != m_nxdn->m_siteData.locId()) {
LogWarning(LOG_RF, "NXDN %s denial, LOCID rejection, locId = $%04X",
NXDNUtils::messageTypeToString(RCCH_MESSAGE_TYPE_REG, true), m_rfLC.getLocId());
LogWarning(LOG_RF, "NXDN, " NXDN_RCCH_MSG_TYPE_REG_REQ " denial, LOCID rejection, locId = $%04X", m_rfLC.getLocId());
::ActivityLog("NXDN", true, "unit registration request from %u denied", srcId);
m_rfLC.setCauseResponse(NXDN_CAUSE_MM_REG_FAILED);
}
// validate the source RID
if (!acl::AccessControl::validateSrcId(srcId)) {
LogWarning(LOG_RF, "NXDN %s denial, RID rejection, srcId = %u",
NXDNUtils::messageTypeToString(RCCH_MESSAGE_TYPE_REG, true), srcId);
LogWarning(LOG_RF, "NXDN, " NXDN_RCCH_MSG_TYPE_REG_REQ " denial, RID rejection, srcId = %u", srcId);
::ActivityLog("NXDN", true, "unit registration request from %u denied", srcId);
m_rfLC.setCauseResponse(NXDN_CAUSE_MM_REG_FAILED);
}
if (m_rfLC.getCauseResponse() == NXDN_CAUSE_MM_REG_ACCEPTED) {
if (m_verbose) {
LogMessage(LOG_RF, "NXDN %s, srcId = %u, locId = %u",
NXDNUtils::messageTypeToString(RCCH_MESSAGE_TYPE_REG, true, true), srcId, m_rfLC.getLocId());
LogMessage(LOG_RF, "NXDN, " NXDN_RCCH_MSG_TYPE_REG_REQ ", srcId = %u, locId = %u", srcId, m_rfLC.getLocId());
}
::ActivityLog("NXDN", true, "unit registration request from %u", srcId);
@ -697,7 +676,7 @@ void Trunk::writeRF_Message_U_Reg_Rsp(uint32_t srcId)
void Trunk::writeRF_CC_Message_Site_Info()
{
if (m_debug) {
LogMessage(LOG_RF, "NXDN, %s", NXDNUtils::messageTypeToString(RCCH_MESSAGE_TYPE_SITE_INFO));
LogMessage(LOG_RF, "NXDN, SITE_INFO (Site Information)");
}
uint8_t data[NXDN_FRAME_LENGTH_BYTES + 2U];
@ -739,7 +718,7 @@ void Trunk::writeRF_CC_Message_Site_Info()
void Trunk::writeRF_CC_Message_Service_Info()
{
if (m_debug) {
LogMessage(LOG_RF, "NXDN, %s", NXDNUtils::messageTypeToString(MESSAGE_TYPE_SRV_INFO));
LogMessage(LOG_RF, "NXDN, SRV_INFO (Service Information)");
}
uint8_t data[NXDN_FRAME_LENGTH_BYTES + 2U];

@ -36,7 +36,6 @@
#include "nxdn/acl/AccessControl.h"
#include "nxdn/Audio.h"
#include "nxdn/Sync.h"
#include "nxdn/NXDNUtils.h"
#include "edac/CRC.h"
#include "HostMain.h"
#include "Log.h"
@ -111,8 +110,7 @@ using namespace nxdn::packet;
#define VALID_SRCID(_SRC_ID, _DST_ID, _GROUP) \
if (!acl::AccessControl::validateSrcId(_SRC_ID)) { \
if (m_lastRejectId == 0U || m_lastRejectId != _SRC_ID) { \
LogWarning(LOG_RF, "NXDN, %s denial, RID rejection, srcId = %u", \
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_VCALL), _SRC_ID); \
LogWarning(LOG_RF, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL " denial, RID rejection, srcId = %u", _SRC_ID); \
::ActivityLog("NXDN", true, "RF voice rejection from %u to %s%u ", _SRC_ID, _GROUP ? "TG " : "", _DST_ID); \
m_lastRejectId = _SRC_ID; \
} \
@ -128,8 +126,7 @@ using namespace nxdn::packet;
if (!_GROUP) { \
if (!acl::AccessControl::validateSrcId(_DST_ID)) { \
if (m_lastRejectId == 0 || m_lastRejectId != _DST_ID) { \
LogWarning(LOG_RF, "NXDN %s denial, RID rejection, dstId = %u", \
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_VCALL), _DST_ID); \
LogWarning(LOG_RF, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL " denial, RID rejection, dstId = %u", _DST_ID); \
::ActivityLog("NXDN", true, "RF voice rejection from %u to %s%u ", _SRC_ID, _GROUP ? "TG " : "", _DST_ID); \
m_lastRejectId = _DST_ID; \
} \
@ -143,8 +140,7 @@ using namespace nxdn::packet;
else { \
if (!acl::AccessControl::validateTGId(_DST_ID)) { \
if (m_lastRejectId == 0 || m_lastRejectId != _DST_ID) { \
LogWarning(LOG_RF, "NXDN %s denial, TGID rejection, dstId = %u", \
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_VCALL), _DST_ID); \
LogWarning(LOG_RF, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL " denial, TGID rejection, dstId = %u", _DST_ID); \
::ActivityLog("NXDN", true, "RF voice rejection from %u to %s%u ", _SRC_ID, _GROUP ? "TG " : "", _DST_ID); \
m_lastRejectId = _DST_ID; \
} \
@ -287,8 +283,8 @@ bool Voice::process(uint8_t fct, uint8_t option, uint8_t* data, uint32_t len)
float(m_rfFrames) / 12.5F, float(m_rfErrs * 100U) / float(m_rfBits));
}
LogMessage(LOG_RF, "NXDN %s, total frames: %d, bits: %d, undecodable LC: %d, errors: %d, BER: %.4f%%",
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_TX_REL), m_rfFrames, m_rfBits, m_rfUndecodableLC, m_rfErrs, float(m_rfErrs * 100U) / float(m_rfBits));
LogMessage(LOG_RF, "NXDN, " NXDN_RTCH_MSG_TYPE_TX_REL ", total frames: %d, bits: %d, undecodable LC: %d, errors: %d, BER: %.4f%%",
m_rfFrames, m_rfBits, m_rfUndecodableLC, m_rfErrs, float(m_rfErrs * 100U) / float(m_rfBits));
m_nxdn->writeEndRF();
} else {
@ -304,8 +300,8 @@ bool Voice::process(uint8_t fct, uint8_t option, uint8_t* data, uint32_t len)
m_nxdn->m_rssiCount = 1U;
if (m_verbose) {
LogMessage(LOG_RF, "NXDN %s, srcId = %u, dstId = %u, group = %u, emerg = %u, encrypt = %u, prio = %u, algo = $%02X, kid = $%02X",
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_VCALL), srcId, dstId, group, lc.getEmergency(), encrypted, lc.getPriority(), lc.getAlgId(), lc.getKId());
LogMessage(LOG_RF, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL ", srcId = %u, dstId = %u, group = %u, emerg = %u, encrypt = %u, prio = %u, algo = $%02X, kid = $%02X",
srcId, dstId, group, lc.getEmergency(), encrypted, lc.getPriority(), lc.getAlgId(), lc.getKId());
}
::ActivityLog("NXDN", true, "RF %svoice transmission from %u to %s%u", encrypted ? "encrypted " : "", srcId, group ? "TG " : "", dstId);
@ -410,8 +406,8 @@ bool Voice::process(uint8_t fct, uint8_t option, uint8_t* data, uint32_t len)
m_nxdn->m_rssiCount = 1U;
if (m_verbose) {
LogMessage(LOG_RF, "NXDN %s, srcId = %u, dstId = %u, group = %u, emerg = %u, encrypt = %u, prio = %u, algo = $%02X, kid = $%04X",
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_VCALL), srcId, dstId, group, m_nxdn->m_rfLC.getEmergency(), encrypted, m_nxdn->m_rfLC.getPriority(), m_nxdn->m_rfLC.getAlgId(), m_nxdn->m_rfLC.getKId());
LogMessage(LOG_RF, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL ", srcId = %u, dstId = %u, group = %u, emerg = %u, encrypt = %u, prio = %u, algo = $%02X, kid = $%04X",
srcId, dstId, group, m_nxdn->m_rfLC.getEmergency(), encrypted, m_nxdn->m_rfLC.getPriority(), m_nxdn->m_rfLC.getAlgId(), m_nxdn->m_rfLC.getKId());
}
::ActivityLog("NXDN", true, "RF %slate entry from %u to %s%u", encrypted ? "encrypted ": "", srcId, group ? "TG " : "", dstId);
@ -503,16 +499,14 @@ bool Voice::process(uint8_t fct, uint8_t option, uint8_t* data, uint32_t len)
::memcpy(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 18U, NXDN_NULL_AMBE, 9U);
::memcpy(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 27U, NXDN_NULL_AMBE, 9U);
LogWarning(LOG_RF, "NXDN %s, exceeded lost audio threshold, filling in",
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_VCALL));
LogWarning(LOG_RF, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL ", exceeded lost audio threshold, filling in");
}
m_rfErrs += errors;
m_rfBits += 188U;
if (m_verbose) {
LogMessage(LOG_RF, "NXDN %s, audio, errs = %u/141 (%.1f%%)",
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_VCALL), errors, float(errors) / 1.88F);
LogMessage(LOG_RF, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL ", audio, errs = %u/141 (%.1f%%)", errors, float(errors) / 1.88F);
}
} else if (option == NXDN_LICH_STEAL_FACCH1_1) {
channel::FACCH1 facch1;
@ -535,16 +529,14 @@ bool Voice::process(uint8_t fct, uint8_t option, uint8_t* data, uint32_t len)
::memcpy(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 18U, NXDN_NULL_AMBE, 9U);
::memcpy(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 27U, NXDN_NULL_AMBE, 9U);
LogWarning(LOG_RF, "NXDN %s, exceeded lost audio threshold, filling in",
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_VCALL));
LogWarning(LOG_RF, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL ", exceeded lost audio threshold, filling in");
}
m_rfErrs += errors;
m_rfBits += 94U;
if (m_verbose) {
LogMessage(LOG_RF, "NXDN %s, audio, errs = %u/94 (%.1f%%)",
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_VCALL), errors, float(errors) / 0.94F);
LogMessage(LOG_RF, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL ", audio, errs = %u/94 (%.1f%%)", errors, float(errors) / 0.94F);
}
} else if (option == NXDN_LICH_STEAL_FACCH1_2) {
edac::AMBEFEC ambe;
@ -562,16 +554,14 @@ bool Voice::process(uint8_t fct, uint8_t option, uint8_t* data, uint32_t len)
::memcpy(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 0U, NXDN_NULL_AMBE, 9U);
::memcpy(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 9U, NXDN_NULL_AMBE, 9U);
LogWarning(LOG_RF, "NXDN %s, exceeded lost audio threshold, filling in",
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_VCALL));
LogWarning(LOG_RF, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL ", exceeded lost audio threshold, filling in");
}
m_rfErrs += errors;
m_rfBits += 94U;
if (m_verbose) {
LogMessage(LOG_RF, "NXDN %s, audio, errs = %u/94 (%.1f%%)",
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_VCALL), errors, float(errors) / 0.94F);
LogMessage(LOG_RF, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL ", audio, errs = %u/94 (%.1f%%)", errors, float(errors) / 0.94F);
}
channel::FACCH1 facch1;
@ -709,8 +699,7 @@ bool Voice::processNetwork(uint8_t fct, uint8_t option, lc::RTCH& netLC, uint8_t
::ActivityLog("NXDN", false, "network end of transmission, %.1f seconds",
float(m_netFrames) / 12.5F);
LogMessage(LOG_NET, "NXDN %s, total frames: %d",
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_TX_REL), m_netFrames);
LogMessage(LOG_NET, "NXDN, " NXDN_RTCH_MSG_TYPE_TX_REL ", total frames: %d", m_netFrames);
m_nxdn->writeEndNet();
} else {
@ -719,8 +708,8 @@ bool Voice::processNetwork(uint8_t fct, uint8_t option, lc::RTCH& netLC, uint8_t
m_nxdn->m_netState = RS_NET_AUDIO;
if (m_verbose) {
LogMessage(LOG_NET, "NXDN %s, srcId = %u, dstId = %u, group = %u, emerg = %u, encrypt = %u, prio = %u, algo = $%02X, kid = $%02X",
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_VCALL), srcId, dstId, group, lc.getEmergency(), encrypted, lc.getPriority(), lc.getAlgId(), lc.getKId());
LogMessage(LOG_NET, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL ", srcId = %u, dstId = %u, group = %u, emerg = %u, encrypt = %u, prio = %u, algo = $%02X, kid = $%02X",
srcId, dstId, group, lc.getEmergency(), encrypted, lc.getPriority(), lc.getAlgId(), lc.getKId());
}
::ActivityLog("NXDN", false, "network %svoice transmission from %u to %s%u", encrypted ? "encrypted " : "", srcId, group ? "TG " : "", dstId);
@ -820,8 +809,8 @@ bool Voice::processNetwork(uint8_t fct, uint8_t option, lc::RTCH& netLC, uint8_t
m_nxdn->m_netState = RS_NET_AUDIO;
if (m_verbose) {
LogMessage(LOG_NET, "NXDN %s, srcId = %u, dstId = %u, group = %u, emerg = %u, encrypt = %u, prio = %u, algo = $%02X, kid = $%04X",
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_VCALL), srcId, dstId, group, m_nxdn->m_netLC.getEmergency(), encrypted, m_nxdn->m_netLC.getPriority(), m_nxdn->m_netLC.getAlgId(), m_nxdn->m_netLC.getKId());
LogMessage(LOG_NET, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL ", srcId = %u, dstId = %u, group = %u, emerg = %u, encrypt = %u, prio = %u, algo = $%02X, kid = $%04X",
srcId, dstId, group, m_nxdn->m_netLC.getEmergency(), encrypted, m_nxdn->m_netLC.getPriority(), m_nxdn->m_netLC.getAlgId(), m_nxdn->m_netLC.getKId());
}
::ActivityLog("NXDN", false, "network %slate entry from %u to %s%u", encrypted ? "encrypted ": "", srcId, group ? "TG " : "", dstId);
@ -901,8 +890,7 @@ bool Voice::processNetwork(uint8_t fct, uint8_t option, lc::RTCH& netLC, uint8_t
m_rfBits += 188U;
if (m_verbose) {
LogMessage(LOG_NET, "NXDN %s, audio, errs = %u/141 (%.1f%%)",
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_VCALL), errors, float(errors) / 1.88F);
LogMessage(LOG_NET, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL ", audio, errs = %u/141 (%.1f%%)", errors, float(errors) / 1.88F);
}
} else if (option == NXDN_LICH_STEAL_FACCH1_1) {
channel::FACCH1 facch1;
@ -921,8 +909,7 @@ bool Voice::processNetwork(uint8_t fct, uint8_t option, lc::RTCH& netLC, uint8_t
m_rfBits += 94U;
if (m_verbose) {
LogMessage(LOG_RF, "NXDN %s, audio, errs = %u/94 (%.1f%%)",
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_VCALL), errors, float(errors) / 0.94F);
LogMessage(LOG_NET, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL ", audio, errs = %u/94 (%.1f%%)", errors, float(errors) / 0.94F);
}
} else if (option == NXDN_LICH_STEAL_FACCH1_2) {
edac::AMBEFEC ambe;
@ -936,8 +923,7 @@ bool Voice::processNetwork(uint8_t fct, uint8_t option, lc::RTCH& netLC, uint8_t
m_rfBits += 94U;
if (m_verbose) {
LogMessage(LOG_RF, "NXDN %s, audio, errs = %u/94 (%.1f%%)",
NXDNUtils::messageTypeToString(RTCH_MESSAGE_TYPE_VCALL), errors, float(errors) / 0.94F);
LogMessage(LOG_NET, "NXDN, " NXDN_RTCH_MSG_TYPE_VCALL ", audio, errs = %u/94 (%.1f%%)", errors, float(errors) / 0.94F);
}
channel::FACCH1 facch1;
bool valid = facch1.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_LENGTH_BITS + NXDN_FACCH1_LENGTH_BITS);

Loading…
Cancel
Save

Powered by TurnKey Linux.