Crash_Override/MMDVMHost-Private
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
MMDVMHost-Private/NXDNControl.cpp
Jonathan Naylor 83e97aa218 Update the log messages.
2018-02-01 18:49:03 +00:00

982 lines
25 KiB
C++
Raw Blame History

/*
* Copyright (C) 2015,2016,2017,2018 Jonathan Naylor, G4KLX
*
* 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; version 2 of the License.
*
* 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.
*/
#include "NXDNControl.h"
#include "NXDNFACCH1.h"
#include "NXDNSACCH.h"
#include "NXDNUDCH.h"
#include "AMBEFEC.h"
#include "Utils.h"
#include "Sync.h"
#include "Log.h"
#include <cstdio>
#include <cassert>
#include <cstring>
#include <ctime>
const unsigned char SCRAMBLER[] = {
0x00U, 0x00U, 0x00U, 0x82U, 0xA0U, 0x88U, 0x8AU, 0x00U, 0xA2U, 0xA8U, 0x82U, 0x8AU, 0x82U, 0x02U,
0x20U, 0x08U, 0x8AU, 0x20U, 0xAAU, 0xA2U, 0x82U, 0x08U, 0x22U, 0x8AU, 0xAAU, 0x08U, 0x28U, 0x88U,
0x28U, 0x28U, 0x00U, 0x0AU, 0x02U, 0x82U, 0x20U, 0x28U, 0x82U, 0x2AU, 0xAAU, 0x20U, 0x22U, 0x80U,
0xA8U, 0x8AU, 0x08U, 0xA0U, 0xAAU, 0x02U };
// #define DUMP_NXDN
const unsigned char BIT_MASK_TABLE[] = { 0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02U, 0x01U };
#define WRITE_BIT1(p,i,b) p[(i)>>3] = (b) ? (p[(i)>>3] | BIT_MASK_TABLE[(i)&7]) : (p[(i)>>3] & ~BIT_MASK_TABLE[(i)&7])
#define READ_BIT1(p,i) (p[(i)>>3] & BIT_MASK_TABLE[(i)&7])
CNXDNControl::CNXDNControl(unsigned int ran, unsigned int id, bool selfOnly, CNXDNNetwork* network, CDisplay* display, unsigned int timeout, bool duplex, bool remoteGateway, CNXDNLookup* lookup, CRSSIInterpolator* rssiMapper) :
m_ran(ran),
m_id(id),
m_selfOnly(selfOnly),
m_network(network),
m_display(display),
m_duplex(duplex),
m_remoteGateway(remoteGateway),
m_lookup(lookup),
m_queue(5000U, "NXDN Control"),
m_rfState(RS_RF_LISTENING),
m_netState(RS_NET_IDLE),
m_rfTimeoutTimer(1000U, timeout),
m_netTimeoutTimer(1000U, timeout),
m_packetTimer(1000U, 0U, 200U),
m_networkWatchdog(1000U, 0U, 1500U),
m_elapsed(),
m_rfFrames(0U),
m_netFrames(0U),
m_netLost(0U),
m_rfErrs(0U),
m_rfBits(1U),
m_netErrs(0U),
m_netBits(1U),
m_rfLastLICH(),
m_rfLayer3(),
m_rfMask(0x00U),
m_netN(0U),
m_rssiMapper(rssiMapper),
m_rssi(0U),
m_maxRSSI(0U),
m_minRSSI(0U),
m_aveRSSI(0U),
m_rssiCount(0U),
m_fp(NULL)
{
assert(display != NULL);
assert(lookup != NULL);
assert(rssiMapper != NULL);
}
CNXDNControl::~CNXDNControl()
{
}
bool CNXDNControl::writeModem(unsigned char *data, unsigned int len)
{
assert(data != NULL);
unsigned char type = data[0U];
if (type == TAG_LOST && m_rfState == RS_RF_AUDIO) {
if (m_rssi != 0U)
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
LogMessage("NXDN, transmission lost, %.1f seconds, BER: %.1f%%", float(m_rfFrames) / 25.0F, float(m_rfErrs * 100U) / float(m_rfBits));
writeEndRF();
return false;
}
if (type == TAG_LOST && m_rfState == RS_RF_DATA) {
writeEndRF();
return false;
}
if (type == TAG_LOST) {
m_rfState = RS_RF_LISTENING;
m_rfMask = 0x00U;
return false;
}
// Have we got RSSI bytes on the end?
if (len == (NXDN_FRAME_LENGTH_BYTES + 4U)) {
uint16_t raw = 0U;
raw |= (data[50U] << 8) & 0xFF00U;
raw |= (data[51U] << 0) & 0x00FFU;
// Convert the raw RSSI to dBm
int rssi = m_rssiMapper->interpolate(raw);
LogDebug("NXDN, raw RSSI: %u, reported RSSI: %d dBm", raw, rssi);
// RSSI is always reported as positive
m_rssi = (rssi >= 0) ? rssi : -rssi;
if (m_rssi > m_minRSSI)
m_minRSSI = m_rssi;
if (m_rssi < m_maxRSSI)
m_maxRSSI = m_rssi;
m_aveRSSI += m_rssi;
m_rssiCount++;
}
// CUtils::dump(2U, "NXDN, raw data", data + 2U, NXDN_FRAME_LENGTH_BYTES);
scrambler(data + 2U);
// CUtils::dump(2U, "NXDN, after descrambling", data + 2U, NXDN_FRAME_LENGTH_BYTES);
CNXDNLICH lich;
bool valid = lich.decode(data + 2U);
if (valid)
m_rfLastLICH = lich;
// Stop repeater packets coming through, unless we're acting as a remote gateway
if (m_remoteGateway) {
unsigned char direction = m_rfLastLICH.getDirection();
if (direction == NXDN_LICH_DIRECTION_INBOUND)
return false;
} else {
unsigned char direction = m_rfLastLICH.getDirection();
if (direction == NXDN_LICH_DIRECTION_OUTBOUND)
return false;
}
unsigned char usc = m_rfLastLICH.getFCT();
unsigned char option = m_rfLastLICH.getOption();
bool ret;
if (usc == NXDN_LICH_USC_UDCH)
ret = processData(option, data);
else
ret = processVoice(usc, option, data);
return ret;
}
bool CNXDNControl::processVoice(unsigned char usc, unsigned char option, unsigned char *data)
{
CNXDNSACCH sacch;
bool valid = sacch.decode(data + 2U);
if (valid) {
unsigned char ran = sacch.getRAN();
if (ran != m_ran && ran != 0U)
return false;
} else if (m_rfState == RS_RF_LISTENING) {
// return false;
}
// XXX Reconstruct invalid LICH
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.
CNXDNFACCH1 facch;
bool valid = facch.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_LENGTH_BITS);
if (!valid)
valid = facch.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];
facch.getData(buffer);
CNXDNLayer3 layer3;
layer3.decode(buffer, NXDN_FACCH1_LENGTH_BITS);
unsigned char type = layer3.getMessageType();
if (type == NXDN_MESSAGE_TYPE_TX_REL) {
if (m_rfState != RS_RF_AUDIO) {
m_rfState = RS_RF_LISTENING;
m_rfMask = 0x00U;
return false;
}
} else {
bool hasInfo = layer3.getHasInfo();
if (m_rfState == RS_RF_LISTENING && m_selfOnly && hasInfo) {
unsigned short srcId = layer3.getSourceUnitId();
if (srcId != m_id) {
m_rfState = RS_RF_REJECTED;
return false;
}
}
}
data[0U] = type == NXDN_MESSAGE_TYPE_TX_REL ? TAG_EOT : TAG_DATA;
data[1U] = 0x00U;
CSync::addNXDNSync(data + 2U);
CNXDNLICH lich = m_rfLastLICH;
lich.setDirection(m_remoteGateway ? NXDN_LICH_DIRECTION_INBOUND : NXDN_LICH_DIRECTION_OUTBOUND);
lich.encode(data + 2U);
CNXDNSACCH sacch;
sacch.setRAN(m_ran);
sacch.setStructure(NXDN_SR_SINGLE);
sacch.setData(SACCH_IDLE);
sacch.encode(data + 2U);
facch.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);
scrambler(data + 2U);
// writeNetwork(data, m_rfFrames, );
#if defined(DUMP_NXDN)
writeFile(data + 2U);
#endif
if (m_duplex)
writeQueueRF(data);
if (type == NXDN_MESSAGE_TYPE_TX_REL) {
m_rfFrames++;
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);
else
LogMessage("NXDN, received RF end of transmission, %.1f seconds, BER: %.1f%%", float(m_rfFrames) / 25.0F, float(m_rfErrs * 100U) / float(m_rfBits));
writeEndRF();
} else {
m_rfFrames = 0U;
m_rfErrs = 0U;
m_rfBits = 1U;
m_rfTimeoutTimer.start();
m_rfState = RS_RF_AUDIO;
m_minRSSI = m_rssi;
m_maxRSSI = m_rssi;
m_aveRSSI = m_rssi;
m_rssiCount = 1U;
#if defined(DUMP_NXDN)
openFile();
#endif
m_rfLayer3 = layer3;
unsigned short srcId = m_rfLayer3.getSourceUnitId();
unsigned short dstId = m_rfLayer3.getDestinationGroupId();
bool grp = m_rfLayer3.getIsGroup();
std::string source = m_lookup->find(srcId);
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");
}
return true;
}
else {
// if (valid) {
unsigned char message[3U];
sacch.getData(message);
unsigned char structure = sacch.getStructure();
switch (structure) {
case NXDN_SR_1_4:
m_rfMask |= 0x01U;
m_rfLayer3.decode(message, 18U, 0U);
break;
case NXDN_SR_2_4:
m_rfMask |= 0x02U;
m_rfLayer3.decode(message, 18U, 18U);
break;
case NXDN_SR_3_4:
m_rfMask |= 0x04U;
m_rfLayer3.decode(message, 18U, 36U);
break;
case NXDN_SR_4_4:
m_rfMask |= 0x08U;
m_rfLayer3.decode(message, 18U, 54U);
break;
default:
break;
}
// if (m_rfMask != 0x0FU)
// return false;
unsigned char messageType = m_rfLayer3.getMessageType();
if (messageType != NXDN_MESSAGE_TYPE_VCALL)
return false;
unsigned short srcId = m_rfLayer3.getSourceUnitId();
unsigned short dstId = m_rfLayer3.getDestinationGroupId();
bool grp = m_rfLayer3.getIsGroup();
if (m_selfOnly) {
if (srcId != m_id) {
m_rfState = RS_RF_REJECTED;
return false;
}
}
m_rfFrames = 0U;
m_rfErrs = 0U;
m_rfBits = 1U;
m_rfTimeoutTimer.start();
m_rfState = RS_RF_AUDIO;
m_minRSSI = m_rssi;
m_maxRSSI = m_rssi;
m_aveRSSI = m_rssi;
m_rssiCount = 1U;
#if defined(DUMP_NXDN)
openFile();
#endif
std::string source = m_lookup->find(srcId);
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_rfState = RS_RF_AUDIO;
}
// }
// if (m_rfState == RS_RF_AUDIO) {
// Regenerate the sync
CSync::addNXDNSync(data + 2U);
// Regenerate the LICH
CNXDNLICH lich;
lich.setRFCT(NXDN_LICH_RFCT_RDCH);
lich.setFCT(usc);
lich.setOption(option);
lich.setDirection(m_remoteGateway ? NXDN_LICH_DIRECTION_INBOUND : NXDN_LICH_DIRECTION_OUTBOUND);
lich.encode(data + 2U);
// XXX Regenerate SACCH here
// Regenerate the audio and interpret the FACCH1 data
unsigned char voiceMode = m_rfLayer3.getCallOptions() & 0x07U;
if (option == NXDN_LICH_STEAL_NONE) {
CAMBEFEC ambe;
unsigned int errors = 0U;
if (voiceMode == NXDN_VOICE_CALL_OPTION_9600_EFR) {
errors += ambe.regenerateIMBE(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES);
errors += ambe.regenerateIMBE(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 18U);
m_rfErrs += errors;
m_rfBits += 288U;
m_display->writeNXDNBER(float(errors) / 2.88F);
LogDebug("NXDN, EFR, AMBE FEC %u/288 (%.1f%%)", errors, float(errors) / 2.88F);
} else {
errors += ambe.regenerateDMR(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES);
errors += ambe.regenerateDMR(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 9U);
errors += ambe.regenerateDMR(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 18U);
errors += ambe.regenerateDMR(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 27U);
m_rfErrs += errors;
m_rfBits += 188U;
m_display->writeNXDNBER(float(errors) / 1.88F);
LogDebug("NXDN, EHR, AMBE FEC %u/188 (%.1f%%)", errors, float(errors) / 1.88F);
}
} else if (option == NXDN_LICH_STEAL_FACCH1_1) {
CNXDNFACCH1 facch1;
bool valid = facch1.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_LENGTH_BITS);
if (valid)
facch1.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_LENGTH_BITS);
CAMBEFEC ambe;
unsigned int errors = 0U;
if (voiceMode == NXDN_VOICE_CALL_OPTION_9600_EFR) {
errors += ambe.regenerateIMBE(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 18U);
m_rfErrs += errors;
m_rfBits += 144U;
m_display->writeNXDNBER(float(errors) / 1.44F);
LogDebug("NXDN, EFR, AMBE FEC %u/144 (%.1f%%)", errors, float(errors) / 1.44F);
} else {
errors += ambe.regenerateDMR(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 18U);
errors += ambe.regenerateDMR(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 27U);
m_rfErrs += errors;
m_rfBits += 94U;
m_display->writeNXDNBER(float(errors) / 0.94F);
LogDebug("NXDN, EHR, AMBE FEC %u/94 (%.1f%%)", errors, float(errors) / 0.94F);
}
} else if (option == NXDN_LICH_STEAL_FACCH1_2) {
CAMBEFEC ambe;
unsigned int errors = 0U;
if (voiceMode == NXDN_VOICE_CALL_OPTION_9600_EFR) {
errors += ambe.regenerateIMBE(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES);
m_rfErrs += errors;
m_rfBits += 144U;
m_display->writeNXDNBER(float(errors) / 1.44F);
LogDebug("NXDN, EFR, AMBE FEC %u/144 (%.1f%%)", errors, float(errors) / 1.44F);
} else {
errors += ambe.regenerateDMR(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES);
errors += ambe.regenerateDMR(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 9U);
m_rfErrs += errors;
m_rfBits += 94U;
m_display->writeNXDNBER(float(errors) / 0.94F);
LogDebug("NXDN, EHR, AMBE FEC %u/94 (%.1f%%)", errors, float(errors) / 0.94F);
}
CNXDNFACCH1 facch1;
bool valid = facch1.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_LENGTH_BITS + NXDN_FACCH1_LENGTH_BITS);
if (valid)
facch1.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_LENGTH_BITS + NXDN_FACCH1_LENGTH_BITS);
} else {
CNXDNFACCH1 facch11;
bool valid1 = facch11.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_LENGTH_BITS);
if (valid1)
facch11.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_LENGTH_BITS);
CNXDNFACCH1 facch12;
bool valid2 = facch12.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_LENGTH_BITS + NXDN_FACCH1_LENGTH_BITS);
if (valid2)
facch12.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_LENGTH_BITS + NXDN_FACCH1_LENGTH_BITS);
}
data[0U] = TAG_DATA;
data[1U] = 0x00U;
scrambler(data + 2U);
// writeNetwork(data, m_rfFrames, );
#if defined(DUMP_NXDN)
writeFile(data + 2U);
#endif
if (m_duplex)
writeQueueRF(data);
m_rfFrames++;
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;
}
bool CNXDNControl::processData(unsigned char option, unsigned char *data)
{
CNXDNUDCH udch;
bool valid = udch.decode(data + 2U);
if (valid) {
unsigned char ran = udch.getRAN();
if (ran != m_ran && ran != 0U)
return false;
data[0U] = TAG_DATA;
data[1U] = 0x00U;
CSync::addNXDNSync(data + 2U);
CNXDNLICH lich;
lich.setRFCT(NXDN_LICH_RFCT_RDCH);
lich.setFCT(NXDN_LICH_USC_UDCH);
lich.setOption(option);
lich.setDirection(m_remoteGateway ? NXDN_LICH_DIRECTION_INBOUND : NXDN_LICH_DIRECTION_OUTBOUND);
lich.encode(data + 2U);
udch.setRAN(m_ran);
udch.encode(data + 2U);
scrambler(data + 2U);
writeQueueNet(data);
if (m_duplex)
writeQueueRF(data);
#if defined(DUMP_NXDN)
writeFile(data + 2U);
#endif
return true;
}
#ifdef notdef
unsigned char fi = m_lastFICH.getFI();
if (valid && fi == YSF_FI_HEADER) {
if (m_rfState == RS_RF_LISTENING) {
valid = m_rfPayload.processHeaderData(data + 2U);
if (!valid)
return false;
m_rfSource = m_rfPayload.getSource();
if (m_selfOnly) {
bool ret = checkCallsign(m_rfSource);
if (!ret) {
LogMessage("NXDN, invalid access attempt from %10.10s", m_rfSource);
m_rfState = RS_RF_REJECTED;
return false;
}
}
unsigned char cm = m_lastFICH.getCM();
if (cm == YSF_CM_GROUP1 || cm == YSF_CM_GROUP2)
m_rfDest = (unsigned char*)"ALL ";
else
m_rfDest = m_rfPayload.getDest();
m_rfFrames = 0U;
m_rfState = RS_RF_DATA;
m_minRSSI = m_rssi;
m_maxRSSI = m_rssi;
m_aveRSSI = m_rssi;
m_rssiCount = 1U;
#if defined(DUMP_NXDN)
openFile();
#endif
m_display->writeFusion((char*)m_rfSource, (char*)m_rfDest, "R", " ");
LogMessage("NXDN, received RF header from %10.10s to %10.10s", m_rfSource, m_rfDest);
CSync::addNXDNSync(data + 2U);
CYSFFICH fich = m_lastFICH;
// Remove any DSQ information
fich.setSQL(false);
fich.setSQ(0U);
fich.encode(data + 2U);
data[0U] = TAG_DATA;
data[1U] = 0x00U;
writeNetwork(data, m_rfFrames);
#if defined(DUMP_NXDN)
writeFile(data + 2U);
#endif
if (m_duplex) {
fich.setMR(m_remoteGateway ? YSF_MR_NOT_BUSY : YSF_MR_BUSY);
fich.encode(data + 2U);
writeQueueRF(data);
}
m_rfFrames++;
m_display->writeFusionRSSI(m_rssi);
return true;
}
} else if (valid && fi == YSF_FI_TERMINATOR) {
if (m_rfState == RS_RF_REJECTED) {
m_rfPayload.reset();
m_rfSource = NULL;
m_rfDest = NULL;
m_rfState = RS_RF_LISTENING;
} else if (m_rfState == RS_RF_DATA) {
m_rfPayload.processHeaderData(data + 2U);
CSync::addNXDNSync(data + 2U);
CYSFFICH fich = m_lastFICH;
// Remove any DSQ information
fich.setSQL(false);
fich.setSQ(0U);
fich.encode(data + 2U);
data[0U] = TAG_EOT;
data[1U] = 0x00U;
writeNetwork(data, m_rfFrames);
#if defined(DUMP_NXDN)
writeFile(data + 2U);
#endif
if (m_duplex) {
fich.setMR(m_remoteGateway ? YSF_MR_NOT_BUSY : YSF_MR_BUSY);
fich.encode(data + 2U);
writeQueueRF(data);
}
m_rfFrames++;
if (m_rssi != 0U)
LogMessage("NXDN, received RF end of transmission, %.1f seconds, RSSI: -%u/-%u/-%u dBm", float(m_rfFrames) / 10.0F, m_minRSSI, m_maxRSSI, m_aveRSSI / m_rssiCount);
else
LogMessage("NXDN, received RF end of transmission, %.1f seconds", float(m_rfFrames) / 10.0F);
writeEndRF();
}
} else {
if (m_rfState == RS_RF_DATA) {
// If valid is false, update the m_lastFICH for this transmission
if (!valid) {
unsigned char ft = m_lastFICH.getFT();
unsigned char fn = m_lastFICH.getFN() + 1U;
if (fn > ft)
fn = 0U;
m_lastFICH.setFN(fn);
}
CSync::addNXDNSync(data + 2U);
unsigned char fn = m_lastFICH.getFN();
m_rfPayload.processDataFRModeData(data + 2U, fn);
CYSFFICH fich = m_lastFICH;
// Remove any DSQ information
fich.setSQL(false);
fich.setSQ(0U);
fich.encode(data + 2U);
data[0U] = TAG_DATA;
data[1U] = 0x00U;
writeNetwork(data, m_rfFrames);
if (m_duplex) {
fich.setMR(m_remoteGateway ? YSF_MR_NOT_BUSY : YSF_MR_BUSY);
fich.encode(data + 2U);
writeQueueRF(data);
}
#if defined(DUMP_NXDN)
writeFile(data + 2U);
#endif
m_rfFrames++;
m_display->writeFusionRSSI(m_rssi);
return true;
}
}
#endif
return false;
}
unsigned int CNXDNControl::readModem(unsigned char* data)
{
assert(data != NULL);
if (m_queue.isEmpty())
return 0U;
unsigned char len = 0U;
m_queue.getData(&len, 1U);
m_queue.getData(data, len);
return len;
}
void CNXDNControl::writeEndRF()
{
m_rfState = RS_RF_LISTENING;
m_rfMask = 0x00U;
m_rfTimeoutTimer.stop();
if (m_netState == RS_NET_IDLE) {
m_display->clearNXDN();
if (m_network != NULL)
m_network->reset();
}
#if defined(DUMP_NXDN)
closeFile();
#endif
}
void CNXDNControl::writeEndNet()
{
m_netState = RS_NET_IDLE;
m_netTimeoutTimer.stop();
m_networkWatchdog.stop();
m_packetTimer.stop();
m_display->clearNXDN();
if (m_network != NULL)
m_network->reset();
}
#ifdef notdef
void CNXDNControl::writeNetwork()
{
unsigned char data[200U];
unsigned int length = m_network->read(data);
if (length == 0U)
return;
if (m_rfState != RS_RF_LISTENING && m_netState == RS_NET_IDLE)
return;
m_networkWatchdog.start();
unsigned char n = (data[5U] & 0xFEU) >> 1;
bool end = (data[5U] & 0x01U) == 0x01U;
if (!m_netTimeoutTimer.isRunning()) {
if (end)
return;
m_display->writeFusion((char*)m_netSource, (char*)m_netDest, "N", (char*)(data + 4U));
LogMessage("NXDN, received network data from %10.10s to %10.10s at %10.10s", m_netSource, m_netDest, data + 4U);
m_netTimeoutTimer.start();
m_packetTimer.start();
m_elapsed.start();
m_netState = RS_NET_AUDIO;
m_netFrames = 0U;
m_netLost = 0U;
m_netErrs = 0U;
m_netBits = 1U;
m_netN = 0U;
} else {
// Check for duplicate frames, if we can
if (m_netN == n)
return;
bool changed = false;
if (::memcmp(data + 14U, " ", YSF_CALLSIGN_LENGTH) != 0 && ::memcmp(m_netSource, "??????????", YSF_CALLSIGN_LENGTH) == 0) {
::memcpy(m_netSource, data + 14U, YSF_CALLSIGN_LENGTH);
changed = true;
}
if (::memcmp(data + 24U, " ", YSF_CALLSIGN_LENGTH) != 0 && ::memcmp(m_netDest, "??????????", YSF_CALLSIGN_LENGTH) == 0) {
::memcpy(m_netDest, data + 24U, YSF_CALLSIGN_LENGTH);
changed = true;
}
if (changed) {
m_display->writeFusion((char*)m_netSource, (char*)m_netDest, "N", (char*)(data + 4U));
LogMessage("YSF, received network data from %10.10s to %10.10s at %10.10s", m_netSource, m_netDest, data + 4U);
}
}
data[33U] = end ? TAG_EOT : TAG_DATA;
data[34U] = 0x00U;
CYSFFICH fich;
bool valid = fich.decode(data + 35U);
if (valid) {
unsigned char dt = fich.getDT();
unsigned char fn = fich.getFN();
unsigned char ft = fich.getFT();
unsigned char fi = fich.getFI();
fich.setVoIP(true);
fich.setMR(m_remoteGateway ? YSF_MR_NOT_BUSY : YSF_MR_BUSY);
fich.encode(data + 35U);
// Set the downlink callsign
switch (fi) {
case YSF_FI_HEADER:
case YSF_FI_TERMINATOR:
m_netPayload.processHeaderData(data + 35U);
break;
case YSF_FI_COMMUNICATIONS:
switch (dt) {
case YSF_DT_VD_MODE1: {
m_netPayload.processVDMode1Data(data + 35U, fn, gateway);
unsigned int errors = m_netPayload.processVDMode1Audio(data + 35U);
m_netErrs += errors;
m_netBits += 235U;
}
break;
case YSF_DT_VD_MODE2: {
m_netPayload.processVDMode2Data(data + 35U, fn, gateway);
unsigned int errors = m_netPayload.processVDMode2Audio(data + 35U);
m_netErrs += errors;
m_netBits += 135U;
}
break;
case YSF_DT_DATA_FR_MODE:
m_netPayload.processDataFRModeData(data + 35U, fn, gateway);
break;
case YSF_DT_VOICE_FR_MODE:
if (fn != 0U || ft != 1U) {
// The first packet after the header is odd, don't try and regenerate it
unsigned int errors = m_netPayload.processVoiceFRModeAudio(data + 35U);
m_netErrs += errors;
m_netBits += 720U;
}
break;
default:
break;
}
break;
default:
break;
}
}
writeQueueNet(data + 33U);
m_packetTimer.start();
m_netFrames++;
m_netN = n;
if (end) {
LogMessage("NXDN, received network end of transmission, %.1f seconds, %u%% packet loss, BER: %.1f%%", float(m_netFrames) / 10.0F, (m_netLost * 100U) / m_netFrames, float(m_netErrs * 100U) / float(m_netBits));
writeEndNet();
}
}
#endif
void CNXDNControl::clock(unsigned int ms)
{
#ifdef notdef
if (m_network != NULL)
writeNetwork();
#endif
m_rfTimeoutTimer.clock(ms);
m_netTimeoutTimer.clock(ms);
if (m_netState == RS_NET_AUDIO) {
m_networkWatchdog.clock(ms);
if (m_networkWatchdog.hasExpired()) {
LogMessage("NXDN, network watchdog has expired, %.1f seconds, %u%% packet loss, BER: %.1f%%", float(m_netFrames) / 10.0F, (m_netLost * 100U) / m_netFrames, float(m_netErrs * 100U) / float(m_netBits));
writeEndNet();
}
}
}
void CNXDNControl::writeQueueRF(const unsigned char *data)
{
assert(data != NULL);
if (m_netState != RS_NET_IDLE)
return;
if (m_rfTimeoutTimer.isRunning() && m_rfTimeoutTimer.hasExpired())
return;
unsigned char len = NXDN_FRAME_LENGTH_BYTES + 2U;
unsigned int space = m_queue.freeSpace();
if (space < (len + 1U)) {
LogError("NXDN, overflow in the NXDN RF queue");
return;
}
m_queue.addData(&len, 1U);
m_queue.addData(data, len);
}
void CNXDNControl::writeQueueNet(const unsigned char *data)
{
assert(data != NULL);
if (m_netTimeoutTimer.isRunning() && m_netTimeoutTimer.hasExpired())
return;
unsigned char len = NXDN_FRAME_LENGTH_BYTES + 2U;
unsigned int space = m_queue.freeSpace();
if (space < (len + 1U)) {
LogError("NXDN, overflow in the NXDN RF queue");
return;
}
m_queue.addData(&len, 1U);
m_queue.addData(data, len);
}
void CNXDNControl::writeNetwork(const unsigned char *data, unsigned int count, bool end)
{
assert(data != NULL);
if (m_network == NULL)
return;
if (m_rfTimeoutTimer.isRunning() && m_rfTimeoutTimer.hasExpired())
return;
unsigned short srcId = m_rfLayer3.getSourceUnitId();
unsigned short dstId = m_rfLayer3.getDestinationGroupId();
bool grp = m_rfLayer3.getIsGroup();
m_network->write(data + 2U, srcId, grp, dstId, count % 256U, end);
}
void CNXDNControl::scrambler(unsigned char* data) const
{
assert(data != NULL);
for (unsigned int i = 0U; i < NXDN_FRAME_LENGTH_BYTES; i++)
data[i] ^= SCRAMBLER[i];
}
bool CNXDNControl::openFile()
{
if (m_fp != NULL)
return true;
time_t t;
::time(&t);
struct tm* tm = ::localtime(&t);
char name[100U];
::sprintf(name, "NXDN_%04d%02d%02d_%02d%02d%02d.ambe", tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
m_fp = ::fopen(name, "wb");
if (m_fp == NULL)
return false;
::fwrite("NXDN", 1U, 3U, m_fp);
return true;
}
bool CNXDNControl::writeFile(const unsigned char* data)
{
if (m_fp == NULL)
return false;
::fwrite(data, 1U, NXDN_FRAME_LENGTH_BYTES, m_fp);
return true;
}
void CNXDNControl::closeFile()
{
if (m_fp != NULL) {
::fclose(m_fp);
m_fp = NULL;
}
}
Reference in a new issue View git blame Copy permalink