add P25 telephone interconnect TSBKs (TELE_INT_VCH_GRANT, TELE_INT_PSTN_REQ, TELE_INT_ANS) and decode them in TSBKFactory;

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
pull/133/head
majmongoose 1 month ago
parent 536997ac10
commit 6430e78e08

@ -0,0 +1,140 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Digital Voice Modem - Common Library
* GPLv2 Open Source. Use is subject to license terms.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright (C) 2026 Charles Bricker, K3NOP
*
*/
#include "Defines.h"
#include "p25/lc/tsbk/IOSP_TELE_INT_ANS.h"
using namespace p25;
using namespace p25::defines;
using namespace p25::lc;
using namespace p25::lc::tsbk;
#include <cassert>
// ---------------------------------------------------------------------------
// Public Class Members
// ---------------------------------------------------------------------------
/* Initializes a new instance of the IOSP_TELE_INT_ANS class. */
IOSP_TELE_INT_ANS::IOSP_TELE_INT_ANS() : TSBK(),
m_digits()
{
m_lco = TSBKO::IOSP_TELE_INT_ANS;
}
/* Decode a trunking signalling block. */
bool IOSP_TELE_INT_ANS::decode(const uint8_t* data, bool rawTSBK)
{
assert(data != nullptr);
uint8_t tsbk[P25_TSBK_LENGTH_BYTES + 1U];
::memset(tsbk, 0x00U, P25_TSBK_LENGTH_BYTES);
bool ret = TSBK::decode(data, tsbk, rawTSBK);
if (!ret)
return false;
ulong64_t tsbkValue = TSBK::toValue(tsbk);
// the ISP and OSP share an opcode but not a layout, so both are decoded; the trailing
// subscriber unit address is the source (ISP) or target (OSP) and is stored as both
m_emergency = (((tsbkValue >> 56) & 0xFFU) & 0x80U) == 0x80U; // Emergency Flag (ISP)
m_encrypted = (((tsbkValue >> 56) & 0xFFU) & 0x40U) == 0x40U; // Encryption Flag (ISP)
m_priority = (((tsbkValue >> 56) & 0xFFU) & 0x07U); // Priority (ISP)
m_response = (uint8_t)((tsbkValue >> 48) & 0xFFU); // Answer Response (ISP)
// a $F digit escapes the next digit ($0 - $3 = A - D, $F = null filler)
m_digits = "";
for (uint32_t i = 0U; i < MAX_DIGITS; i++) {
uint8_t digit = (uint8_t)((tsbkValue >> (60U - (i * 4U))) & 0x0FU); // Digits 1 - 10 (OSP)
if (digit <= 0x09U) {
m_digits += (char)('0' + digit);
}
else if (digit == 0x0AU) {
m_digits += '*';
}
else if (digit == 0x0BU) {
m_digits += '#';
}
else if (digit == 0x0FU) {
if (i + 1U >= MAX_DIGITS)
break;
uint8_t escaped = (uint8_t)((tsbkValue >> (60U - ((i + 1U) * 4U))) & 0x0FU);
if (escaped > 0x03U)
break;
m_digits += (char)('A' + escaped);
i++;
}
}
m_srcId = (uint32_t)(tsbkValue & 0xFFFFFFU); // Source (ISP) / Target (OSP) Radio Address
m_dstId = m_srcId;
return true;
}
/* Encode a trunking signalling block. */
void IOSP_TELE_INT_ANS::encode(uint8_t* data, bool rawTSBK, bool noTrellis)
{
assert(data != nullptr);
uint8_t digits[MAX_DIGITS];
::memset(digits, 0x0FU, MAX_DIGITS); // Null Filler
uint32_t count = 0U;
for (char c : m_digits) {
if (c >= '0' && c <= '9' && count < MAX_DIGITS) {
digits[count++] = (uint8_t)(c - '0');
}
else if (c == '*' && count < MAX_DIGITS) {
digits[count++] = 0x0AU;
}
else if (c == '#' && count < MAX_DIGITS) {
digits[count++] = 0x0BU;
}
else if (c >= 'A' && c <= 'D' && count + 1U < MAX_DIGITS) {
digits[count++] = 0x0FU;
digits[count++] = (uint8_t)(c - 'A');
}
}
ulong64_t tsbkValue = 0U;
for (uint32_t i = 0U; i < MAX_DIGITS; i++)
tsbkValue = (tsbkValue << 4) + digits[i]; // Digits 1 - 10
tsbkValue = (tsbkValue << 24) + m_dstId; // Target Radio Address
std::unique_ptr<uint8_t[]> tsbk = TSBK::fromValue(tsbkValue);
TSBK::encode(data, tsbk.get(), rawTSBK, noTrellis);
}
/* Returns a string that represents the current TSBK. */
std::string IOSP_TELE_INT_ANS::toString(bool isp)
{
return (isp) ? std::string("TSBKO, IOSP_TELE_INT_ANS (Telephone Interconnect Answer Response)") :
std::string("TSBKO, IOSP_TELE_INT_ANS (Telephone Interconnect Answer Request)");
}
// ---------------------------------------------------------------------------
// Private Class Members
// ---------------------------------------------------------------------------
/* Internal helper to copy the the class. */
void IOSP_TELE_INT_ANS::copy(const IOSP_TELE_INT_ANS& data)
{
TSBK::copy(data);
m_digits = data.m_digits;
}

@ -0,0 +1,82 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Digital Voice Modem - Common Library
* GPLv2 Open Source. Use is subject to license terms.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright (C) 2026 Charles Bricker, K3NOP
*
*/
/**
* @file IOSP_TELE_INT_ANS.h
* @ingroup p25_tsbk
* @file IOSP_TELE_INT_ANS.cpp
* @ingroup p25_tsbk
*/
#if !defined(__P25_LC_TSBK__IOSP_TELE_INT_ANS_H__)
#define __P25_LC_TSBK__IOSP_TELE_INT_ANS_H__
#include "common/Defines.h"
#include "common/p25/lc/TSBK.h"
namespace p25
{
namespace lc
{
namespace tsbk
{
// ---------------------------------------------------------------------------
// Class Declaration
// ---------------------------------------------------------------------------
/**
* @brief Implements TELE INT ANS RSP - Telephone Interconnect Answer Response (ISP) and
* TELE INT ANS REQ - Telephone Interconnect Answer Request (OSP)
* @ingroup p25_tsbk
*/
class DVM_COMMON_API IOSP_TELE_INT_ANS : public TSBK {
public:
/**
* @brief Maximum number of digits carried by the OSP.
*/
static const uint32_t MAX_DIGITS = 10U;
/**
* @brief Initializes a new instance of the IOSP_TELE_INT_ANS class.
*/
IOSP_TELE_INT_ANS();
/**
* @brief Decode a trunking signalling block.
* @param[in] data Buffer containing a TSBK to decode.
* @param rawTSBK Flag indicating whether or not the passed buffer is raw.
* @returns bool True, if TSBK decoded, otherwise false.
*/
bool decode(const uint8_t* data, bool rawTSBK = false) override;
/**
* @brief Encode a trunking signalling block.
* @param[out] data Buffer to encode a TSBK.
* @param rawTSBK Flag indicating whether or not the output buffer is raw.
* @param noTrellis Flag indicating whether or not the encoded data should be Trellis encoded.
*/
void encode(uint8_t* data, bool rawTSBK = false, bool noTrellis = false) override;
/**
* @brief Returns a string that represents the current TSBK.
* @returns std::string String representation of the TSBK.
*/
std::string toString(bool isp = false) override;
public:
/**
* @brief Telephone digits presented to the called unit (OSP only); 0-9, '*', '#' and A-D.
*/
DECLARE_PROPERTY(std::string, digits, Digits);
DECLARE_COPY(IOSP_TELE_INT_ANS);
};
} // namespace tsbk
} // namespace lc
} // namespace p25
#endif // __P25_LC_TSBK__IOSP_TELE_INT_ANS_H__

@ -0,0 +1,93 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Digital Voice Modem - Common Library
* GPLv2 Open Source. Use is subject to license terms.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright (C) 2026 Charles Bricker, K3NOP
*
*/
#include "Defines.h"
#include "p25/lc/tsbk/ISP_TELE_INT_PSTN_REQ.h"
using namespace p25;
using namespace p25::defines;
using namespace p25::lc;
using namespace p25::lc::tsbk;
#include <cassert>
// ---------------------------------------------------------------------------
// Public Class Members
// ---------------------------------------------------------------------------
/* Initializes a new instance of the ISP_TELE_INT_PSTN_REQ class. */
ISP_TELE_INT_PSTN_REQ::ISP_TELE_INT_PSTN_REQ() : TSBK(),
m_pstnAddress(0U)
{
m_lco = TSBKO::ISP_TELE_INT_PSTN_REQ;
}
/* Decode a trunking signalling block. */
bool ISP_TELE_INT_PSTN_REQ::decode(const uint8_t* data, bool rawTSBK)
{
assert(data != nullptr);
uint8_t tsbk[P25_TSBK_LENGTH_BYTES + 1U];
::memset(tsbk, 0x00U, P25_TSBK_LENGTH_BYTES);
bool ret = TSBK::decode(data, tsbk, rawTSBK);
if (!ret)
return false;
ulong64_t tsbkValue = TSBK::toValue(tsbk);
m_emergency = (((tsbkValue >> 56) & 0xFFU) & 0x80U) == 0x80U; // Emergency Flag
m_encrypted = (((tsbkValue >> 56) & 0xFFU) & 0x40U) == 0x40U; // Encryption Flag
m_priority = (((tsbkValue >> 56) & 0xFFU) & 0x07U); // Priority
m_pstnAddress = (uint8_t)((tsbkValue >> 24) & 0xFFU); // PSTN Address
m_srcId = (uint32_t)(tsbkValue & 0xFFFFFFU); // Source Radio Address
return true;
}
/* Encode a trunking signalling block. */
void ISP_TELE_INT_PSTN_REQ::encode(uint8_t* data, bool rawTSBK, bool noTrellis)
{
assert(data != nullptr);
ulong64_t tsbkValue = 0U;
tsbkValue =
(m_emergency ? 0x80U : 0x00U) + // Emergency Flag
(m_encrypted ? 0x40U : 0x00U) + // Encrypted Flag
(m_priority & 0x07U); // Priority
tsbkValue = (tsbkValue << 32) + m_pstnAddress; // Reserved + PSTN Address
tsbkValue = (tsbkValue << 24) + m_srcId; // Source Radio Address
std::unique_ptr<uint8_t[]> tsbk = TSBK::fromValue(tsbkValue);
TSBK::encode(data, tsbk.get(), rawTSBK, noTrellis);
}
/* Returns a string that represents the current TSBK. */
std::string ISP_TELE_INT_PSTN_REQ::toString(bool isp)
{
return std::string("TSBKO, ISP_TELE_INT_PSTN_REQ (Telephone Interconnect Request - Implicit)");
}
// ---------------------------------------------------------------------------
// Private Class Members
// ---------------------------------------------------------------------------
/* Internal helper to copy the the class. */
void ISP_TELE_INT_PSTN_REQ::copy(const ISP_TELE_INT_PSTN_REQ& data)
{
TSBK::copy(data);
m_pstnAddress = data.m_pstnAddress;
}

@ -0,0 +1,76 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Digital Voice Modem - Common Library
* GPLv2 Open Source. Use is subject to license terms.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright (C) 2026 Charles Bricker, K3NOP
*
*/
/**
* @file ISP_TELE_INT_PSTN_REQ.h
* @ingroup p25_tsbk
* @file ISP_TELE_INT_PSTN_REQ.cpp
* @ingroup p25_tsbk
*/
#if !defined(__P25_LC_TSBK__ISP_TELE_INT_PSTN_REQ_H__)
#define __P25_LC_TSBK__ISP_TELE_INT_PSTN_REQ_H__
#include "common/Defines.h"
#include "common/p25/lc/TSBK.h"
namespace p25
{
namespace lc
{
namespace tsbk
{
// ---------------------------------------------------------------------------
// Class Declaration
// ---------------------------------------------------------------------------
/**
* @brief Implements TELE INT PSTN REQ - Telephone Interconnect Request - Implicit Dialing (ISP)
* @ingroup p25_tsbk
*/
class DVM_COMMON_API ISP_TELE_INT_PSTN_REQ : public TSBK {
public:
/**
* @brief Initializes a new instance of the ISP_TELE_INT_PSTN_REQ class.
*/
ISP_TELE_INT_PSTN_REQ();
/**
* @brief Decode a trunking signalling block.
* @param[in] data Buffer containing a TSBK to decode.
* @param rawTSBK Flag indicating whether or not the passed buffer is raw.
* @returns bool True, if TSBK decoded, otherwise false.
*/
bool decode(const uint8_t* data, bool rawTSBK = false) override;
/**
* @brief Encode a trunking signalling block.
* @param[out] data Buffer to encode a TSBK.
* @param rawTSBK Flag indicating whether or not the output buffer is raw.
* @param noTrellis Flag indicating whether or not the encoded data should be Trellis encoded.
*/
void encode(uint8_t* data, bool rawTSBK = false, bool noTrellis = false) override;
/**
* @brief Returns a string that represents the current TSBK.
* @returns std::string String representation of the TSBK.
*/
std::string toString(bool isp = false) override;
public:
/**
* @brief PSTN address; an index into the preset telephone number table held by the infrastructure.
*/
DECLARE_PROPERTY(uint8_t, pstnAddress, PSTNAddress);
DECLARE_COPY(ISP_TELE_INT_PSTN_REQ);
};
} // namespace tsbk
} // namespace lc
} // namespace p25
#endif // __P25_LC_TSBK__ISP_TELE_INT_PSTN_REQ_H__

@ -0,0 +1,103 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Digital Voice Modem - Common Library
* GPLv2 Open Source. Use is subject to license terms.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright (C) 2026 Charles Bricker, K3NOP
*
*/
#include "Defines.h"
#include "p25/lc/tsbk/OSP_TELE_INT_VCH_GRANT.h"
using namespace p25;
using namespace p25::defines;
using namespace p25::lc;
using namespace p25::lc::tsbk;
#include <cassert>
// ---------------------------------------------------------------------------
// Public Class Members
// ---------------------------------------------------------------------------
/* Initializes a new instance of the OSP_TELE_INT_VCH_GRANT class. */
OSP_TELE_INT_VCH_GRANT::OSP_TELE_INT_VCH_GRANT() : TSBK(),
m_callTimer(0U)
{
m_lco = TSBKO::IOSP_TELE_INT_DIAL;
}
/* Decode a trunking signalling block. */
bool OSP_TELE_INT_VCH_GRANT::decode(const uint8_t* data, bool rawTSBK)
{
assert(data != nullptr);
uint8_t tsbk[P25_TSBK_LENGTH_BYTES + 1U];
::memset(tsbk, 0x00U, P25_TSBK_LENGTH_BYTES);
bool ret = TSBK::decode(data, tsbk, rawTSBK);
if (!ret)
return false;
ulong64_t tsbkValue = TSBK::toValue(tsbk);
m_emergency = (((tsbkValue >> 56) & 0xFFU) & 0x80U) == 0x80U; // Emergency Flag
m_encrypted = (((tsbkValue >> 56) & 0xFFU) & 0x40U) == 0x40U; // Encryption Flag
m_priority = (((tsbkValue >> 56) & 0xFFU) & 0x07U); // Priority
m_grpVchId = ((tsbkValue >> 52) & 0x0FU); // Channel ID
m_grpVchNo = ((tsbkValue >> 40) & 0xFFFU); // Channel Number
m_callTimer = (uint16_t)((tsbkValue >> 24) & 0xFFFFU); // Call Timer
m_srcId = (uint32_t)(tsbkValue & 0xFFFFFFU); // Source/Target Radio Address
m_dstId = m_srcId;
return true;
}
/* Encode a trunking signalling block. */
void OSP_TELE_INT_VCH_GRANT::encode(uint8_t* data, bool rawTSBK, bool noTrellis)
{
assert(data != nullptr);
ulong64_t tsbkValue = 0U;
tsbkValue =
(m_emergency ? 0x80U : 0x00U) + // Emergency Flag
(m_encrypted ? 0x40U : 0x00U) + // Encrypted Flag
(m_priority & 0x07U); // Priority
if (m_grpVchId != 0U) {
tsbkValue = (tsbkValue << 4) + m_grpVchId; // Channel ID
}
else {
tsbkValue = (tsbkValue << 4) + s_siteData.channelId(); // Channel ID
}
tsbkValue = (tsbkValue << 12) + m_grpVchNo; // Channel Number
tsbkValue = (tsbkValue << 16) + m_callTimer; // Call Timer
tsbkValue = (tsbkValue << 24) + m_srcId; // Source/Target Radio Address
std::unique_ptr<uint8_t[]> tsbk = TSBK::fromValue(tsbkValue);
TSBK::encode(data, tsbk.get(), rawTSBK, noTrellis);
}
/* Returns a string that represents the current TSBK. */
std::string OSP_TELE_INT_VCH_GRANT::toString(bool isp)
{
return std::string("TSBKO, OSP_TELE_INT_VCH_GRANT (Telephone Interconnect Voice Channel Grant)");
}
// ---------------------------------------------------------------------------
// Private Class Members
// ---------------------------------------------------------------------------
/* Internal helper to copy the the class. */
void OSP_TELE_INT_VCH_GRANT::copy(const OSP_TELE_INT_VCH_GRANT& data)
{
TSBK::copy(data);
m_callTimer = data.m_callTimer;
}

@ -0,0 +1,76 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Digital Voice Modem - Common Library
* GPLv2 Open Source. Use is subject to license terms.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright (C) 2026 Charles Bricker, K3NOP
*
*/
/**
* @file OSP_TELE_INT_VCH_GRANT.h
* @ingroup p25_tsbk
* @file OSP_TELE_INT_VCH_GRANT.cpp
* @ingroup p25_tsbk
*/
#if !defined(__P25_LC_TSBK__OSP_TELE_INT_VCH_GRANT_H__)
#define __P25_LC_TSBK__OSP_TELE_INT_VCH_GRANT_H__
#include "common/Defines.h"
#include "common/p25/lc/TSBK.h"
namespace p25
{
namespace lc
{
namespace tsbk
{
// ---------------------------------------------------------------------------
// Class Declaration
// ---------------------------------------------------------------------------
/**
* @brief Implements TELE INT VCH GRANT - Telephone Interconnect Voice Channel Grant (OSP)
* @ingroup p25_tsbk
*/
class DVM_COMMON_API OSP_TELE_INT_VCH_GRANT : public TSBK {
public:
/**
* @brief Initializes a new instance of the OSP_TELE_INT_VCH_GRANT class.
*/
OSP_TELE_INT_VCH_GRANT();
/**
* @brief Decode a trunking signalling block.
* @param[in] data Buffer containing a TSBK to decode.
* @param rawTSBK Flag indicating whether or not the passed buffer is raw.
* @returns bool True, if TSBK decoded, otherwise false.
*/
bool decode(const uint8_t* data, bool rawTSBK = false) override;
/**
* @brief Encode a trunking signalling block.
* @param[out] data Buffer to encode a TSBK.
* @param rawTSBK Flag indicating whether or not the output buffer is raw.
* @param noTrellis Flag indicating whether or not the encoded data should be Trellis encoded.
*/
void encode(uint8_t* data, bool rawTSBK = false, bool noTrellis = false) override;
/**
* @brief Returns a string that represents the current TSBK.
* @returns std::string String representation of the TSBK.
*/
std::string toString(bool isp = false) override;
public:
/**
* @brief Call timer, in 100ms units (0 = no timer).
*/
DECLARE_PROPERTY(uint16_t, callTimer, CallTimer);
DECLARE_COPY(OSP_TELE_INT_VCH_GRANT);
};
} // namespace tsbk
} // namespace lc
} // namespace p25
#endif // __P25_LC_TSBK__OSP_TELE_INT_VCH_GRANT_H__

@ -175,6 +175,12 @@ std::unique_ptr<TSBK> TSBKFactory::createTSBK(const uint8_t* data, bool rawTSBK)
return decode(new OSP_UU_VCH_GRANT_UPD(), data, rawTSBK);
case TSBKO::IOSP_UU_ANS:
return decode(new IOSP_UU_ANS(), data, rawTSBK);
case TSBKO::IOSP_TELE_INT_DIAL:
return decode(new OSP_TELE_INT_VCH_GRANT(), data, rawTSBK);
case TSBKO::ISP_TELE_INT_PSTN_REQ:
return decode(new ISP_TELE_INT_PSTN_REQ(), data, rawTSBK);
case TSBKO::IOSP_TELE_INT_ANS:
return decode(new IOSP_TELE_INT_ANS(), data, rawTSBK);
case TSBKO::ISP_SNDCP_CH_REQ:
return decode(new ISP_SNDCP_CH_REQ(), data, rawTSBK);
case TSBKO::ISP_SNDCP_REC_REQ:

@ -38,6 +38,7 @@
#include "common/p25/lc/tsbk/IOSP_MSG_UPDT.h"
#include "common/p25/lc/tsbk/IOSP_RAD_MON.h"
#include "common/p25/lc/tsbk/IOSP_STS_UPDT.h"
#include "common/p25/lc/tsbk/IOSP_TELE_INT_ANS.h"
#include "common/p25/lc/tsbk/IOSP_U_REG.h"
#include "common/p25/lc/tsbk/IOSP_UU_ANS.h"
#include "common/p25/lc/tsbk/IOSP_UU_VCH.h"
@ -50,6 +51,7 @@
#include "common/p25/lc/tsbk/ISP_LOC_REG_REQ.h"
#include "common/p25/lc/tsbk/ISP_SNDCP_CH_REQ.h"
#include "common/p25/lc/tsbk/ISP_SNDCP_REC_REQ.h"
#include "common/p25/lc/tsbk/ISP_TELE_INT_PSTN_REQ.h"
#include "common/p25/lc/tsbk/ISP_U_DEREG_REQ.h"
#include "common/p25/lc/tsbk/OSP_ADJ_STS_BCAST.h"
#include "common/p25/lc/tsbk/OSP_AUTH_FNE_RESP.h"
@ -75,6 +77,7 @@
#include "common/p25/lc/tsbk/OSP_SNDCP_CH_GNT.h"
#include "common/p25/lc/tsbk/OSP_SYNC_BCAST.h"
#include "common/p25/lc/tsbk/OSP_SYS_SRV_BCAST.h"
#include "common/p25/lc/tsbk/OSP_TELE_INT_VCH_GRANT.h"
#include "common/p25/lc/tsbk/OSP_TIME_DATE_ANN.h"
#include "common/p25/lc/tsbk/OSP_TSBK_RAW.h"
#include "common/p25/lc/tsbk/OSP_U_DEREG_ACK.h"

@ -0,0 +1,151 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Digital Voice Modem - Test Suite
* GPLv2 Open Source. Use is subject to license terms.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright (C) 2026 Charles Bricker, K3NOP
*
*/
#include "host/Defines.h"
#include "common/p25/lc/tsbk/TSBKFactory.h"
#include "common/p25/P25Defines.h"
#include "common/edac/CRC.h"
using namespace p25;
using namespace p25::defines;
using namespace p25::lc;
using namespace p25::lc::tsbk;
#include <catch2/catch_test_macros.hpp>
TEST_CASE("TSBK Telephone Interconnect", "[p25][tsbk]") {
SECTION("OSP_TELE_INT_VCH_GRANT_Layout") {
OSP_TELE_INT_VCH_GRANT osp;
osp.setPriority(4U);
osp.setGrpVchId(1U);
osp.setGrpVchNo(0x123U);
osp.setCallTimer(600U);
osp.setSrcId(0x123456U);
uint8_t raw[P25_TSBK_LENGTH_BYTES];
osp.encode(raw, true, true);
REQUIRE((raw[0U] & 0x3FU) == TSBKO::IOSP_TELE_INT_DIAL);
REQUIRE(raw[2U] == 0x04U); // Service Options
REQUIRE(raw[3U] == 0x11U); // Channel ID + Channel Number (MSB)
REQUIRE(raw[4U] == 0x23U); // Channel Number (LSB)
REQUIRE(raw[5U] == 0x02U); // Call Timer (MSB)
REQUIRE(raw[6U] == 0x58U); // Call Timer (LSB)
REQUIRE(raw[7U] == 0x12U); // Address
REQUIRE(raw[8U] == 0x34U);
REQUIRE(raw[9U] == 0x56U);
std::unique_ptr<TSBK> tsbk = TSBKFactory::createTSBK(raw, true);
REQUIRE(tsbk != nullptr);
OSP_TELE_INT_VCH_GRANT* decoded = dynamic_cast<OSP_TELE_INT_VCH_GRANT*>(tsbk.get());
REQUIRE(decoded != nullptr);
REQUIRE(decoded->getPriority() == 4U);
REQUIRE(decoded->getGrpVchId() == 1U);
REQUIRE(decoded->getGrpVchNo() == 0x123U);
REQUIRE(decoded->getCallTimer() == 600U);
REQUIRE(decoded->getSrcId() == 0x123456U);
REQUIRE(decoded->getDstId() == 0x123456U);
}
SECTION("ISP_TELE_INT_PSTN_REQ_Layout") {
ISP_TELE_INT_PSTN_REQ isp;
isp.setEmergency(true);
isp.setPSTNAddress(0x07U);
isp.setSrcId(0x00ABCDU);
uint8_t raw[P25_TSBK_LENGTH_BYTES];
isp.encode(raw, true, true);
REQUIRE((raw[0U] & 0x3FU) == TSBKO::ISP_TELE_INT_PSTN_REQ);
REQUIRE(raw[2U] == 0x80U); // Service Options
REQUIRE(raw[3U] == 0x00U); // Reserved
REQUIRE(raw[4U] == 0x00U);
REQUIRE(raw[5U] == 0x00U);
REQUIRE(raw[6U] == 0x07U); // PSTN Address
REQUIRE(raw[7U] == 0x00U); // Source Address
REQUIRE(raw[8U] == 0xABU);
REQUIRE(raw[9U] == 0xCDU);
std::unique_ptr<TSBK> tsbk = TSBKFactory::createTSBK(raw, true);
REQUIRE(tsbk != nullptr);
ISP_TELE_INT_PSTN_REQ* decoded = dynamic_cast<ISP_TELE_INT_PSTN_REQ*>(tsbk.get());
REQUIRE(decoded != nullptr);
REQUIRE(decoded->getEmergency() == true);
REQUIRE(decoded->getPSTNAddress() == 0x07U);
REQUIRE(decoded->getSrcId() == 0x00ABCDU);
}
SECTION("IOSP_TELE_INT_ANS_Request_Layout") {
IOSP_TELE_INT_ANS osp;
osp.setDigits("5551234");
osp.setDstId(0x000064U);
uint8_t raw[P25_TSBK_LENGTH_BYTES];
osp.encode(raw, true, true);
REQUIRE((raw[0U] & 0x3FU) == TSBKO::IOSP_TELE_INT_ANS);
REQUIRE(raw[2U] == 0x55U); // Digits 1 - 2
REQUIRE(raw[3U] == 0x51U); // Digits 3 - 4
REQUIRE(raw[4U] == 0x23U); // Digits 5 - 6
REQUIRE(raw[5U] == 0x4FU); // Digit 7 + Null Filler
REQUIRE(raw[6U] == 0xFFU); // Null Filler
REQUIRE(raw[7U] == 0x00U); // Target Address
REQUIRE(raw[8U] == 0x00U);
REQUIRE(raw[9U] == 0x64U);
std::unique_ptr<TSBK> tsbk = TSBKFactory::createTSBK(raw, true);
REQUIRE(tsbk != nullptr);
IOSP_TELE_INT_ANS* decoded = dynamic_cast<IOSP_TELE_INT_ANS*>(tsbk.get());
REQUIRE(decoded != nullptr);
REQUIRE(decoded->getDigits() == "5551234");
REQUIRE(decoded->getDstId() == 0x000064U);
}
SECTION("IOSP_TELE_INT_ANS_Request_ExtendedDigits") {
IOSP_TELE_INT_ANS osp;
osp.setDigits("12A*#");
osp.setDstId(0x000001U);
uint8_t raw[P25_TSBK_LENGTH_BYTES];
osp.encode(raw, true, true);
REQUIRE(raw[2U] == 0x12U); // 1, 2
REQUIRE(raw[3U] == 0xF0U); // ESC, A
REQUIRE(raw[4U] == 0xABU); // *, #
IOSP_TELE_INT_ANS decoded;
REQUIRE(decoded.decode(raw, true) == true);
REQUIRE(decoded.getDigits() == "12A*#");
}
SECTION("IOSP_TELE_INT_ANS_Response_Decode") {
uint8_t raw[P25_TSBK_LENGTH_BYTES];
::memset(raw, 0x00U, P25_TSBK_LENGTH_BYTES);
raw[0U] = 0x80U | TSBKO::IOSP_TELE_INT_ANS; // Last Block + LCO
raw[1U] = MFG_STANDARD;
raw[2U] = 0x00U; // Service Options
raw[3U] = ResponseCode::ANS_PROCEED; // Answer Response
raw[7U] = 0x00U; // Source Address
raw[8U] = 0x12U;
raw[9U] = 0x34U;
edac::CRC::addCCITT162(raw, P25_TSBK_LENGTH_BYTES);
std::unique_ptr<TSBK> tsbk = TSBKFactory::createTSBK(raw, true);
REQUIRE(tsbk != nullptr);
IOSP_TELE_INT_ANS* decoded = dynamic_cast<IOSP_TELE_INT_ANS*>(tsbk.get());
REQUIRE(decoded != nullptr);
REQUIRE(decoded->getResponse() == ResponseCode::ANS_PROCEED);
REQUIRE(decoded->getSrcId() == 0x001234U);
}
}
Loading…
Cancel
Save

Powered by TurnKey Linux.