MMDVM/MMDVMHost
1
0
Fork 0
mirror of https://github.com/g4klx/MMDVMHost synced 2025-12-23 08:45:48 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'g4klx/nxdn' into nxdn

Browse Source
This commit is contained in:
Andy CA6JAU
2018-02-01 19:47:53 -03:00
parent d4fbc8f7ec 7cc2a042b5
commit 7c95bb7d6d
14 changed files with 265 additions and 307 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
Conf.cpp
View File

@@ -165,6 +165,7 @@ m_dmrNetworkLocal(0U),
m_dmrNetworkPassword(), m_dmrNetworkPassword(),
m_dmrNetworkOptions(), m_dmrNetworkOptions(),
m_dmrNetworkDebug(false), m_dmrNetworkDebug(false),
m_dmrNetworkJitterEnabled(true),
m_dmrNetworkJitter(300U), m_dmrNetworkJitter(300U),
m_dmrNetworkSlot1(true), m_dmrNetworkSlot1(true),
m_dmrNetworkSlot2(true), m_dmrNetworkSlot2(true),
@@ -595,6 +596,8 @@ bool CConf::read()
m_dmrNetworkOptions = value; m_dmrNetworkOptions = value;
else if (::strcmp(key, "Debug") == 0) else if (::strcmp(key, "Debug") == 0)
m_dmrNetworkDebug = ::atoi(value) == 1; m_dmrNetworkDebug = ::atoi(value) == 1;
else if (::strcmp(key, "JitterEnabled") == 0)
m_dmrNetworkJitterEnabled = ::atoi(value) == 1;
else if (::strcmp(key, "Jitter") == 0) else if (::strcmp(key, "Jitter") == 0)
m_dmrNetworkJitter = (unsigned int)::atoi(value); m_dmrNetworkJitter = (unsigned int)::atoi(value);
else if (::strcmp(key, "Slot1") == 0) else if (::strcmp(key, "Slot1") == 0)
@@ -1266,6 +1269,11 @@ bool CConf::getDMRNetworkDebug() const
return m_dmrNetworkDebug; return m_dmrNetworkDebug;
} }
bool CConf::getDMRNetworkJitterEnabled() const
{
return m_dmrNetworkJitterEnabled;
}
unsigned int CConf::getDMRNetworkJitter() const unsigned int CConf::getDMRNetworkJitter() const
{ {
return m_dmrNetworkJitter; return m_dmrNetworkJitter;

2
Conf.h
View File

@@ -167,6 +167,7 @@ public:
std::string getDMRNetworkPassword() const; std::string getDMRNetworkPassword() const;
std::string getDMRNetworkOptions() const; std::string getDMRNetworkOptions() const;
bool getDMRNetworkDebug() const; bool getDMRNetworkDebug() const;
bool getDMRNetworkJitterEnabled() const;
unsigned int getDMRNetworkJitter() const; unsigned int getDMRNetworkJitter() const;
bool getDMRNetworkSlot1() const; bool getDMRNetworkSlot1() const;
bool getDMRNetworkSlot2() const; bool getDMRNetworkSlot2() const;
@@ -360,6 +361,7 @@ private:
std::string m_dmrNetworkPassword; std::string m_dmrNetworkPassword;
std::string m_dmrNetworkOptions; std::string m_dmrNetworkOptions;
bool m_dmrNetworkDebug; bool m_dmrNetworkDebug;
bool m_dmrNetworkJitterEnabled;
unsigned int m_dmrNetworkJitter; unsigned int m_dmrNetworkJitter;
bool m_dmrNetworkSlot1; bool m_dmrNetworkSlot1;
bool m_dmrNetworkSlot2; bool m_dmrNetworkSlot2;

11
DMRNetwork.cpp
View File

@@ -32,7 +32,7 @@ const unsigned int BUFFER_LENGTH = 500U;
const unsigned int HOMEBREW_DATA_PACKET_LENGTH = 55U; const unsigned int HOMEBREW_DATA_PACKET_LENGTH = 55U;
CDMRNetwork::CDMRNetwork(const std::string& address, unsigned int port, unsigned int local, unsigned int id, const std::string& password, bool duplex, const char* version, bool debug, bool slot1, bool slot2, HW_TYPE hwType, unsigned int jitter) : CDMRNetwork::CDMRNetwork(const std::string& address, unsigned int port, unsigned int local, unsigned int id, const std::string& password, bool duplex, const char* version, bool debug, bool slot1, bool slot2, HW_TYPE hwType, bool jitterEnabled, unsigned int jitter) :
m_address(), m_address(),
m_port(port), m_port(port),
m_id(NULL), m_id(NULL),
@@ -44,6 +44,7 @@ m_socket(local),
m_enabled(false), m_enabled(false),
m_slot1(slot1), m_slot1(slot1),
m_slot2(slot2), m_slot2(slot2),
m_jitterEnabled(jitterEnabled),
m_jitterBuffers(NULL), m_jitterBuffers(NULL),
m_hwType(hwType), m_hwType(hwType),
m_status(WAITING_CONNECT), m_status(WAITING_CONNECT),
@@ -498,9 +499,7 @@ void CDMRNetwork::receiveData(const unsigned char* data, unsigned int length)
if (slotNo == 2U && !m_slot2) if (slotNo == 2U && !m_slot2)
return; return;
m_jitterBuffers[slotNo]->appendData(data, length); if (m_jitterEnabled) {
/*
unsigned char dataType = data[15U] & 0x3FU; unsigned char dataType = data[15U] & 0x3FU;
if (dataType == (0x20U | DT_CSBK) || if (dataType == (0x20U | DT_CSBK) ||
dataType == (0x20U | DT_DATA_HEADER) || dataType == (0x20U | DT_DATA_HEADER) ||
@@ -514,7 +513,9 @@ void CDMRNetwork::receiveData(const unsigned char* data, unsigned int length)
unsigned char seqNo = data[4U]; unsigned char seqNo = data[4U];
m_jitterBuffers[slotNo]->addData(data, length, seqNo); m_jitterBuffers[slotNo]->addData(data, length, seqNo);
} }
*/ } else {
m_jitterBuffers[slotNo]->appendData(data, length);
}
} }
bool CDMRNetwork::writeLogin() bool CDMRNetwork::writeLogin()

3
DMRNetwork.h
View File

@@ -31,7 +31,7 @@
class CDMRNetwork class CDMRNetwork
{ {
public: public:
CDMRNetwork(const std::string& address, unsigned int port, unsigned int local, unsigned int id, const std::string& password, bool duplex, const char* version, bool debug, bool slot1, bool slot2, HW_TYPE hwType, unsigned int jitter); CDMRNetwork(const std::string& address, unsigned int port, unsigned int local, unsigned int id, const std::string& password, bool duplex, const char* version, bool debug, bool slot1, bool slot2, HW_TYPE hwType, bool jitterEnabled, unsigned int jitter);
~CDMRNetwork(); ~CDMRNetwork();
void setOptions(const std::string& options); void setOptions(const std::string& options);
@@ -70,6 +70,7 @@ private:
bool m_enabled; bool m_enabled;
bool m_slot1; bool m_slot1;
bool m_slot2; bool m_slot2;
bool m_jitterEnabled;
CJitterBuffer** m_jitterBuffers; CJitterBuffer** m_jitterBuffers;
HW_TYPE m_hwType; HW_TYPE m_hwType;

1
MMDVM.ini
View File

@@ -131,6 +131,7 @@ Debug=0
Enable=1 Enable=1
Address=44.131.4.1 Address=44.131.4.1
Port=62031 Port=62031
JitterEnabled=1
Jitter=500 Jitter=500
# Local=62032 # Local=62032
Password=PASSWORD Password=PASSWORD

4
MMDVMHost.cpp
View File

@@ -1035,6 +1035,7 @@ bool CMMDVMHost::createDMRNetwork()
unsigned int id = m_conf.getDMRId(); unsigned int id = m_conf.getDMRId();
std::string password = m_conf.getDMRNetworkPassword(); std::string password = m_conf.getDMRNetworkPassword();
bool debug = m_conf.getDMRNetworkDebug(); bool debug = m_conf.getDMRNetworkDebug();
bool jitterEnabled = m_conf.getDMRNetworkJitterEnabled();
unsigned int jitter = m_conf.getDMRNetworkJitter(); unsigned int jitter = m_conf.getDMRNetworkJitter();
bool slot1 = m_conf.getDMRNetworkSlot1(); bool slot1 = m_conf.getDMRNetworkSlot1();
bool slot2 = m_conf.getDMRNetworkSlot2(); bool slot2 = m_conf.getDMRNetworkSlot2();
@@ -1048,12 +1049,13 @@ bool CMMDVMHost::createDMRNetwork()
LogInfo(" Local: %u", local); LogInfo(" Local: %u", local);
else else
LogInfo(" Local: random"); LogInfo(" Local: random");
LogInfo(" Jitter Buffer: %s", jitterEnabled ? "enabled" : "disabled");
LogInfo(" Jitter: %ums", jitter); LogInfo(" Jitter: %ums", jitter);
LogInfo(" Slot 1: %s", slot1 ? "enabled" : "disabled"); LogInfo(" Slot 1: %s", slot1 ? "enabled" : "disabled");
LogInfo(" Slot 2: %s", slot2 ? "enabled" : "disabled"); LogInfo(" Slot 2: %s", slot2 ? "enabled" : "disabled");
LogInfo(" Mode Hang: %us", m_dmrNetModeHang); LogInfo(" Mode Hang: %us", m_dmrNetModeHang);
m_dmrNetwork = new CDMRNetwork(address, port, local, id, password, m_duplex, VERSION, debug, slot1, slot2, hwType, jitter); m_dmrNetwork = new CDMRNetwork(address, port, local, id, password, m_duplex, VERSION, debug, slot1, slot2, hwType, jitterEnabled, jitter);
std::string options = m_conf.getDMRNetworkOptions(); std::string options = m_conf.getDMRNetworkOptions();
if (!options.empty()) { if (!options.empty()) {

150
NXDNCRC.cpp
View File

@@ -22,30 +22,25 @@
#include <cassert> #include <cassert>
const uint8_t BIT_MASK_TABLE1[] = { 0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02U, 0x01U }; const uint8_t BIT_MASK_TABLE1[] = { 0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02U, 0x01U };
const uint16_t BIT_MASK_TABLE2[] = { 0x8000U, 0x4000U, 0x2000U, 0x1000U, 0x0800U, 0x0400U, 0x0200U, 0x0100U,
0x0080U, 0x0040U, 0x0020U, 0x0010U, 0x0008U, 0x0004U, 0x0002U, 0x0001U };
#define WRITE_BIT1(p,i,b) p[(i)>>3] = (b) ? (p[(i)>>3] | BIT_MASK_TABLE1[(i)&7]) : (p[(i)>>3] & ~BIT_MASK_TABLE1[(i)&7]) #define WRITE_BIT1(p,i,b) p[(i)>>3] = (b) ? (p[(i)>>3] | BIT_MASK_TABLE1[(i)&7]) : (p[(i)>>3] & ~BIT_MASK_TABLE1[(i)&7])
#define READ_BIT1(p,i) (p[(i)>>3] & BIT_MASK_TABLE1[(i)&7]) #define READ_BIT1(p,i) (p[(i)>>3] & BIT_MASK_TABLE1[(i)&7])
#define READ_BIT2(p,i) (p[(i)>>4] & BIT_MASK_TABLE2[(i)&15])
bool CNXDNCRC::checkCRC6(const unsigned char* in, unsigned int length) bool CNXDNCRC::checkCRC6(const unsigned char* in, unsigned int length)
{ {
assert(in != NULL); assert(in != NULL);
uint8_t crc[1U]; uint8_t crc = createCRC6(in, length);
crc[0U] = createCRC6(in, length);
unsigned int n = length; uint8_t temp[1U];
for (unsigned int i = 0U; i < 6U; i++, n++) { temp[0U] = 0x00U;
bool b1 = READ_BIT1(crc, i); unsigned int j = length;
bool b2 = READ_BIT1(in, n); for (unsigned int i = 2U; i < 8U; i++, j++) {
if (b1 != b2) bool b = READ_BIT1(in, j);
return false; WRITE_BIT1(temp, i, b);
} }
return true; return crc == temp[0U];
} }
void CNXDNCRC::encodeCRC6(unsigned char* in, unsigned int length) void CNXDNCRC::encodeCRC6(unsigned char* in, unsigned int length)
@@ -56,7 +51,7 @@ void CNXDNCRC::encodeCRC6(unsigned char* in, unsigned int length)
crc[0U] = createCRC6(in, length); crc[0U] = createCRC6(in, length);
unsigned int n = length; unsigned int n = length;
for (unsigned int i = 0U; i < 6U; i++, n++) { for (unsigned int i = 2U; i < 8U; i++, n++) {
bool b = READ_BIT1(crc, i); bool b = READ_BIT1(crc, i);
WRITE_BIT1(in, n, b); WRITE_BIT1(in, n, b);
} }
@@ -66,30 +61,36 @@ bool CNXDNCRC::checkCRC12(const unsigned char* in, unsigned int length)
{ {
assert(in != NULL); assert(in != NULL);
uint16_t crc[1U]; uint16_t crc = createCRC12(in, length);
crc[0U] = createCRC12(in, length); uint8_t temp1[2U];
temp1[0U] = (crc >> 8) & 0xFFU;
temp1[1U] = (crc >> 0) & 0xFFU;
unsigned int n = length; uint8_t temp2[2U];
for (unsigned int i = 0U; i < 12U; i++, n++) { temp2[0U] = 0x00U;
bool b1 = READ_BIT2(crc, i); temp2[1U] = 0x00U;
bool b2 = READ_BIT1(in, n); unsigned int j = length;
if (b1 != b2) for (unsigned int i = 4U; i < 16U; i++, j++) {
return false; bool b = READ_BIT1(in, j);
WRITE_BIT1(temp2, i, b);
} }
return true; return temp1[0U] == temp2[0U] && temp1[1U] == temp2[1U];
} }
void CNXDNCRC::encodeCRC12(unsigned char* in, unsigned int length) void CNXDNCRC::encodeCRC12(unsigned char* in, unsigned int length)
{ {
assert(in != NULL); assert(in != NULL);
uint16_t crc[1U]; uint16_t crc = createCRC12(in, length);
crc[0U] = createCRC12(in, length);
uint8_t temp[2U];
temp[0U] = (crc >> 8) & 0xFFU;
temp[1U] = (crc >> 0) & 0xFFU;
unsigned int n = length; unsigned int n = length;
for (unsigned int i = 0U; i < 12U; i++, n++) { for (unsigned int i = 4U; i < 16U; i++, n++) {
bool b = READ_BIT2(crc, i); bool b = READ_BIT1(temp, i);
WRITE_BIT1(in, n, b); WRITE_BIT1(in, n, b);
} }
} }
@@ -98,123 +99,90 @@ bool CNXDNCRC::checkCRC15(const unsigned char* in, unsigned int length)
{ {
assert(in != NULL); assert(in != NULL);
uint16_t crc[1U]; uint16_t crc = createCRC15(in, length);
crc[0U] = createCRC15(in, length); uint8_t temp1[2U];
temp1[0U] = (crc >> 8) & 0xFFU;
temp1[1U] = (crc >> 0) & 0xFFU;
unsigned int n = length; uint16_t temp2[2U];
for (unsigned int i = 0U; i < 15U; i++, n++) { temp2[0U] = 0x00U;
bool b1 = READ_BIT2(crc, i); temp2[1U] = 0x00U;
bool b2 = READ_BIT1(in, n); unsigned int j = length;
if (b1 != b2) for (unsigned int i = 1U; i < 16U; i++, j++) {
return false; bool b = READ_BIT1(in, j);
WRITE_BIT1(temp2, i, b);
} }
return true; return temp1[0U] == temp2[0U] && temp1[1U] == temp2[1U];
} }
void CNXDNCRC::encodeCRC15(unsigned char* in, unsigned int length) void CNXDNCRC::encodeCRC15(unsigned char* in, unsigned int length)
{ {
assert(in != NULL); assert(in != NULL);
uint16_t crc[1U]; uint16_t crc = createCRC15(in, length);
crc[0U] = createCRC15(in, length);
uint8_t temp[2U];
temp[0U] = (crc >> 8) & 0xFFU;
temp[1U] = (crc >> 0) & 0xFFU;
unsigned int n = length; unsigned int n = length;
for (unsigned int i = 0U; i < 15U; i++, n++) { for (unsigned int i = 1U; i < 16U; i++, n++) {
bool b = READ_BIT2(crc, i); bool b = READ_BIT1(temp, i);
WRITE_BIT1(in, n, b); WRITE_BIT1(in, n, b);
} }
} }
uint8_t CNXDNCRC::createCRC6(const unsigned char* in, unsigned int length) uint8_t CNXDNCRC::createCRC6(const unsigned char* in, unsigned int length)
{ {
uint8_t crc = 0x3EU; uint8_t crc = 0x3FU;
for (unsigned int i = 0U; i < length; i++) { for (unsigned int i = 0U; i < length; i++) {
bool bit1 = READ_BIT1(in, i) != 0x00U; bool bit1 = READ_BIT1(in, i) != 0x00U;
bool bit2 = (crc & 0x20U) == 0x20U; bool bit2 = (crc & 0x20U) == 0x20U;
crc <<= 1; crc <<= 1;
crc &= 0x3EU;
if (bit1) if (bit1 ^ bit2)
crc |= 0x01U;
if (bit2)
crc ^= 0x27U;
crc &= 0x3FU;
}
for (unsigned int i = 0U; i < 6U; i++) {
bool bit = (crc & 0x20U) == 0x20U;
crc <<= 1;
if (bit)
crc ^= 0x27U; crc ^= 0x27U;
} }
return (crc & 0x3FU) << 2U; return crc;
} }
uint16_t CNXDNCRC::createCRC12(const unsigned char* in, unsigned int length) uint16_t CNXDNCRC::createCRC12(const unsigned char* in, unsigned int length)
{ {
uint16_t crc = 0x0D9EU; uint16_t crc = 0x0FFFU;
for (unsigned int i = 0U; i < length; i++) { for (unsigned int i = 0U; i < length; i++) {
bool bit1 = READ_BIT1(in, i) != 0x00U; bool bit1 = READ_BIT1(in, i) != 0x00U;
bool bit2 = (crc & 0x0800U) == 0x0800U; bool bit2 = (crc & 0x0800U) == 0x0800U;
crc <<= 1; crc <<= 1;
crc &= 0x0FFEU;
if (bit1) if (bit1 ^ bit2)
crc |= 0x0001U;
if (bit2)
crc ^= 0x080FU;
crc &= 0x0FFFU;
}
for (unsigned int i = 0U; i < 12U; i++) {
bool bit = (crc & 0x0800U) == 0x0800U;
crc <<= 1;
if (bit)
crc ^= 0x080FU; crc ^= 0x080FU;
} }
return (crc & 0x0FFFU) << 4U; return crc & 0x0FFFU;
} }
uint16_t CNXDNCRC::createCRC15(const unsigned char* in, unsigned int length) uint16_t CNXDNCRC::createCRC15(const unsigned char* in, unsigned int length)
{ {
uint16_t crc = 0x02E4U; uint16_t crc = 0x7FFFU;
for (unsigned int i = 0U; i < length; i++) { for (unsigned int i = 0U; i < length; i++) {
bool bit1 = READ_BIT1(in, i) != 0x00U; bool bit1 = READ_BIT1(in, i) != 0x00U;
bool bit2 = (crc & 0x4000U) == 0x4000U; bool bit2 = (crc & 0x4000U) == 0x4000U;
crc <<= 1; crc <<= 1;
crc &= 0x7FFEU;
if (bit1) if (bit1 ^ bit2)
crc |= 0x0001U;
if (bit2)
crc ^= 0x4CC5U;
crc &= 0x7FFFU;
}
for (unsigned int i = 0U; i < 15U; i++) {
bool bit = (crc & 0x4000U) == 0x4000U;
crc <<= 1;
if (bit)
crc ^= 0x4CC5U; crc ^= 0x4CC5U;
} }
return (crc & 0x7FFFU) << 1U; return crc & 0x7FFFU;
} }

76
NXDNControl.cpp
View File

@@ -91,9 +91,9 @@ bool CNXDNControl::writeModem(unsigned char *data, unsigned int len)
if (type == TAG_LOST && m_rfState == RS_RF_AUDIO) { if (type == TAG_LOST && m_rfState == RS_RF_AUDIO) {
if (m_rssi != 0U) if (m_rssi != 0U)
LogMessage("NXDN, transmission lost, %.1f seconds, BER: %.1f%%, RSSI: -%u/-%u/-%u dBm", float(m_rfFrames) / 10.0F, float(m_rfErrs * 100U) / float(m_rfBits), m_minRSSI, m_maxRSSI, m_aveRSSI / m_rssiCount); LogMessage("NXDN, transmission lost, %.1f seconds, BER: %.1f%%, RSSI: -%u/-%u/-%u dBm", float(m_rfFrames) / 25.0F, float(m_rfErrs * 100U) / float(m_rfBits), m_minRSSI, m_maxRSSI, m_aveRSSI / m_rssiCount);
else else
LogMessage("NXDN, transmission lost, %.1f seconds, BER: %.1f%%", float(m_rfFrames) / 10.0F, float(m_rfErrs * 100U) / float(m_rfBits)); LogMessage("NXDN, transmission lost, %.1f seconds, BER: %.1f%%", float(m_rfFrames) / 25.0F, float(m_rfErrs * 100U) / float(m_rfBits));
writeEndRF(); writeEndRF();
return false; return false;
} }
@@ -174,25 +174,24 @@ bool CNXDNControl::processVoice(unsigned char usc, unsigned char option, unsigne
unsigned char ran = sacch.getRAN(); unsigned char ran = sacch.getRAN();
if (ran != m_ran && ran != 0U) if (ran != m_ran && ran != 0U)
return false; return false;
} else if (m_rfState == RS_RF_LISTENING) {
return false;
} }
// XXX Reconstruct invalid LICH // XXX Reconstruct invalid LICH
if (usc == NXDN_LICH_USC_SACCH_NS) { if (usc == NXDN_LICH_USC_SACCH_NS) {
// The SACCH on a non-superblock frame is usually an idle and not interesting apart from the RAN. // The SACCH on a non-superblock frame is usually an idle and not interesting apart from the RAN.
CNXDNFACCH1 facch11; CNXDNFACCH1 facch;
bool valid1 = facch11.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_LENGTH_BITS); bool valid = facch.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_LENGTH_BITS);
if (!valid)
CNXDNFACCH1 facch12; valid = facch.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_LENGTH_BITS + NXDN_FACCH1_LENGTH_BITS);
bool valid2 = facch12.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_LENGTH_BITS + NXDN_FACCH1_LENGTH_BITS); if (!valid)
return false;
unsigned char buffer[10U]; unsigned char buffer[10U];
if (valid1) facch.getData(buffer);
facch11.getData(buffer);
else if (valid2)
facch12.getData(buffer);
if (valid1 || valid2) {
CNXDNLayer3 layer3; CNXDNLayer3 layer3;
layer3.decode(buffer, NXDN_FACCH1_LENGTH_BITS); layer3.decode(buffer, NXDN_FACCH1_LENGTH_BITS);
@@ -204,7 +203,8 @@ bool CNXDNControl::processVoice(unsigned char usc, unsigned char option, unsigne
return false; return false;
} }
} else { } else {
if (m_selfOnly) { bool hasInfo = layer3.getHasInfo();
if (m_rfState == RS_RF_LISTENING && m_selfOnly && hasInfo) {
unsigned short srcId = layer3.getSourceUnitId(); unsigned short srcId = layer3.getSourceUnitId();
if (srcId != m_id) { if (srcId != m_id) {
m_rfState = RS_RF_REJECTED; m_rfState = RS_RF_REJECTED;
@@ -228,13 +228,8 @@ bool CNXDNControl::processVoice(unsigned char usc, unsigned char option, unsigne
sacch.setData(SACCH_IDLE); sacch.setData(SACCH_IDLE);
sacch.encode(data + 2U); sacch.encode(data + 2U);
if (valid1) { facch.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_LENGTH_BITS);
facch11.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_LENGTH_BITS); facch.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_LENGTH_BITS + NXDN_FACCH1_LENGTH_BITS);
facch11.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_LENGTH_BITS + NXDN_FACCH1_LENGTH_BITS);
} else {
facch12.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_LENGTH_BITS);
facch12.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_LENGTH_BITS + NXDN_FACCH1_LENGTH_BITS);
}
scrambler(data + 2U); scrambler(data + 2U);
@@ -243,7 +238,6 @@ bool CNXDNControl::processVoice(unsigned char usc, unsigned char option, unsigne
#if defined(DUMP_NXDN) #if defined(DUMP_NXDN)
writeFile(data + 2U); writeFile(data + 2U);
#endif #endif
if (m_duplex) if (m_duplex)
writeQueueRF(data); writeQueueRF(data);
@@ -252,16 +246,14 @@ bool CNXDNControl::processVoice(unsigned char usc, unsigned char option, unsigne
if (m_rssi != 0U) if (m_rssi != 0U)
LogMessage("NXDN, received RF end of transmission, %.1f seconds, BER: %.1f%%, RSSI: -%u/-%u/-%u dBm", float(m_rfFrames) / 25.0F, float(m_rfErrs * 100U) / float(m_rfBits), m_minRSSI, m_maxRSSI, m_aveRSSI / m_rssiCount); LogMessage("NXDN, received RF end of transmission, %.1f seconds, BER: %.1f%%, RSSI: -%u/-%u/-%u dBm", float(m_rfFrames) / 25.0F, float(m_rfErrs * 100U) / float(m_rfBits), m_minRSSI, m_maxRSSI, m_aveRSSI / m_rssiCount);
else else
LogMessage("NXDN, received RF end of transmission, %.1f seconds, BER: %.1f%%", float(m_rfFrames) / 10.0F, float(m_rfErrs * 100U) / float(m_rfBits)); LogMessage("NXDN, received RF end of transmission, %.1f seconds, BER: %.1f%%", float(m_rfFrames) / 25.0F, float(m_rfErrs * 100U) / float(m_rfBits));
writeEndRF(); writeEndRF();
return true;
} else { } else {
m_rfFrames = 0U; m_rfFrames = 0U;
m_rfErrs = 0U; m_rfErrs = 0U;
m_rfBits = 1U; m_rfBits = 1U;
m_rfTimeoutTimer.start(); m_rfTimeoutTimer.start();
m_rfState = RS_RF_AUDIO; m_rfState = RS_RF_AUDIO;
m_minRSSI = m_rssi; m_minRSSI = m_rssi;
m_maxRSSI = m_rssi; m_maxRSSI = m_rssi;
m_aveRSSI = m_rssi; m_aveRSSI = m_rssi;
@@ -276,17 +268,13 @@ bool CNXDNControl::processVoice(unsigned char usc, unsigned char option, unsigne
bool grp = m_rfLayer3.getIsGroup(); bool grp = m_rfLayer3.getIsGroup();
std::string source = m_lookup->find(srcId); std::string source = m_lookup->find(srcId);
LogMessage("NXDN, received RF voice transmission from %s to %s%u", source.c_str(), grp ? "TG " : "", dstId); LogMessage("NXDN, received RF header from %s to %s%u", source.c_str(), grp ? "TG " : "", dstId);
m_display->writeNXDN(source.c_str(), grp, dstId, "R"); m_display->writeNXDN(source.c_str(), grp, dstId, "R");
}
m_rfState = RS_RF_AUDIO;
return true; return true;
}
}
return false;
} else { } else {
if (m_rfState == RS_RF_LISTENING) {
unsigned char message[3U]; unsigned char message[3U];
sacch.getData(message); sacch.getData(message);
@@ -315,8 +303,8 @@ bool CNXDNControl::processVoice(unsigned char usc, unsigned char option, unsigne
if (m_rfMask != 0x0FU) if (m_rfMask != 0x0FU)
return false; return false;
unsigned char messageType = m_rfLayer3.getMessageType(); bool hasInfo = m_rfLayer3.getHasInfo();
if (messageType != NXDN_MESSAGE_TYPE_VCALL) if (!hasInfo)
return false; return false;
unsigned short srcId = m_rfLayer3.getSourceUnitId(); unsigned short srcId = m_rfLayer3.getSourceUnitId();
@@ -344,13 +332,14 @@ bool CNXDNControl::processVoice(unsigned char usc, unsigned char option, unsigne
openFile(); openFile();
#endif #endif
std::string source = m_lookup->find(srcId); std::string source = m_lookup->find(srcId);
LogMessage("NXDN, received RF voice transmission from %s to %s%u", source.c_str(), grp ? "TG " : "", dstId); LogMessage("NXDN, received RF late entry from %s to %s%u", source.c_str(), grp ? "TG " : "", dstId);
m_display->writeNXDN(source.c_str(), grp, dstId, "R"); m_display->writeNXDN(source.c_str(), grp, dstId, "R");
m_rfState = RS_RF_AUDIO; m_rfState = RS_RF_AUDIO;
} }
}
// if (m_rfState == RS_RF_AUDIO) { if (m_rfState == RS_RF_AUDIO) {
// Regenerate the sync // Regenerate the sync
CSync::addNXDNSync(data + 2U); CSync::addNXDNSync(data + 2U);
@@ -460,24 +449,7 @@ bool CNXDNControl::processVoice(unsigned char usc, unsigned char option, unsigne
m_rfFrames++; m_rfFrames++;
m_display->writeNXDNRSSI(m_rssi); m_display->writeNXDNRSSI(m_rssi);
#ifdef notdef
// Process end of audio here
if (endofdata) {
if (m_rfState == RS_RF_AUDIO) {
if (m_rssi != 0U)
LogMessage("NXDN, received RF end of transmission, %.1f seconds, BER: %.1f%%, RSSI: -%u/-%u/-%u dBm", float(m_rfFrames) / 10.0F, float(m_rfErrs * 100U) / float(m_rfBits), m_minRSSI, m_maxRSSI, m_aveRSSI / m_rssiCount);
else
LogMessage("NXDN, received RF end of transmission, %.1f seconds, BER: %.1f%%", float(m_rfFrames) / 10.0F, float(m_rfErrs * 100U) / float(m_rfBits));
writeEndRF();
} else {
m_rfState = RS_RF_LISTENING;
m_rfMask = 0x00U;
return false;
} }
}
#endif
return true; return true;
} }

3
NXDNConvolution.cpp
View File

@@ -21,6 +21,7 @@
#include <cstdio> #include <cstdio>
#include <cassert> #include <cassert>
#include <cstring> #include <cstring>
#include <cmath>
const unsigned char BIT_MASK_TABLE[] = {0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02U, 0x01U}; const unsigned char BIT_MASK_TABLE[] = {0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02U, 0x01U};
@@ -72,7 +73,7 @@ void CNXDNConvolution::decode(uint8_t s0, uint8_t s1)
for (uint8_t i = 0U; i < NUM_OF_STATES_D2; i++) { for (uint8_t i = 0U; i < NUM_OF_STATES_D2; i++) {
uint8_t j = i * 2U; uint8_t j = i * 2U;
uint16_t metric = abs(BRANCH_TABLE1[i] - s0) + abs(BRANCH_TABLE2[i] - s1); uint16_t metric = ::abs(BRANCH_TABLE1[i] - s0) + ::abs(BRANCH_TABLE2[i] - s1);
uint16_t m0 = m_oldMetrics[i] + metric; uint16_t m0 = m_oldMetrics[i] + metric;
uint16_t m1 = m_oldMetrics[i + NUM_OF_STATES_D2] + (M - metric); uint16_t m1 = m_oldMetrics[i + NUM_OF_STATES_D2] + (M - metric);

8
NXDNFACCH1.cpp
View File

@@ -115,7 +115,7 @@ bool CNXDNFACCH1::decode(const unsigned char* data, unsigned int offset)
conv.chainback(m_data, 96U); conv.chainback(m_data, 96U);
CUtils::dump("NXDN, FACCH1 decoded", m_data, 12U); // CUtils::dump("NXDN, FACCH1 decoded", m_data, 12U);
return CNXDNCRC::checkCRC12(m_data, 80U); return CNXDNCRC::checkCRC12(m_data, 80U);
} }
@@ -126,11 +126,7 @@ void CNXDNFACCH1::encode(unsigned char* data, unsigned int offset) const
unsigned char temp1[12U]; unsigned char temp1[12U];
::memset(temp1, 0x00U, 12U); ::memset(temp1, 0x00U, 12U);
::memcpy(temp1, m_data, 10U);
for (unsigned int i = 0U; i < 80U; i++) {
bool b = READ_BIT1(m_data, i);
WRITE_BIT1(temp1, i, b);
}
CNXDNCRC::encodeCRC12(temp1, 80U); CNXDNCRC::encodeCRC12(temp1, 80U);

9
NXDNLayer3.cpp
View File

@@ -93,6 +93,15 @@ unsigned char CNXDNLayer3::getCallOptions() const
return m_data[2U] & 0x1FU; return m_data[2U] & 0x1FU;
} }
bool CNXDNLayer3::getHasInfo() const
{
unsigned char type = getMessageType();
return type != NXDN_MESSAGE_TYPE_IDLE &&
type != NXDN_MESSAGE_TYPE_VCALL_IV &&
type != NXDN_MESSAGE_TYPE_SDCALL_IV;
}
CNXDNLayer3& CNXDNLayer3::operator=(const CNXDNLayer3& layer3) CNXDNLayer3& CNXDNLayer3::operator=(const CNXDNLayer3& layer3)
{ {
if (&layer3 != this) if (&layer3 != this)

1
NXDNLayer3.h
View File

@@ -34,6 +34,7 @@ public:
unsigned short getDestinationGroupId() const; unsigned short getDestinationGroupId() const;
bool getIsGroup() const; bool getIsGroup() const;
unsigned char getCallOptions() const; unsigned char getCallOptions() const;
bool getHasInfo() const;
CNXDNLayer3& operator=(const CNXDNLayer3& layer3); CNXDNLayer3& operator=(const CNXDNLayer3& layer3);

8
NXDNSACCH.cpp
View File

@@ -108,7 +108,7 @@ bool CNXDNSACCH::decode(const unsigned char* data)
conv.chainback(m_data, 36U); conv.chainback(m_data, 36U);
CUtils::dump("NXDN, SACCH decoded", m_data, 4U); // CUtils::dump("NXDN, SACCH decoded", m_data, 4U);
return CNXDNCRC::checkCRC6(m_data, 26U); return CNXDNCRC::checkCRC6(m_data, 26U);
} }
@@ -127,14 +127,14 @@ void CNXDNSACCH::encode(unsigned char* data) const
CNXDNCRC::encodeCRC6(temp1, 26U); CNXDNCRC::encodeCRC6(temp1, 26U);
CUtils::dump("NXDN, SACCH encoded with CRC", temp1, 4U); // CUtils::dump("NXDN, SACCH encoded with CRC", temp1, 4U);
unsigned char temp2[8U]; unsigned char temp2[9U];
CNXDNConvolution conv; CNXDNConvolution conv;
conv.encode(temp1, temp2, 36U); conv.encode(temp1, temp2, 36U);
// CUtils::dump("NXDN, SACCH convolved", temp2, 8U); // CUtils::dump("NXDN, SACCH convolved", temp2, 9U);
unsigned char temp3[8U]; unsigned char temp3[8U];

18
NXDNUDCH.cpp
View File

@@ -93,7 +93,7 @@ bool CNXDNUDCH::decode(const unsigned char* data)
{ {
assert(data != NULL); assert(data != NULL);
CUtils::dump("NXDN, UDCH/FACCH2 input", data, 44U); // CUtils::dump("NXDN, UDCH/FACCH2 input", data, 44U);
unsigned char temp1[44U]; unsigned char temp1[44U];
@@ -103,7 +103,7 @@ bool CNXDNUDCH::decode(const unsigned char* data)
WRITE_BIT1(temp1, i, b); WRITE_BIT1(temp1, i, b);
} }
CUtils::dump("NXDN, UDCH/FACCH2 de-interleaved", temp1, 44U); // CUtils::dump("NXDN, UDCH/FACCH2 de-interleaved", temp1, 44U);
uint8_t temp2[420U]; uint8_t temp2[420U];
@@ -136,7 +136,7 @@ bool CNXDNUDCH::decode(const unsigned char* data)
conv.chainback(m_data, 203U); conv.chainback(m_data, 203U);
CUtils::dump("NXDN, UDCH/FACCH2 decoded", m_data, 25U); // CUtils::dump("NXDN, UDCH/FACCH2 decoded", m_data, 25U);
return CNXDNCRC::checkCRC15(m_data, 184U); return CNXDNCRC::checkCRC15(m_data, 184U);
} }
@@ -147,22 +147,18 @@ void CNXDNUDCH::encode(unsigned char* data) const
unsigned char temp1[25U]; unsigned char temp1[25U];
::memset(temp1, 0x00U, 25U); ::memset(temp1, 0x00U, 25U);
::memcpy(temp1, m_data, 23U);
for (unsigned int i = 0U; i < 184U; i++) {
bool b = READ_BIT1(m_data, i);
WRITE_BIT1(temp1, i, b);
}
CNXDNCRC::encodeCRC15(temp1, 184U); CNXDNCRC::encodeCRC15(temp1, 184U);
CUtils::dump("NXDN, UDCH/FACCH2 encoded with CRC", temp1, 25U); // CUtils::dump("NXDN, UDCH/FACCH2 encoded with CRC", temp1, 25U);
unsigned char temp2[51U]; unsigned char temp2[51U];
CNXDNConvolution conv; CNXDNConvolution conv;
conv.encode(temp1, temp2, 203U); conv.encode(temp1, temp2, 203U);
CUtils::dump("NXDN, UDCH/FACCH2 convolved", temp2, 51U); // CUtils::dump("NXDN, UDCH/FACCH2 convolved", temp2, 51U);
unsigned char temp3[44U]; unsigned char temp3[44U];
@@ -178,7 +174,7 @@ void CNXDNUDCH::encode(unsigned char* data) const
} }
} }
CUtils::dump("NXDN, UDCH/FACCH2 punctured", temp3, 44U); // CUtils::dump("NXDN, UDCH/FACCH2 punctured", temp3, 44U);
for (unsigned int i = 0U; i < NXDN_FACCH2_LENGTH_BITS; i++) { for (unsigned int i = 0U; i < NXDN_FACCH2_LENGTH_BITS; i++) {
unsigned int n = INTERLEAVE_TABLE[i] + NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS; unsigned int n = INTERLEAVE_TABLE[i] + NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS;