void CP25Control::createRFHeader() { unsigned char buffer[P25_HDR_FRAME_LENGTH_BYTES + 2U]; ::memset(buffer, 0x00U, P25_HDR_FRAME_LENGTH_BYTES + 2U); buffer[0U] = TAG_HEADER; buffer[1U] = 0x00U; // Add the sync CSync::addP25Sync(buffer + 2U); // Add the NID m_nid.encode(buffer + 2U, P25_DUID_HEADER); // Add the dummy header m_rfData.encodeHeader(buffer + 2U); // Add busy bits addBusyBits(buffer + 2U, P25_HDR_FRAME_LENGTH_BITS, false, true); m_rfFrames = 0U; m_rfErrs = 0U; m_rfBits = 1U; m_rfTimeout.start(); m_lastDUID = P25_DUID_HEADER; ::memset(m_rfLDU, 0x00U, P25_LDU_FRAME_LENGTH_BYTES); #if defined(DUMP_P25) openFile(); writeFile(buffer + 2U, buffer - 2U); #endif if (m_duplex) { buffer[0U] = TAG_HEADER; buffer[1U] = 0x00U; writeQueueRF(buffer, P25_HDR_FRAME_LENGTH_BYTES + 2U); } }
bool CYSFControl::writeModem(unsigned char *data, unsigned int len) { assert(data != NULL); unsigned char type = data[0U]; if (type == TAG_LOST && m_rfState == RS_RF_AUDIO) { LogMessage("YSF, transmission lost, %.1f seconds, BER: %.1f%%", float(m_rfFrames) / 10.0F, float(m_rfErrs * 100U) / float(m_rfBits)); writeEndRF(); return false; } if (type == TAG_LOST) return false; CYSFFICH fich; bool valid = fich.decode(data + 2U); if (valid && m_rfState == RS_RF_LISTENING) { unsigned char fi = fich.getFI(); if (fi == YSF_FI_TERMINATOR) return false; m_rfFrames = 0U; m_rfErrs = 0U; m_rfBits = 1U; m_rfTimeoutTimer.start(); m_rfPayload.reset(); m_rfState = RS_RF_AUDIO; #if defined(DUMP_YSF) openFile(); #endif } if (m_rfState != RS_RF_AUDIO) return false; if (valid) m_lastMR = fich.getMR(); // Stop repeater packets coming through, unless we're acting as a remote gateway if (m_remoteGateway) { if (m_lastMR != YSF_MR_BUSY) return false; } else { if (m_lastMR == YSF_MR_BUSY) return false; } unsigned char fi = fich.getFI(); if (valid && fi == YSF_FI_HEADER) { CSync::addYSFSync(data + 2U); // LogDebug("YSF, FICH: FI: %u, DT: %u, FN: %u, FT: %u", fich.getFI(), fich.getDT(), fich.getFN(), fich.getFT()); valid = m_rfPayload.processHeaderData(data + 2U); if (valid) m_rfSource = m_rfPayload.getSource(); unsigned char cm = fich.getCM(); if (cm == YSF_CM_GROUP) { m_rfDest = (unsigned char*)"ALL "; } else { if (valid) m_rfDest = m_rfPayload.getDest(); } if (m_rfSource != NULL && m_rfDest != NULL) { m_display->writeFusion((char*)m_rfSource, (char*)m_rfDest, "R", " "); LogMessage("YSF, received RF header from %10.10s to %10.10s", m_rfSource, m_rfDest); } else if (m_rfSource == NULL && m_rfDest != NULL) { m_display->writeFusion("??????????", (char*)m_rfDest, "R", " "); LogMessage("YSF, received RF header from ?????????? to %10.10s", m_rfDest); } else if (m_rfSource != NULL && m_rfDest == NULL) { m_display->writeFusion((char*)m_rfSource, "??????????", "R", " "); LogMessage("YSF, received RF header from %10.10s to ??????????", m_rfSource); } else { m_display->writeFusion("??????????", "??????????", "R", " "); LogMessage("YSF, received RF header from ?????????? to ??????????"); } data[0U] = TAG_DATA; data[1U] = 0x00U; writeNetwork(data, m_rfFrames % 128U); #if defined(DUMP_YSF) 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++; } else if (valid && fi == YSF_FI_TERMINATOR) { CSync::addYSFSync(data + 2U); // LogDebug("YSF, FICH: FI: %u, DT: %u, FN: %u, FT: %u", fich.getFI(), fich.getDT(), fich.getFN(), fich.getFT()); m_rfPayload.processHeaderData(data + 2U); data[0U] = TAG_EOT; data[1U] = 0x00U; writeNetwork(data, m_rfFrames % 128U); #if defined(DUMP_YSF) 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++; LogMessage("YSF, received RF end of transmission, %.1f seconds, BER: %.1f%%", float(m_rfFrames) / 10.0F, float(m_rfErrs * 100U) / float(m_rfBits)); writeEndRF(); return false; } else if (valid) { CSync::addYSFSync(data + 2U); unsigned char bn = fich.getBN(); unsigned char bt = fich.getBT(); unsigned char fn = fich.getFN(); unsigned char ft = fich.getFT(); unsigned char dt = fich.getDT(); // LogDebug("YSF, FICH: FI: %u, DT: %u, FN: %u, FT: %u", fich.getFI(), fich.getDT(), fich.getFN(), fich.getFT()); switch (dt) { case YSF_DT_VD_MODE1: { valid = m_rfPayload.processVDMode1Data(data + 2U, fn); unsigned int errors = m_rfPayload.processVDMode1Audio(data + 2U); m_rfErrs += errors; m_rfBits += 235U; LogDebug("YSF, V/D Mode 1, seq %u, AMBE FEC %u/235 (%.1f%%)", m_rfFrames % 128, errors, float(errors) / 2.35F); } break; case YSF_DT_VD_MODE2: { valid = m_rfPayload.processVDMode2Data(data + 2U, fn); unsigned int errors = m_rfPayload.processVDMode2Audio(data + 2U); m_rfErrs += errors; m_rfBits += 135U; LogDebug("YSF, V/D Mode 2, seq %u, Repetition FEC %u/135 (%.1f%%)", m_rfFrames % 128, errors, float(errors) / 1.35F); } break; case YSF_DT_DATA_FR_MODE: LogDebug("YSF, RF data FICH B=%u/%u F=%u/%u", bn, bt, fn, ft); valid = m_rfPayload.processDataFRModeData(data + 2U, fn); 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_rfPayload.processVoiceFRModeAudio(data + 2U); m_rfErrs += errors; m_rfBits += 720U; LogDebug("YSF, V Mode 3, seq %u, AMBE FEC %u/720 (%.1f%%)", m_rfFrames % 128, errors, float(errors) / 7.2F); } valid = false; break; default: break; } bool change = false; if (m_rfDest == NULL) { unsigned char cm = fich.getCM(); if (cm == YSF_CM_GROUP) { m_rfDest = (unsigned char*)"ALL "; change = true; } else if (valid) { m_rfDest = m_rfPayload.getDest(); if (m_rfDest != NULL) change = true; } } if (valid && m_rfSource == NULL) { m_rfSource = m_rfPayload.getSource(); if (m_rfSource != NULL) change = true; } if (change) { if (m_rfSource != NULL && m_rfDest != NULL) { m_display->writeFusion((char*)m_rfSource, (char*)m_rfDest, "R", " "); LogMessage("YSF, received RF data from %10.10s to %10.10s", m_rfSource, m_rfDest); } if (m_rfSource != NULL && m_rfDest == NULL) { m_display->writeFusion((char*)m_rfSource, "??????????", "R", " "); LogMessage("YSF, received RF data from %10.10s to ??????????", m_rfSource); } if (m_rfSource == NULL && m_rfDest != NULL) { m_display->writeFusion("??????????", (char*)m_rfDest, "R", " "); LogMessage("YSF, received RF data from ?????????? to %10.10s", m_rfDest); } } data[0U] = TAG_DATA; data[1U] = 0x00U; writeNetwork(data, m_rfFrames % 128U); if (m_duplex) { fich.setMR(m_remoteGateway ? YSF_MR_NOT_BUSY : YSF_MR_BUSY); fich.encode(data + 2U); writeQueueRF(data); } #if defined(DUMP_YSF) writeFile(data + 2U); #endif m_rfFrames++; } else { CSync::addYSFSync(data + 2U); data[0U] = TAG_DATA; data[1U] = 0x00U; writeNetwork(data, m_rfFrames % 128U); if (m_duplex) writeQueueRF(data); #if defined(DUMP_YSF) writeFile(data + 2U); #endif m_rfFrames++; } return true; }
bool CYSFControl::writeModem(unsigned char *data) { assert(data != NULL); unsigned char type = data[0U]; if (type == TAG_LOST && m_rfState == RS_RF_AUDIO) { LogMessage("YSF, transmission lost, %.1f seconds, BER: %.1f%%", float(m_rfFrames) / 10.0F, float(m_rfErrs * 100U) / float(m_rfBits)); writeEndRF(); return false; } if (type == TAG_LOST) return false; CYSFFICH fich; bool valid = fich.decode(data + 2U); if (valid && m_rfState == RS_RF_LISTENING) { unsigned char fi = fich.getFI(); if (fi == YSF_FI_TERMINATOR) return false; m_holdoffTimer.stop(); m_rfFrames = 0U; m_rfErrs = 0U; m_rfBits = 1U; m_rfTimeoutTimer.start(); m_rfPayload.reset(); m_rfState = RS_RF_AUDIO; #if defined(DUMP_YSF) openFile(); #endif } if (m_rfState != RS_RF_AUDIO) return false; unsigned char fi = fich.getFI(); if (valid && fi == YSF_FI_HEADER) { CSync::addYSFSync(data + 2U); // LogDebug("YSF, FICH: FI: %u, DT: %u, FN: %u, FT: %u", fich.getFI(), fich.getDT(), fich.getFN(), fich.getFT()); m_rfFrames++; valid = m_rfPayload.processHeaderData(data + 2U); if (valid) m_rfSource = m_rfPayload.getSource(); unsigned char cm = fich.getCM(); if (cm == YSF_CM_GROUP) { m_rfDest = (unsigned char*)"ALL "; } else { if (valid) m_rfDest = m_rfPayload.getDest(); } if (m_rfSource != NULL && m_rfDest != NULL) { m_display->writeFusion((char*)m_rfSource, (char*)m_rfDest, "R", " "); LogMessage("YSF, received RF header from %10.10s to %10.10s", m_rfSource, m_rfDest); } else if (m_rfSource == NULL && m_rfDest != NULL) { m_display->writeFusion("??????????", (char*)m_rfDest, "R", " "); LogMessage("YSF, received RF header from ?????????? to %10.10s", m_rfDest); } else if (m_rfSource != NULL && m_rfDest == NULL) { m_display->writeFusion((char*)m_rfSource, "??????????", "R", " "); LogMessage("YSF, received RF header from %10.10s to ??????????", m_rfSource); } else { m_display->writeFusion("??????????", "??????????", "R", " "); LogMessage("YSF, received RF header from ?????????? to ??????????"); } data[0U] = TAG_DATA; data[1U] = 0x00U; writeNetwork(data); #if defined(DUMP_YSF) writeFile(data + 2U); #endif if (m_duplex) { fich.setMR(YSF_MR_BUSY); fich.encode(data + 2U); writeQueueRF(data); } } else if (valid && fi == YSF_FI_TERMINATOR) { CSync::addYSFSync(data + 2U); // LogDebug("YSF, FICH: FI: %u, DT: %u, FN: %u, FT: %u", fich.getFI(), fich.getDT(), fich.getFN(), fich.getFT()); m_rfFrames++; m_rfPayload.processHeaderData(data + 2U); data[0U] = TAG_EOT; data[1U] = 0x00U; writeNetwork(data); #if defined(DUMP_YSF) writeFile(data + 2U); #endif if (m_duplex) { fich.setMR(YSF_MR_BUSY); fich.encode(data + 2U); writeQueueRF(data); } LogMessage("YSF, received RF end of transmission, %.1f seconds, BER: %.1f%%", float(m_rfFrames) / 10.0F, float(m_rfErrs * 100U) / float(m_rfBits)); writeEndRF(); return false; } else if (valid) { CSync::addYSFSync(data + 2U); unsigned char fn = fich.getFN(); unsigned char ft = fich.getFT(); unsigned char dt = fich.getDT(); // LogDebug("YSF, FICH: FI: %u, DT: %u, FN: %u, FT: %u", fich.getFI(), fich.getDT(), fich.getFN(), fich.getFT()); m_rfFrames++; switch (dt) { case YSF_DT_VD_MODE1: valid = m_rfPayload.processVDMode1Data(data + 2U, fn); m_rfErrs += m_rfPayload.processVDMode1Audio(data + 2U); m_rfBits += 235U; break; case YSF_DT_VD_MODE2: valid = m_rfPayload.processVDMode2Data(data + 2U, fn); m_rfErrs += m_rfPayload.processVDMode2Audio(data + 2U); m_rfBits += 135U; break; case YSF_DT_DATA_FR_MODE: valid = m_rfPayload.processDataFRModeData(data + 2U, fn); 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 m_rfErrs += m_rfPayload.processVoiceFRModeAudio(data + 2U); m_rfBits += 720U; } valid = false; break; default: break; } bool change = false; if (m_rfDest == NULL) { unsigned char cm = fich.getCM(); if (cm == YSF_CM_GROUP) { m_rfDest = (unsigned char*)"ALL "; change = true; } else if (valid) { m_rfDest = m_rfPayload.getDest(); if (m_rfDest != NULL) change = true; } } if (valid && m_rfSource == NULL) { m_rfSource = m_rfPayload.getSource(); if (m_rfSource != NULL) change = true; } if (change) { if (m_rfSource != NULL && m_rfDest != NULL) { m_display->writeFusion((char*)m_rfSource, (char*)m_rfDest, "R", " "); LogMessage("YSF, received RF data from %10.10s to %10.10s", m_rfSource, m_rfDest); } if (m_rfSource != NULL && m_rfDest == NULL) { m_display->writeFusion((char*)m_rfSource, "??????????", "R", " "); LogMessage("YSF, received RF data from %10.10s to ??????????", m_rfSource); } if (m_rfSource == NULL && m_rfDest != NULL) { m_display->writeFusion("??????????", (char*)m_rfDest, "R", " "); LogMessage("YSF, received RF data from ?????????? to %10.10s", m_rfDest); } } data[0U] = TAG_DATA; data[1U] = 0x00U; writeNetwork(data); if (m_duplex) { fich.setMR(YSF_MR_BUSY); fich.encode(data + 2U); writeQueueRF(data); } #if defined(DUMP_YSF) writeFile(data + 2U); #endif } else { CSync::addYSFSync(data + 2U); m_rfFrames++; data[0U] = TAG_DATA; data[1U] = 0x00U; writeNetwork(data); if (m_duplex) writeQueueRF(data); #if defined(DUMP_YSF) writeFile(data + 2U); #endif } return true; }
bool CP25Control::writeModem(unsigned char* data, unsigned int len) { assert(data != NULL); bool sync = data[1U] == 0x01U; if (data[0U] == TAG_LOST && m_rfState == RS_RF_AUDIO) { if (m_rssi != 0U) LogMessage("P25, transmission lost, %.1f seconds, BER: %.1f%%, RSSI: -%u/-%u/-%u dBm", float(m_rfFrames) / 5.56F, float(m_rfErrs * 100U) / float(m_rfBits), m_minRSSI, m_maxRSSI, m_aveRSSI / m_rssiCount); else LogMessage("P25, transmission lost, %.1f seconds, BER: %.1f%%", float(m_rfFrames) / 5.56F, float(m_rfErrs * 100U) / float(m_rfBits)); if (m_netState == RS_NET_IDLE) m_display->clearP25(); writeNetwork(m_rfLDU, m_lastDUID, true); writeNetwork(data + 2U, P25_DUID_TERM, true); m_rfState = RS_RF_LISTENING; m_rfTimeout.stop(); m_rfData.reset(); #if defined(DUMP_P25) closeFile(); #endif return false; } if (data[0U] == TAG_LOST && m_rfState == RS_RF_DATA) { if (m_netState == RS_NET_IDLE) m_display->clearP25(); m_rfState = RS_RF_LISTENING; m_rfPDUCount = 0U; m_rfPDUBits = 0U; #if defined(DUMP_P25) closeFile(); #endif return false; } if (data[0U] == TAG_LOST) { m_rfState = RS_RF_LISTENING; return false; } if (!sync && m_rfState == RS_RF_LISTENING) return false; // Decode the NID bool valid = m_nid.decode(data + 2U); if (m_rfState == RS_RF_LISTENING && !valid) return false; unsigned char duid = m_nid.getDUID(); if (!valid) { switch (m_lastDUID) { case P25_DUID_HEADER: case P25_DUID_LDU2: duid = P25_DUID_LDU1; break; case P25_DUID_LDU1: duid = P25_DUID_LDU2; break; case P25_DUID_PDU: duid = P25_DUID_PDU; break; case P25_DUID_TSDU: duid = P25_DUID_TSDU; break; default: break; } } // Have we got RSSI bytes on the end of a P25 LDU? if (len == (P25_LDU_FRAME_LENGTH_BYTES + 4U)) { uint16_t raw = 0U; raw |= (data[218U] << 8) & 0xFF00U; raw |= (data[219U] << 0) & 0x00FFU; // Convert the raw RSSI to dBm int rssi = m_rssiMapper->interpolate(raw); if (rssi != 0) LogDebug("P25, 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++; } if (duid == P25_DUID_LDU1) { if (m_rfState == RS_RF_LISTENING) { m_rfData.reset(); bool ret = m_rfData.decodeLDU1(data + 2U); if (!ret) { m_lastDUID = duid; return false; } unsigned int srcId = m_rfData.getSrcId(); if (m_selfOnly) { if (m_id > 99999999U) { // Check that the Config DMR-ID is bigger than 8 digits if (srcId != m_id / 100U) return false; } else if (m_id > 9999999U) { // Check that the Config DMR-ID is bigger than 7 digits if (srcId != m_id / 10U) return false; } else if (srcId != m_id) { // All other cases return false; } } if (!m_uidOverride) { bool found = m_lookup->exists(srcId); if (!found) return false; } bool grp = m_rfData.getLCF() == P25_LCF_GROUP; unsigned int dstId = m_rfData.getDstId(); std::string source = m_lookup->find(srcId); LogMessage("P25, received RF voice transmission from %s to %s%u", source.c_str(), grp ? "TG " : "", dstId); m_display->writeP25(source.c_str(), grp, dstId, "R"); m_rfState = RS_RF_AUDIO; m_minRSSI = m_rssi; m_maxRSSI = m_rssi; m_aveRSSI = m_rssi; m_rssiCount = 1U; createRFHeader(); writeNetwork(data + 2U, P25_DUID_HEADER, false); } else if (m_rfState == RS_RF_AUDIO) { writeNetwork(m_rfLDU, m_lastDUID, false); } if (m_rfState == RS_RF_AUDIO) { // Regenerate Sync CSync::addP25Sync(data + 2U); // Regenerate NID m_nid.encode(data + 2U, P25_DUID_LDU1); // Regenerate LDU1 Data m_rfData.encodeLDU1(data + 2U); // Regenerate the Low Speed Data m_rfLSD.process(data + 2U); // Regenerate Audio unsigned int errors = m_audio.process(data + 2U); LogDebug("P25, LDU1 audio, errs: %u/1233 (%.1f%%)", errors, float(errors) / 12.33F); m_display->writeP25BER(float(errors) / 12.33F); m_rfBits += 1233U; m_rfErrs += errors; m_rfFrames++; m_lastDUID = duid; // Add busy bits addBusyBits(data + 2U, P25_LDU_FRAME_LENGTH_BITS, false, true); #if defined(DUMP_P25) writeFile(data + 2U, len - 2U); #endif ::memcpy(m_rfLDU, data + 2U, P25_LDU_FRAME_LENGTH_BYTES); if (m_duplex) { data[0U] = TAG_DATA; data[1U] = 0x00U; writeQueueRF(data, P25_LDU_FRAME_LENGTH_BYTES + 2U); } m_display->writeP25RSSI(m_rssi); return true; } } else if (duid == P25_DUID_LDU2) { if (m_rfState == RS_RF_AUDIO) { writeNetwork(m_rfLDU, m_lastDUID, false); // Regenerate Sync CSync::addP25Sync(data + 2U); // Regenerate NID m_nid.encode(data + 2U, P25_DUID_LDU2); // Add the dummy LDU2 data m_rfData.encodeLDU2(data + 2U); // Regenerate the Low Speed Data m_rfLSD.process(data + 2U); // Regenerate Audio unsigned int errors = m_audio.process(data + 2U); LogDebug("P25, LDU2 audio, errs: %u/1233 (%.1f%%)", errors, float(errors) / 12.33F); m_display->writeP25BER(float(errors) / 12.33F); m_rfBits += 1233U; m_rfErrs += errors; m_rfFrames++; m_lastDUID = duid; // Add busy bits addBusyBits(data + 2U, P25_LDU_FRAME_LENGTH_BITS, false, true); #if defined(DUMP_P25) writeFile(data + 2U, len - 2U); #endif ::memcpy(m_rfLDU, data + 2U, P25_LDU_FRAME_LENGTH_BYTES); if (m_duplex) { data[0U] = TAG_DATA; data[1U] = 0x00U; writeQueueRF(data, P25_LDU_FRAME_LENGTH_BYTES + 2U); } m_display->writeP25RSSI(m_rssi); return true; } } else if (duid == P25_DUID_TSDU) { if (m_rfState != RS_RF_DATA) { m_rfPDUCount = 0U; m_rfPDUBits = 0U; m_rfState = RS_RF_DATA; m_rfDataFrames = 0U; } bool ret = m_rfData.decodeTSDU(data + 2U); if (!ret) { m_lastDUID = duid; return false; } unsigned int srcId = m_rfData.getSrcId(); unsigned int dstId = m_rfData.getDstId(); unsigned char data[P25_TSDU_FRAME_LENGTH_BYTES + 2U]; switch (m_rfData.getLCF()) { case P25_LCF_TSBK_CALL_ALERT: LogMessage("P25, received RF TSDU transmission, CALL ALERT from %u to %u", srcId, dstId); ::memset(data + 2U, 0x00U, P25_TSDU_FRAME_LENGTH_BYTES); // Regenerate Sync CSync::addP25Sync(data + 2U); // Regenerate NID m_nid.encode(data + 2U, P25_DUID_TSDU); // Regenerate TDULC Data m_rfData.encodeTSDU(data + 2U); // Add busy bits addBusyBits(data + 2U, P25_TSDU_FRAME_LENGTH_BITS, true, false); // Set first busy bits to 1,1 setBusyBits(data + 2U, P25_SS0_START, true, true); if (m_duplex) { data[0U] = TAG_DATA; data[1U] = 0x00U; writeQueueRF(data, P25_TSDU_FRAME_LENGTH_BYTES + 2U); } break; case P25_LCF_TSBK_ACK_RSP_FNE: LogMessage("P25, received RF TSDU transmission, ACK RESPONSE FNE from %u to %u", srcId, dstId); ::memset(data + 2U, 0x00U, P25_TSDU_FRAME_LENGTH_BYTES); // Regenerate Sync CSync::addP25Sync(data + 2U); // Regenerate NID m_nid.encode(data + 2U, P25_DUID_TSDU); // Regenerate TDULC Data m_rfData.encodeTSDU(data + 2U); // Add busy bits addBusyBits(data + 2U, P25_TSDU_FRAME_LENGTH_BITS, true, false); // Set first busy bits to 1,1 setBusyBits(data + 2U, P25_SS0_START, true, true); if (m_duplex) { data[0U] = TAG_DATA; data[1U] = 0x00U; writeQueueRF(data, P25_TSDU_FRAME_LENGTH_BYTES + 2U); } break; default: LogMessage("P25, recieved RF TSDU transmission, unhandled LCF $%02X", m_rfData.getLCF()); break; } m_rfState = RS_RF_LISTENING; return true; } else if (duid == P25_DUID_TERM || duid == P25_DUID_TERM_LC) { if (m_rfState == RS_RF_AUDIO) { writeNetwork(m_rfLDU, m_lastDUID, true); ::memset(data + 2U, 0x00U, P25_TERM_FRAME_LENGTH_BYTES); // Regenerate Sync CSync::addP25Sync(data + 2U); // Regenerate NID m_nid.encode(data + 2U, P25_DUID_TERM); // Add busy bits addBusyBits(data + 2U, P25_TERM_FRAME_LENGTH_BITS, false, true); m_rfState = RS_RF_LISTENING; m_rfTimeout.stop(); m_rfData.reset(); m_lastDUID = duid; if (m_rssi != 0U) LogMessage("P25, received RF end of voice transmission, %.1f seconds, BER: %.1f%%, RSSI: -%u/-%u/-%u dBm", float(m_rfFrames) / 5.56F, float(m_rfErrs * 100U) / float(m_rfBits), m_minRSSI, m_maxRSSI, m_aveRSSI / m_rssiCount); else LogMessage("P25, received RF end of voice transmission, %.1f seconds, BER: %.1f%%", float(m_rfFrames) / 5.56F, float(m_rfErrs * 100U) / float(m_rfBits)); m_display->clearP25(); #if defined(DUMP_P25) closeFile(); #endif writeNetwork(data + 2U, P25_DUID_TERM, true); if (m_duplex) { data[0U] = TAG_EOT; data[1U] = 0x00U; writeQueueRF(data, P25_TERM_FRAME_LENGTH_BYTES + 2U); } } } else if (duid == P25_DUID_PDU) { if (m_rfState != RS_RF_DATA) { m_rfPDUCount = 0U; m_rfPDUBits = 0U; m_rfState = RS_RF_DATA; m_rfDataFrames = 0U; } unsigned int start = m_rfPDUCount * P25_LDU_FRAME_LENGTH_BITS; unsigned char buffer[P25_LDU_FRAME_LENGTH_BYTES]; unsigned int bits = CP25Utils::decode(data + 2U, buffer, start, start + P25_LDU_FRAME_LENGTH_BITS); for (unsigned int i = 0U; i < bits; i++, m_rfPDUBits++) { bool b = READ_BIT(buffer, i); WRITE_BIT(m_rfPDU, m_rfPDUBits, b); } if (m_rfPDUCount == 0U) { CP25Trellis trellis; unsigned char header[P25_PDU_HEADER_LENGTH_BYTES]; bool valid = trellis.decode12(m_rfPDU + P25_SYNC_LENGTH_BYTES + P25_NID_LENGTH_BYTES, header); if (valid) valid = CCRC::checkCCITT162(header, P25_PDU_HEADER_LENGTH_BYTES); if (valid) { unsigned int llId = (header[3U] << 16) + (header[4U] << 8) + header[5U]; unsigned int sap = header[1U] & 0x3FU; m_rfDataFrames = header[6U] & 0x7FU; LogMessage("P25, received RF data transmission for Local Link Id %u, SAP %u, %u blocks", llId, sap, m_rfDataFrames); } else { m_rfPDUCount = 0U; m_rfPDUBits = 0U; m_rfState = RS_RF_LISTENING; m_rfDataFrames = 0U; } } if (m_rfState == RS_RF_DATA) { m_rfPDUCount++; unsigned int bitLength = ((m_rfDataFrames + 1U) * P25_PDU_FEC_LENGTH_BITS) + P25_SYNC_LENGTH_BITS + P25_NID_LENGTH_BITS; if (m_rfPDUBits >= bitLength) { unsigned int offset = P25_SYNC_LENGTH_BYTES + P25_NID_LENGTH_BYTES; // Regenerate the PDU header CP25Trellis trellis; unsigned char header[P25_PDU_HEADER_LENGTH_BYTES]; trellis.decode12(m_rfPDU + offset, header); trellis.encode12(header, m_rfPDU + offset); offset += P25_PDU_FEC_LENGTH_BITS; // Regenerate the PDU data for (unsigned int i = 0U; i < m_rfDataFrames; i++) { unsigned char data[P25_PDU_CONFIRMED_LENGTH_BYTES]; bool valid = trellis.decode34(m_rfPDU + offset, data); if (valid) { trellis.encode34(data, m_rfPDU + offset); } else { valid = trellis.decode12(m_rfPDU + offset, data); if (valid) trellis.encode12(data, m_rfPDU + offset); } offset += P25_PDU_FEC_LENGTH_BITS; } unsigned char pdu[1024U]; // Add the data unsigned int newBitLength = CP25Utils::encode(m_rfPDU, pdu + 2U, bitLength); unsigned int newByteLength = newBitLength / 8U; if ((newBitLength % 8U) > 0U) newByteLength++; // Regenerate Sync CSync::addP25Sync(pdu + 2U); // Regenerate NID m_nid.encode(pdu + 2U, P25_DUID_PDU); // Add busy bits addBusyBits(pdu + 2U, newBitLength, false, true); if (m_duplex) { pdu[0U] = TAG_DATA; pdu[1U] = 0x00U; writeQueueRF(pdu, newByteLength + 2U); } LogMessage("P25, ended RF data transmission"); m_display->clearP25(); m_rfPDUCount = 0U; m_rfPDUBits = 0U; m_rfState = RS_RF_LISTENING; m_rfDataFrames = 0U; } return true; } } return false; }