expand on and better handle frame sequencing from a V.24 source;

pull/126/head
Bryan Biedenkapp 4 months ago
parent d05088da57
commit 9508ce9404

@ -690,94 +690,92 @@ void ModemV24::create_TDU(uint8_t* buffer)
DUID::E ModemV24::updateLDUSequence(DFSIFrameType::E frameType)
{
// determine the LDU1 N
uint8_t n = 0U;
// helper lambda to advance the LDU sequence and determine if a complete LDU has been received
auto advanceLDU = [this](uint8_t n, uint8_t& state, uint16_t& mask, DUID::E duidType) -> DUID::E {
const std::string lduName = (duidType == DUID::LDU1) ? "LDU1" : "LDU2";
const uint16_t blockBit = (uint16_t)(1U << (n - 1U));
const uint16_t fullMask = 0x01FFU;
if ((mask & blockBit) != 0U) {
if (m_debug) {
LogDebugEx(LOG_MODEM, "ModemV24::updateLDUSequence()", "%s duplicate frame received, n = %u, mask = $%03X", lduName.c_str(), n, mask);
}
return (DUID::E)0xFFU;
}
// track highest observed block index for diagnostics only
if (n > state) {
state = n;
}
// out-of-sequence arrivals are retained by setting their bit in the mask
if (n != 1U && ((mask & (uint16_t)(blockBit >> 1U)) == 0U) && m_debug) {
LogDebugEx(LOG_MODEM, "ModemV24::updateLDUSequence()", "%s out-of-sequence frame held, n = %u, mask(before) = $%03X", lduName.c_str(), n, mask);
}
mask |= blockBit;
if (mask != fullMask) {
if (m_debug) {
const uint16_t missingMask = (uint16_t)(fullMask & ~mask);
LogDebugEx(LOG_MODEM, "ModemV24::updateLDUSequence()", "%s awaiting missing frames, mask = $%03X, missing = $%03X", lduName.c_str(), mask, missingMask);
}
return (DUID::E)0xFFU;
}
if (m_debug) {
LogDebugEx(LOG_MODEM, "ModemV24::updateLDUSequence()", "%s complete frame set received, mask = $%03X", lduName.c_str(), mask);
}
state = 0U;
mask = 0U;
return duidType;
};
// advance LDU sequence
switch (frameType) {
case DFSIFrameType::LDU1_VOICE1:
n = 1U;
break;
return advanceLDU(1U, m_rxCall->ldu1N, m_rxCall->ldu1Mask, DUID::LDU1);
case DFSIFrameType::LDU1_VOICE2:
n = 2U;
break;
return advanceLDU(2U, m_rxCall->ldu1N, m_rxCall->ldu1Mask, DUID::LDU1);
case DFSIFrameType::LDU1_VOICE3:
n = 3U;
break;
return advanceLDU(3U, m_rxCall->ldu1N, m_rxCall->ldu1Mask, DUID::LDU1);
case DFSIFrameType::LDU1_VOICE4:
n = 4U;
break;
return advanceLDU(4U, m_rxCall->ldu1N, m_rxCall->ldu1Mask, DUID::LDU1);
case DFSIFrameType::LDU1_VOICE5:
n = 5U;
break;
return advanceLDU(5U, m_rxCall->ldu1N, m_rxCall->ldu1Mask, DUID::LDU1);
case DFSIFrameType::LDU1_VOICE6:
n = 6U;
break;
return advanceLDU(6U, m_rxCall->ldu1N, m_rxCall->ldu1Mask, DUID::LDU1);
case DFSIFrameType::LDU1_VOICE7:
n = 7U;
break;
return advanceLDU(7U, m_rxCall->ldu1N, m_rxCall->ldu1Mask, DUID::LDU1);
case DFSIFrameType::LDU1_VOICE8:
n = 8U;
break;
return advanceLDU(8U, m_rxCall->ldu1N, m_rxCall->ldu1Mask, DUID::LDU1);
case DFSIFrameType::LDU1_VOICE9:
n = 9U;
break;
default:
break;
}
// advance LDU1 sequence if applicable
if (n != 0U) {
if (n == 1U || n > m_rxCall->ldu1N) {
m_rxCall->ldu1N = n;
return (n == 9U) ? DUID::LDU1 : (DUID::E)0xFFU;
}
return advanceLDU(9U, m_rxCall->ldu1N, m_rxCall->ldu1Mask, DUID::LDU1);
return (DUID::E)0xFFU;
}
// determine the LDU2 N
n = 0U;
switch (frameType) {
case DFSIFrameType::LDU2_VOICE10:
n = 1U;
break;
return advanceLDU(1U, m_rxCall->ldu2N, m_rxCall->ldu2Mask, DUID::LDU2);
case DFSIFrameType::LDU2_VOICE11:
n = 2U;
break;
return advanceLDU(2U, m_rxCall->ldu2N, m_rxCall->ldu2Mask, DUID::LDU2);
case DFSIFrameType::LDU2_VOICE12:
n = 3U;
break;
return advanceLDU(3U, m_rxCall->ldu2N, m_rxCall->ldu2Mask, DUID::LDU2);
case DFSIFrameType::LDU2_VOICE13:
n = 4U;
break;
return advanceLDU(4U, m_rxCall->ldu2N, m_rxCall->ldu2Mask, DUID::LDU2);
case DFSIFrameType::LDU2_VOICE14:
n = 5U;
break;
return advanceLDU(5U, m_rxCall->ldu2N, m_rxCall->ldu2Mask, DUID::LDU2);
case DFSIFrameType::LDU2_VOICE15:
n = 6U;
break;
return advanceLDU(6U, m_rxCall->ldu2N, m_rxCall->ldu2Mask, DUID::LDU2);
case DFSIFrameType::LDU2_VOICE16:
n = 7U;
break;
return advanceLDU(7U, m_rxCall->ldu2N, m_rxCall->ldu2Mask, DUID::LDU2);
case DFSIFrameType::LDU2_VOICE17:
n = 8U;
break;
return advanceLDU(8U, m_rxCall->ldu2N, m_rxCall->ldu2Mask, DUID::LDU2);
case DFSIFrameType::LDU2_VOICE18:
n = 9U;
break;
return advanceLDU(9U, m_rxCall->ldu2N, m_rxCall->ldu2Mask, DUID::LDU2);
default:
break;
}
// advance LDU2 sequence if applicable
if (n != 0U) {
if (n == 1U || n > m_rxCall->ldu2N) {
m_rxCall->ldu2N = n;
return (n == 9U) ? DUID::LDU2 : (DUID::E)0xFFU;
}
return (DUID::E)0xFFU;
}
return (DUID::E)0xFFU;
}
@ -952,6 +950,7 @@ void ModemV24::convertToAirV24(const uint8_t *data, uint32_t length)
::memset(m_rxCall->LDULC, 0x00U, P25DEF::P25_LDU_LC_FEC_LENGTH_BYTES);
::memcpy(m_rxCall->netLDU1 + 10U, svf.fullRateVoice->imbeData, RAW_IMBE_LENGTH_BYTES);
m_rxCall->resetLDU2State(); // force reset the LDU2 state to prevent LDU2 from being emitted
m_rxCall->errors = 0U;
// process start of stream ICW for the voice call
@ -1004,6 +1003,7 @@ void ModemV24::convertToAirV24(const uint8_t *data, uint32_t length)
::memset(m_rxCall->LDULC, 0x00U, P25DEF::P25_LDU_LC_FEC_LENGTH_BYTES);
::memcpy(m_rxCall->netLDU2 + 10U, svf.fullRateVoice->imbeData, RAW_IMBE_LENGTH_BYTES);
m_rxCall->resetLDU1State(); // force reset the LDU1 state to prevent LDU1 from being emitted
m_rxCall->errors = 0U;
// process start of stream ICW for the voice call
@ -1690,8 +1690,6 @@ void ModemV24::convertToAirV24(const uint8_t *data, uint32_t length)
m_rxCall->errors = 0U;
}
m_rxCall->ldu1N = 0U;
lc::LC lc = lc::LC();
lc.setLCO(m_rxCall->lco);
lc.setMFId(m_rxCall->mfId);
@ -1767,6 +1765,8 @@ void ModemV24::convertToAirV24(const uint8_t *data, uint32_t length)
buffer[0U] = modem::TAG_DATA;
buffer[1U] = 0x01U;
storeConvertedRx(buffer, P25_LDU_FRAME_LENGTH_BYTES + 2U);
m_rxCall->resetLDU1State();
}
// encode LDU2 if ready
@ -1789,8 +1789,6 @@ void ModemV24::convertToAirV24(const uint8_t *data, uint32_t length)
m_rxCall->errors = 0U;
}
m_rxCall->ldu2N = 0U;
lc::LC lc = lc::LC();
lc.setMI(m_rxCall->MI);
lc.setAlgId(m_rxCall->algoId);
@ -1829,6 +1827,8 @@ void ModemV24::convertToAirV24(const uint8_t *data, uint32_t length)
buffer[0U] = modem::TAG_DATA;
buffer[1U] = 0x01U;
storeConvertedRx(buffer, P25_LDU_FRAME_LENGTH_BYTES + 2U);
m_rxCall->resetLDU2State();
}
}
}
@ -2052,6 +2052,7 @@ void ModemV24::convertToAirTIA(const uint8_t *data, uint32_t length)
switch (frameType) {
case DFSIFrameType::LDU1_VOICE1:
{
m_rxCall->resetLDU2State(); // force reset the LDU2 state to prevent LDU2 from being emitted
::memset(m_rxCall->LDULC, 0x00U, P25DEF::P25_LDU_LC_FEC_LENGTH_BYTES);
::memcpy(m_rxCall->netLDU1 + 10U, voice.imbeData, RAW_IMBE_LENGTH_BYTES);
}
@ -2161,6 +2162,7 @@ void ModemV24::convertToAirTIA(const uint8_t *data, uint32_t length)
case DFSIFrameType::LDU2_VOICE10:
{
m_rxCall->resetLDU1State(); // force reset the LDU1 state to prevent LDU1 from being emitted
::memset(m_rxCall->LDULC, 0x00U, P25DEF::P25_LDU_LC_FEC_LENGTH_BYTES);
::memcpy(m_rxCall->netLDU2 + 10U, voice.imbeData, RAW_IMBE_LENGTH_BYTES);
}
@ -2295,8 +2297,6 @@ void ModemV24::convertToAirTIA(const uint8_t *data, uint32_t length)
m_rxCall->errors = 0U;
}
m_rxCall->ldu1N = 0U;
lc::LC lc = lc::LC();
lc.setLCO(m_rxCall->lco);
lc.setMFId(m_rxCall->mfId);
@ -2372,6 +2372,8 @@ void ModemV24::convertToAirTIA(const uint8_t *data, uint32_t length)
buffer[0U] = modem::TAG_DATA;
buffer[1U] = 0x01U;
storeConvertedRx(buffer, P25_LDU_FRAME_LENGTH_BYTES + 2U);
m_rxCall->resetLDU1State();
}
// encode LDU2 if ready
@ -2434,6 +2436,8 @@ void ModemV24::convertToAirTIA(const uint8_t *data, uint32_t length)
buffer[0U] = modem::TAG_DATA;
buffer[1U] = 0x01U;
storeConvertedRx(buffer, P25_LDU_FRAME_LENGTH_BYTES + 2U);
m_rxCall->resetLDU2State();
}
}
break;

@ -84,6 +84,8 @@ namespace modem
seqNo(0U),
ldu1N(0U),
ldu2N(0U),
ldu1Mask(0U),
ldu2Mask(0U),
netLDU1(nullptr),
netLDU2(nullptr),
pduUserData(nullptr),
@ -183,6 +185,8 @@ namespace modem
ldu1N = 0U;
ldu2N = 0U;
ldu1Mask = 0U;
ldu2Mask = 0U;
seqNo = 0U;
if (pduUserData != nullptr)
@ -197,6 +201,27 @@ namespace modem
errors = 0U;
}
/**
* @brief Resets the state of the LDU1 sequence, including its buffer, block count, and bitmask.
*/
void resetLDU1State()
{
if (netLDU1 != nullptr)
::memset(netLDU1, 0x00U, 9U * 25U);
ldu1N = 0U;
ldu1Mask = 0U;
}
/**
* @brief Resets the state of the LDU2 sequence, including its buffer, block count, and bitmask.
*/
void resetLDU2State()
{
if (netLDU2 != nullptr)
::memset(netLDU2, 0x00U, 9U * 25U);
ldu2N = 0U;
ldu2Mask = 0U;
}
public:
/** @name Call Data */
/**
@ -269,6 +294,14 @@ namespace modem
* @brief Number of LDU2 blocks.
*/
uint8_t ldu2N;
/**
* @brief Bitmask of received LDU1 voice blocks (VOICE1..VOICE9 => bits 0..8).
*/
uint16_t ldu1Mask;
/**
* @brief Bitmask of received LDU2 voice blocks (VOICE10..VOICE18 => bits 0..8).
*/
uint16_t ldu2Mask;
/**
* @brief LDU1 Buffer.

Loading…
Cancel
Save

Powered by TurnKey Linux.