Crash_Override/MMDVMHost-Private
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Fix commit with bad line endings.

Browse source
This commit is contained in:
Bryan Biedenkapp 2018-05-14 10:25:19 -04:00
parent 0395955ab3
commit 471e084723
5 changed files with 1906 additions and 1897 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2308
P25Control.cpp
View file

File diff suppressed because it is too large Load diff

236
P25Control.h
View file

@ -1,118 +1,118 @@
/* /*
* Copyright (C) 2016,2017,2018 by Jonathan Naylor G4KLX * Copyright (C) 2016,2017,2018 by Jonathan Naylor G4KLX
* Copyright (C) 2018 by Bryan Biedenkapp <gatekeep@gmail.com> * Copyright (C) 2018 by Bryan Biedenkapp <gatekeep@gmail.com>
* *
* This program is free software; you can redistribute it and/or modify * 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 * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/ */
#if !defined(P25Control_H) #if !defined(P25Control_H)
#define P25Control_H #define P25Control_H
#include "RSSIInterpolator.h" #include "RSSIInterpolator.h"
#include "P25LowSpeedData.h" #include "P25LowSpeedData.h"
#include "RingBuffer.h" #include "RingBuffer.h"
#include "P25Network.h" #include "P25Network.h"
#include "DMRLookup.h" #include "DMRLookup.h"
#include "P25Audio.h" #include "P25Audio.h"
#include "Defines.h" #include "Defines.h"
#include "Display.h" #include "Display.h"
#include "P25Data.h" #include "P25Data.h"
#include "P25NID.h" #include "P25NID.h"
#include "Modem.h" #include "Modem.h"
#include "Timer.h" #include "Timer.h"
#include <cstdio> #include <cstdio>
class CP25Control { class CP25Control {
public: public:
CP25Control(unsigned int nac, unsigned int id, bool selfOly, bool uidOverride, CP25Network* network, CDisplay* display, unsigned int timeout, bool duplex, CDMRLookup* lookup, bool remoteGateway, CRSSIInterpolator* rssiMapper); CP25Control(unsigned int nac, unsigned int id, bool selfOly, bool uidOverride, CP25Network* network, CDisplay* display, unsigned int timeout, bool duplex, CDMRLookup* lookup, bool remoteGateway, CRSSIInterpolator* rssiMapper);
~CP25Control(); ~CP25Control();
bool writeModem(unsigned char* data, unsigned int len); bool writeModem(unsigned char* data, unsigned int len);
unsigned int readModem(unsigned char* data); unsigned int readModem(unsigned char* data);
void clock(unsigned int ms); void clock(unsigned int ms);
private: private:
unsigned int m_nac; unsigned int m_nac;
unsigned int m_id; unsigned int m_id;
bool m_selfOnly; bool m_selfOnly;
bool m_uidOverride; bool m_uidOverride;
bool m_remoteGateway; bool m_remoteGateway;
CP25Network* m_network; CP25Network* m_network;
CDisplay* m_display; CDisplay* m_display;
bool m_duplex; bool m_duplex;
CDMRLookup* m_lookup; CDMRLookup* m_lookup;
CRingBuffer<unsigned char> m_queue; CRingBuffer<unsigned char> m_queue;
RPT_RF_STATE m_rfState; RPT_RF_STATE m_rfState;
RPT_NET_STATE m_netState; RPT_NET_STATE m_netState;
CTimer m_rfTimeout; CTimer m_rfTimeout;
CTimer m_netTimeout; CTimer m_netTimeout;
CTimer m_networkWatchdog; CTimer m_networkWatchdog;
unsigned int m_rfFrames; unsigned int m_rfFrames;
unsigned int m_rfBits; unsigned int m_rfBits;
unsigned int m_rfErrs; unsigned int m_rfErrs;
unsigned int m_netFrames; unsigned int m_netFrames;
unsigned int m_netLost; unsigned int m_netLost;
unsigned int m_rfDataFrames; unsigned int m_rfDataFrames;
CP25NID m_nid; CP25NID m_nid;
unsigned char m_lastDUID; unsigned char m_lastDUID;
CP25Audio m_audio; CP25Audio m_audio;
CP25Data m_rfData; CP25Data m_rfData;
CP25Data m_netData; CP25Data m_netData;
CP25LowSpeedData m_rfLSD; CP25LowSpeedData m_rfLSD;
CP25LowSpeedData m_netLSD; CP25LowSpeedData m_netLSD;
unsigned char* m_netLDU1; unsigned char* m_netLDU1;
unsigned char* m_netLDU2; unsigned char* m_netLDU2;
unsigned char* m_lastIMBE; unsigned char* m_lastIMBE;
unsigned char* m_rfLDU; unsigned char* m_rfLDU;
unsigned char* m_rfPDU; unsigned char* m_rfPDU;
unsigned int m_rfPDUCount; unsigned int m_rfPDUCount;
unsigned int m_rfPDUBits; unsigned int m_rfPDUBits;
CRSSIInterpolator* m_rssiMapper; CRSSIInterpolator* m_rssiMapper;
unsigned char m_rssi; unsigned char m_rssi;
unsigned char m_maxRSSI; unsigned char m_maxRSSI;
unsigned char m_minRSSI; unsigned char m_minRSSI;
unsigned int m_aveRSSI; unsigned int m_aveRSSI;
unsigned int m_rssiCount; unsigned int m_rssiCount;
FILE* m_fp; FILE* m_fp;
void writeQueueRF(const unsigned char* data, unsigned int length); void writeQueueRF(const unsigned char* data, unsigned int length);
void writeQueueNet(const unsigned char* data, unsigned int length); void writeQueueNet(const unsigned char* data, unsigned int length);
void writeNetwork(const unsigned char *data, unsigned char type, bool end); void writeNetwork(const unsigned char *data, unsigned char type, bool end);
void writeNetwork(); void writeNetwork();
void setBusyBits(unsigned char* data, unsigned int ssOffset, bool b1, bool b2); void setBusyBits(unsigned char* data, unsigned int ssOffset, bool b1, bool b2);
void addBusyBits(unsigned char* data, unsigned int length, bool b1, bool b2); void addBusyBits(unsigned char* data, unsigned int length, bool b1, bool b2);
void checkNetLDU1(); void checkNetLDU1();
void checkNetLDU2(); void checkNetLDU2();
void insertMissingAudio(unsigned char* data); void insertMissingAudio(unsigned char* data);
void createRFHeader(); void createRFHeader();
void createNetHeader(); void createNetHeader();
void createNetLDU1(); void createNetLDU1();
void createNetLDU2(); void createNetLDU2();
void createNetTerminator(); void createNetTerminator();
bool openFile(); bool openFile();
bool writeFile(const unsigned char* data, unsigned char length); bool writeFile(const unsigned char* data, unsigned char length);
void closeFile(); void closeFile();
}; };
#endif #endif

929
P25Data.cpp
View file

@ -1,460 +1,469 @@
/* /*
* Copyright (C) 2016,2017 by Jonathan Naylor G4KLX * Copyright (C) 2016,2017 by Jonathan Naylor G4KLX
* Copyright (C) 2018 by Bryan Biedenkapp <gatekeep@gmail.com> * Copyright (C) 2018 by Bryan Biedenkapp <gatekeep@gmail.com>
* *
* This program is free software; you can redistribute it and/or modify * 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 * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/ */
#include "P25Data.h" #include "P25Data.h"
#include "P25Defines.h" #include "P25Defines.h"
#include "P25Utils.h" #include "P25Utils.h"
#include "CRC.h" #include "CRC.h"
#include "Hamming.h" #include "Hamming.h"
#include "Utils.h" #include "Utils.h"
#include "Log.h" #include "Log.h"
#include <cstdio> #include <cstdio>
#include <cassert> #include <cassert>
#include <cstring> #include <cstring>
const unsigned char DUMMY_HEADER[] = { const unsigned char DUMMY_HEADER[] = {
0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U,
0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x08U, 0xDCU, 0x60U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x08U, 0xDCU, 0x60U,
0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x02U, 0x93U, 0xE7U, 0x73U, 0x77U, 0x57U, 0xD6U, 0xD3U, 0xCFU, 0x77U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x02U, 0x93U, 0xE7U, 0x73U, 0x77U, 0x57U, 0xD6U, 0xD3U, 0xCFU, 0x77U,
0xEEU, 0x82U, 0x93U, 0xE2U, 0x2FU, 0xF3U, 0xD5U, 0xF5U, 0xBEU, 0xBCU, 0x54U, 0x0DU, 0x9CU, 0x29U, 0x3EU, 0x46U, 0xEEU, 0x82U, 0x93U, 0xE2U, 0x2FU, 0xF3U, 0xD5U, 0xF5U, 0xBEU, 0xBCU, 0x54U, 0x0DU, 0x9CU, 0x29U, 0x3EU, 0x46U,
0xE3U, 0x28U, 0xB0U, 0xB7U, 0x73U, 0x76U, 0x1EU, 0x26U, 0x0CU, 0x75U, 0x5BU, 0xF7U, 0x4DU, 0x5FU, 0x5AU, 0x37U, 0xE3U, 0x28U, 0xB0U, 0xB7U, 0x73U, 0x76U, 0x1EU, 0x26U, 0x0CU, 0x75U, 0x5BU, 0xF7U, 0x4DU, 0x5FU, 0x5AU, 0x37U,
0x18U}; 0x18U};
const unsigned char DUMMY_LDU2[] = { const unsigned char DUMMY_LDU2[] = {
0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x80U, 0x00U, 0x00U, 0xACU, 0xB8U, 0xA4U, 0x9BU, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x80U, 0x00U, 0x00U, 0xACU, 0xB8U, 0xA4U, 0x9BU,
0xDCU, 0x75U 0xDCU, 0x75U
}; };
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 };
#define WRITE_BIT(p,i,b) p[(i)>>3] = (b) ? (p[(i)>>3] | BIT_MASK_TABLE[(i)&7]) : (p[(i)>>3] & ~BIT_MASK_TABLE[(i)&7]) #define WRITE_BIT(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_BIT(p,i) (p[(i)>>3] & BIT_MASK_TABLE[(i)&7]) #define READ_BIT(p,i) (p[(i)>>3] & BIT_MASK_TABLE[(i)&7])
CP25Data::CP25Data() : CP25Data::CP25Data() :
m_mi(NULL), m_mi(NULL),
m_mfId(0U), m_mfId(0U),
m_algId(0x80U), m_algId(0x80U),
m_kId(0U), m_kId(0U),
m_lcf(0x00U), m_lcf(0x00U),
m_emergency(false), m_emergency(false),
m_srcId(0U), m_srcId(0U),
m_dstId(0U), m_dstId(0U),
m_serviceType(0U), m_rs241213(),
m_rs241213(), m_trellis()
m_trellis() {
{ m_mi = new unsigned char[P25_MI_LENGTH_BYTES];
m_mi = new unsigned char[P25_MI_LENGTH_BYTES]; }
}
CP25Data::~CP25Data()
CP25Data::~CP25Data() {
{ delete[] m_mi;
delete[] m_mi; }
}
void CP25Data::encodeHeader(unsigned char* data)
void CP25Data::encodeHeader(unsigned char* data) {
{ assert(data != NULL);
assert(data != NULL);
CP25Utils::encode(DUMMY_HEADER, data, 114U, 780U);
CP25Utils::encode(DUMMY_HEADER, data, 114U, 780U); }
}
bool CP25Data::decodeLDU1(const unsigned char* data)
bool CP25Data::decodeLDU1(const unsigned char* data) {
{ assert(data != NULL);
assert(data != NULL);
unsigned char rs[18U];
unsigned char rs[18U];
unsigned char raw[5U];
unsigned char raw[5U]; CP25Utils::decode(data, raw, 410U, 452U);
CP25Utils::decode(data, raw, 410U, 452U); decodeLDUHamming(raw, rs + 0U);
decodeLDUHamming(raw, rs + 0U);
CP25Utils::decode(data, raw, 600U, 640U);
CP25Utils::decode(data, raw, 600U, 640U); decodeLDUHamming(raw, rs + 3U);
decodeLDUHamming(raw, rs + 3U);
CP25Utils::decode(data, raw, 788U, 830U);
CP25Utils::decode(data, raw, 788U, 830U); decodeLDUHamming(raw, rs + 6U);
decodeLDUHamming(raw, rs + 6U);
CP25Utils::decode(data, raw, 978U, 1020U);
CP25Utils::decode(data, raw, 978U, 1020U); decodeLDUHamming(raw, rs + 9U);
decodeLDUHamming(raw, rs + 9U);
CP25Utils::decode(data, raw, 1168U, 1208U);
CP25Utils::decode(data, raw, 1168U, 1208U); decodeLDUHamming(raw, rs + 12U);
decodeLDUHamming(raw, rs + 12U);
CP25Utils::decode(data, raw, 1356U, 1398U);
CP25Utils::decode(data, raw, 1356U, 1398U); decodeLDUHamming(raw, rs + 15U);
decodeLDUHamming(raw, rs + 15U);
try {
try { bool ret = m_rs241213.decode(rs);
bool ret = m_rs241213.decode(rs); if (!ret)
if (!ret) return false;
return false; } catch (...) {
} catch (...) { CUtils::dump(2U, "P25, RS carshed with input data", rs, 18U);
CUtils::dump(2U, "P25, RS carshed with input data", rs, 18U); return false;
return false; }
}
unsigned int srcId = (rs[6U] << 16) + (rs[7U] << 8) + rs[8U];
unsigned int srcId = (rs[6U] << 16) + (rs[7U] << 8) + rs[8U];
switch (rs[0U]) {
switch (rs[0U]) { case P25_LCF_GROUP:
case P25_LCF_GROUP: m_emergency = (rs[2U] & 0x80U) == 0x80U;
m_emergency = (rs[2U] & 0x80U) == 0x80U; m_dstId = (rs[4U] << 8) + rs[5U];
m_dstId = (rs[4U] << 8) + rs[5U]; m_srcId = srcId;
m_srcId = srcId; break;
break; case P25_LCF_PRIVATE:
case P25_LCF_PRIVATE: m_emergency = false;
m_emergency = false; m_dstId = (rs[3U] << 16) + (rs[4U] << 8) + rs[5U];
m_dstId = (rs[3U] << 16) + (rs[4U] << 8) + rs[5U]; m_srcId = srcId;
m_srcId = srcId; break;
break; default:
default: return false;
return false; }
}
m_lcf = rs[0U];
m_lcf = rs[0U]; m_mfId = rs[1U];
m_mfId = rs[1U];
return true;
return true; }
}
void CP25Data::encodeLDU1(unsigned char* data)
void CP25Data::encodeLDU1(unsigned char* data) {
{ assert(data != NULL);
assert(data != NULL);
unsigned char rs[18U];
unsigned char rs[18U]; ::memset(rs, 0x00U, 18U);
::memset(rs, 0x00U, 18U);
rs[0U] = m_lcf;
rs[0U] = m_lcf; rs[1U] = m_mfId;
rs[1U] = m_mfId;
switch (m_lcf) {
switch (m_lcf) { case P25_LCF_GROUP:
case P25_LCF_GROUP: rs[2U] = m_emergency ? 0x80U : 0x00U;
rs[2U] = m_emergency ? 0x80U : 0x00U; rs[4U] = (m_dstId >> 8) & 0xFFU;
rs[4U] = (m_dstId >> 8) & 0xFFU; rs[5U] = (m_dstId >> 0) & 0xFFU;
rs[5U] = (m_dstId >> 0) & 0xFFU; rs[6U] = (m_srcId >> 16) & 0xFFU;
rs[6U] = (m_srcId >> 16) & 0xFFU; rs[7U] = (m_srcId >> 8) & 0xFFU;
rs[7U] = (m_srcId >> 8) & 0xFFU; rs[8U] = (m_srcId >> 0) & 0xFFU;
rs[8U] = (m_srcId >> 0) & 0xFFU; break;
break; case P25_LCF_PRIVATE:
case P25_LCF_PRIVATE: rs[3U] = (m_dstId >> 16) & 0xFFU;
rs[3U] = (m_dstId >> 16) & 0xFFU; rs[4U] = (m_dstId >> 8) & 0xFFU;
rs[4U] = (m_dstId >> 8) & 0xFFU; rs[5U] = (m_dstId >> 0) & 0xFFU;
rs[5U] = (m_dstId >> 0) & 0xFFU; rs[6U] = (m_srcId >> 16) & 0xFFU;
rs[6U] = (m_srcId >> 16) & 0xFFU; rs[7U] = (m_srcId >> 8) & 0xFFU;
rs[7U] = (m_srcId >> 8) & 0xFFU; rs[8U] = (m_srcId >> 0) & 0xFFU;
rs[8U] = (m_srcId >> 0) & 0xFFU; break;
break; default:
default: LogMessage("P25, unknown LCF value in LDU1 - $%02X", m_lcf);
LogMessage("P25, unknown LCF value in LDU1 - $%02X", m_lcf); break;
break; }
}
m_rs241213.encode(rs);
m_rs241213.encode(rs);
unsigned char raw[5U];
unsigned char raw[5U]; encodeLDUHamming(raw, rs + 0U);
encodeLDUHamming(raw, rs + 0U); CP25Utils::encode(raw, data, 410U, 452U);
CP25Utils::encode(raw, data, 410U, 452U);
encodeLDUHamming(raw, rs + 3U);
encodeLDUHamming(raw, rs + 3U); CP25Utils::encode(raw, data, 600U, 640U);
CP25Utils::encode(raw, data, 600U, 640U);
encodeLDUHamming(raw, rs + 6U);
encodeLDUHamming(raw, rs + 6U); CP25Utils::encode(raw, data, 788U, 830U);
CP25Utils::encode(raw, data, 788U, 830U);
encodeLDUHamming(raw, rs + 9U);
encodeLDUHamming(raw, rs + 9U); CP25Utils::encode(raw, data, 978U, 1020U);
CP25Utils::encode(raw, data, 978U, 1020U);
encodeLDUHamming(raw, rs + 12U);
encodeLDUHamming(raw, rs + 12U); CP25Utils::encode(raw, data, 1168U, 1208U);
CP25Utils::encode(raw, data, 1168U, 1208U);
encodeLDUHamming(raw, rs + 15U);
encodeLDUHamming(raw, rs + 15U); CP25Utils::encode(raw, data, 1356U, 1398U);
CP25Utils::encode(raw, data, 1356U, 1398U); }
}
void CP25Data::encodeLDU2(unsigned char* data)
void CP25Data::encodeLDU2(unsigned char* data) {
{ assert(data != NULL);
assert(data != NULL);
unsigned char raw[5U];
unsigned char raw[5U]; encodeLDUHamming(raw, DUMMY_LDU2 + 0U);
encodeLDUHamming(raw, DUMMY_LDU2 + 0U); CP25Utils::encode(raw, data, 410U, 452U);
CP25Utils::encode(raw, data, 410U, 452U);
encodeLDUHamming(raw, DUMMY_LDU2 + 3U);
encodeLDUHamming(raw, DUMMY_LDU2 + 3U); CP25Utils::encode(raw, data, 600U, 640U);
CP25Utils::encode(raw, data, 600U, 640U);
encodeLDUHamming(raw, DUMMY_LDU2 + 6U);
encodeLDUHamming(raw, DUMMY_LDU2 + 6U); CP25Utils::encode(raw, data, 788U, 830U);
CP25Utils::encode(raw, data, 788U, 830U);
encodeLDUHamming(raw, DUMMY_LDU2 + 9U);
encodeLDUHamming(raw, DUMMY_LDU2 + 9U); CP25Utils::encode(raw, data, 978U, 1020U);
CP25Utils::encode(raw, data, 978U, 1020U);
encodeLDUHamming(raw, DUMMY_LDU2 + 12U);
encodeLDUHamming(raw, DUMMY_LDU2 + 12U); CP25Utils::encode(raw, data, 1168U, 1208U);
CP25Utils::encode(raw, data, 1168U, 1208U);
encodeLDUHamming(raw, DUMMY_LDU2 + 15U);
encodeLDUHamming(raw, DUMMY_LDU2 + 15U); CP25Utils::encode(raw, data, 1356U, 1398U);
CP25Utils::encode(raw, data, 1356U, 1398U); }
}
bool CP25Data::decodeTSDU(const unsigned char* data)
bool CP25Data::decodeTSDU(const unsigned char* data) {
{ assert(data != NULL);
assert(data != NULL);
// deinterleave
// deinterleave unsigned char tsbk[12U];
unsigned char tsbk[12U]; unsigned char raw[25U];
unsigned char raw[25U]; CP25Utils::decode(data, raw, 114U, 318U);
CP25Utils::decode(data, raw, 114U, 318U);
// decode 1/2 rate Trellis & check CRC-CCITT 16
// decode 1/2 rate Trellis & check CRC-CCITT 16 try {
try { bool ret = m_trellis.decode12(raw, tsbk);
bool ret = m_trellis.decode12(raw, tsbk); if (ret)
if (ret) ret = CCRC::checkCCITT162(tsbk, 12U);
ret = CCRC::checkCCITT162(tsbk, 12U); if (!ret)
if (!ret) return false;
return false; }
} catch (...) {
catch (...) { CUtils::dump(2U, "P25, CRC failed with input data", tsbk, 12U);
CUtils::dump(2U, "P25, CRC failed with input data", tsbk, 12U); return false;
return false; }
}
m_lcf = tsbk[0U] & 0x3F;
m_lcf = tsbk[0U] & 0x3F; m_mfId = tsbk[1U];
m_mfId = tsbk[1U];
unsigned long long tsbkValue = 0U;
unsigned long long tsbkValue = 0U;
// combine bytes into rs value
// combine bytes into rs value tsbkValue = tsbk[2U];
tsbkValue = tsbk[2U]; tsbkValue = (tsbkValue << 8) + tsbk[3U];
tsbkValue = (tsbkValue << 8) + tsbk[3U]; tsbkValue = (tsbkValue << 8) + tsbk[4U];
tsbkValue = (tsbkValue << 8) + tsbk[4U]; tsbkValue = (tsbkValue << 8) + tsbk[5U];
tsbkValue = (tsbkValue << 8) + tsbk[5U]; tsbkValue = (tsbkValue << 8) + tsbk[6U];
tsbkValue = (tsbkValue << 8) + tsbk[6U]; tsbkValue = (tsbkValue << 8) + tsbk[7U];
tsbkValue = (tsbkValue << 8) + tsbk[7U]; tsbkValue = (tsbkValue << 8) + tsbk[8U];
tsbkValue = (tsbkValue << 8) + tsbk[8U]; tsbkValue = (tsbkValue << 8) + tsbk[9U];
tsbkValue = (tsbkValue << 8) + tsbk[9U];
switch (m_lcf) {
switch (m_lcf) { case P25_LCF_TSBK_CALL_ALERT:
case P25_LCF_TSBK_CALL_ALERT: m_dstId = (unsigned int)((tsbkValue >> 24) & 0xFFFFFFU); // Target Radio Address
m_dstId = (unsigned int)((tsbkValue >> 24) & 0xFFFFFFU); // Target Radio Address m_srcId = (unsigned int)(tsbkValue & 0xFFFFFFU); // Source Radio Address
m_srcId = (unsigned int)(tsbkValue & 0xFFFFFFU); // Source Radio Address break;
break; case P25_LCF_TSBK_ACK_RSP_FNE:
case P25_LCF_TSBK_ACK_RSP_FNE: m_serviceType = (unsigned char)((tsbkValue >> 56) & 0xFFU); // Service Type
m_serviceType = (unsigned char)((tsbkValue >> 56) & 0xFFU); // Service Type m_dstId = (unsigned int)((tsbkValue >> 24) & 0xFFFFFFU); // Target Radio Address
m_dstId = (unsigned int)((tsbkValue >> 24) & 0xFFFFFFU); // Target Radio Address m_srcId = (unsigned int)(tsbkValue & 0xFFFFFFU); // Source Radio Address
m_srcId = (unsigned int)(tsbkValue & 0xFFFFFFU); // Source Radio Address break;
break; default:
default: LogMessage("P25, unknown LCF value in TSDU - $%02X", m_lcf);
LogMessage("P25, unknown LCF value in TSDU - $%02X", m_lcf); break;
break; }
}
return true;
return true; }
}
void CP25Data::encodeTSDU(unsigned char* data)
void CP25Data::encodeTSDU(unsigned char* data) {
{ assert(data != NULL);
assert(data != NULL);
unsigned char tsbk[12U];
unsigned char tsbk[12U]; ::memset(tsbk, 0x00U, 12U);
::memset(tsbk, 0x00U, 12U);
unsigned long long tsbkValue = 0U;
unsigned long long tsbkValue = 0U; tsbk[0U] = m_lcf;
tsbk[0U] = m_lcf; tsbk[0U] |= 0x80;
tsbk[0U] |= 0x80;
tsbk[1U] = m_mfId;
tsbk[1U] = m_mfId;
switch (m_lcf) {
switch (m_lcf) { case P25_LCF_TSBK_CALL_ALERT:
case P25_LCF_TSBK_CALL_ALERT: tsbkValue = 0U;
tsbkValue = 0U; tsbkValue = (tsbkValue << 16) + 0U;
tsbkValue = (tsbkValue << 16) + 0U; tsbkValue = (tsbkValue << 24) + m_dstId; // Target Radio Address
tsbkValue = (tsbkValue << 24) + m_dstId; // Target Radio Address tsbkValue = (tsbkValue << 24) + m_srcId; // Source Radio Address
tsbkValue = (tsbkValue << 24) + m_srcId; // Source Radio Address break;
break; case P25_LCF_TSBK_ACK_RSP_FNE:
case P25_LCF_TSBK_ACK_RSP_FNE: tsbkValue = 0U; // Additional Info. Flag
tsbkValue = 0U; // Additional Info. Flag tsbkValue = (tsbkValue << 1) + 0U; // Extended Address Flag
tsbkValue = (tsbkValue << 1) + 0U; // Extended Address Flag tsbkValue = (tsbkValue << 16) + (m_serviceType & 0xFF); // Service Type
tsbkValue = (tsbkValue << 16) + (m_serviceType & 0xFF); // Service Type tsbkValue = (tsbkValue << 32) + m_dstId; // Target Radio Address
tsbkValue = (tsbkValue << 32) + m_dstId; // Target Radio Address tsbkValue = (tsbkValue << 24) + m_srcId; // Source Radio Address
tsbkValue = (tsbkValue << 24) + m_srcId; // Source Radio Address break;
break; default:
default: LogMessage("P25, unknown LCF value in TSDU - $%02X", m_lcf);
LogMessage("P25, unknown LCF value in TSDU - $%02X", m_lcf); break;
break; }
}
// split rs value into bytes
// split rs value into bytes tsbk[2U] = (unsigned char)((tsbkValue >> 56) & 0xFFU);
tsbk[2U] = (unsigned char)((tsbkValue >> 56) & 0xFFU); tsbk[3U] = (unsigned char)((tsbkValue >> 48) & 0xFFU);
tsbk[3U] = (unsigned char)((tsbkValue >> 48) & 0xFFU); tsbk[4U] = (unsigned char)((tsbkValue >> 40) & 0xFFU);
tsbk[4U] = (unsigned char)((tsbkValue >> 40) & 0xFFU); tsbk[5U] = (unsigned char)((tsbkValue >> 32) & 0xFFU);
tsbk[5U] = (unsigned char)((tsbkValue >> 32) & 0xFFU); tsbk[6U] = (unsigned char)((tsbkValue >> 24) & 0xFFU);
tsbk[6U] = (unsigned char)((tsbkValue >> 24) & 0xFFU); tsbk[7U] = (unsigned char)((tsbkValue >> 16) & 0xFFU);
tsbk[7U] = (unsigned char)((tsbkValue >> 16) & 0xFFU); tsbk[8U] = (unsigned char)((tsbkValue >> 8) & 0xFFU);
tsbk[8U] = (unsigned char)((tsbkValue >> 8) & 0xFFU); tsbk[9U] = (unsigned char)((tsbkValue >> 0) & 0xFFU);
tsbk[9U] = (unsigned char)((tsbkValue >> 0) & 0xFFU);
// compute CRC-CCITT 16
// compute CRC-CCITT 16 CCRC::addCCITT162(tsbk, 12U);
CCRC::addCCITT162(tsbk, 12U);
unsigned char raw[25U];
unsigned char raw[25U]; ::memset(raw, 0x00U, 25U);
::memset(raw, 0x00U, 25U);
// encode 1/2 rate Trellis
// encode 1/2 rate Trellis m_trellis.encode12(tsbk, raw);
m_trellis.encode12(tsbk, raw);
// interleave
// interleave CP25Utils::encode(raw, data, 114U, 318U);
CP25Utils::encode(raw, data, 114U, 318U); }
}
void CP25Data::setMI(const unsigned char* mi)
void CP25Data::setMI(const unsigned char* mi) {
{ assert(mi != NULL);
assert(mi != NULL);
::memcpy(m_mi, mi, P25_MI_LENGTH_BYTES);
::memcpy(m_mi, mi, P25_MI_LENGTH_BYTES); }
}
void CP25Data::getMI(unsigned char* mi) const
void CP25Data::getMI(unsigned char* mi) const {
{ assert(mi != NULL);
assert(mi != NULL);
::memcpy(mi, m_mi, P25_MI_LENGTH_BYTES);
::memcpy(mi, m_mi, P25_MI_LENGTH_BYTES); }
}
void CP25Data::setMFId(unsigned char id)
void CP25Data::setMFId(unsigned char id) {
{ m_mfId = id;
m_mfId = id; }
}
unsigned char CP25Data::getMFId() const
unsigned char CP25Data::getMFId() const {
{ return m_mfId;
return m_mfId; }
}
void CP25Data::setAlgId(unsigned char id)
void CP25Data::setAlgId(unsigned char id) {
{ m_algId = id;
m_algId = id; }
}
unsigned char CP25Data::getAlgId() const
unsigned char CP25Data::getAlgId() const {
{ return m_algId;
return m_algId; }
}
void CP25Data::setKId(unsigned int id)
void CP25Data::setKId(unsigned int id) {
{ m_kId = id;
m_kId = id; }
}
unsigned int CP25Data::getKId() const
unsigned int CP25Data::getKId() const {
{ return m_kId;
return m_kId; }
}
void CP25Data::setSrcId(unsigned int id)
void CP25Data::setSrcId(unsigned int id) {
{ m_srcId = id;
m_srcId = id; }
}
unsigned int CP25Data::getSrcId() const
unsigned int CP25Data::getSrcId() const {
{ return m_srcId;
return m_srcId; }
}
void CP25Data::setEmergency(bool on)
void CP25Data::setEmergency(bool on) {
{ m_emergency = on;
m_emergency = on; }
}
bool CP25Data::getEmergency() const
bool CP25Data::getEmergency() const {
{ return m_emergency;
return m_emergency; }
}
void CP25Data::setLCF(unsigned char lcf)
void CP25Data::setLCF(unsigned char lcf) {
{ m_lcf = lcf;
m_lcf = lcf; }
}
unsigned char CP25Data::getLCF() const
unsigned char CP25Data::getLCF() const {
{ return m_lcf;
return m_lcf; }
}
void CP25Data::setDstId(unsigned int id)
void CP25Data::setDstId(unsigned int id) {
{ m_dstId = id;
m_dstId = id; }
}
unsigned int CP25Data::getDstId() const
unsigned int CP25Data::getDstId() const {
{ return m_dstId;
return m_dstId; }
}
void CP25Data::setServiceType(unsigned char type)
void CP25Data::reset() {
{ m_serviceType = type;
::memset(m_mi, 0x00U, P25_MI_LENGTH_BYTES); }
m_algId = 0x80U; unsigned char CP25Data::getServiceType() const
m_kId = 0x0000U; {
m_lcf = P25_LCF_GROUP; return m_serviceType;
m_mfId = 0x00U; }
m_srcId = 0U;
m_dstId = 0U; void CP25Data::reset()
m_emergency = false; {
} ::memset(m_mi, 0x00U, P25_MI_LENGTH_BYTES);
void CP25Data::decodeLDUHamming(const unsigned char* data, unsigned char* raw) m_algId = 0x80U;
{ m_kId = 0x0000U;
unsigned int n = 0U; m_lcf = P25_LCF_GROUP;
unsigned int m = 0U; m_mfId = 0x00U;
for (unsigned int i = 0U; i < 4U; i++) { m_srcId = 0U;
bool hamming[10U]; m_dstId = 0U;
m_emergency = false;
for (unsigned int j = 0U; j < 10U; j++) { }
hamming[j] = READ_BIT(data, n);
n++; void CP25Data::decodeLDUHamming(const unsigned char* data, unsigned char* raw)
} {
unsigned int n = 0U;
CHamming::decode1063(hamming); unsigned int m = 0U;
for (unsigned int i = 0U; i < 4U; i++) {
for (unsigned int j = 0U; j < 6U; j++) { bool hamming[10U];
WRITE_BIT(raw, m, hamming[j]);
m++; for (unsigned int j = 0U; j < 10U; j++) {
} hamming[j] = READ_BIT(data, n);
} n++;
} }
void CP25Data::encodeLDUHamming(unsigned char* data, const unsigned char* raw) CHamming::decode1063(hamming);
{
unsigned int n = 0U; for (unsigned int j = 0U; j < 6U; j++) {
unsigned int m = 0U; WRITE_BIT(raw, m, hamming[j]);
for (unsigned int i = 0U; i < 4U; i++) { m++;
bool hamming[10U]; }
}
for (unsigned int j = 0U; j < 6U; j++) { }
hamming[j] = READ_BIT(raw, m);
m++; void CP25Data::encodeLDUHamming(unsigned char* data, const unsigned char* raw)
} {
unsigned int n = 0U;
CHamming::encode1063(hamming); unsigned int m = 0U;
for (unsigned int i = 0U; i < 4U; i++) {
for (unsigned int j = 0U; j < 10U; j++) { bool hamming[10U];
WRITE_BIT(data, n, hamming[j]);
n++; for (unsigned int j = 0U; j < 6U; j++) {
} hamming[j] = READ_BIT(raw, m);
} m++;
} }
CHamming::encode1063(hamming);
for (unsigned int j = 0U; j < 10U; j++) {
WRITE_BIT(data, n, hamming[j]);
n++;
}
}
}

174
P25Data.h
View file

@ -1,87 +1,87 @@
/* /*
* Copyright (C) 2016,2017 by Jonathan Naylor G4KLX * Copyright (C) 2016,2017 by Jonathan Naylor G4KLX
* Copyright (C) 2018 by Bryan Biedenkapp <gatekeep@gmail.com> * Copyright (C) 2018 by Bryan Biedenkapp <gatekeep@gmail.com>
* *
* This program is free software; you can redistribute it and/or modify * 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 * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/ */
#if !defined(P25Data_H) #if !defined(P25Data_H)
#define P25Data_H #define P25Data_H
#include "RS241213.h" #include "RS241213.h"
#include "P25Trellis.h" #include "P25Trellis.h"
class CP25Data { class CP25Data {
public: public:
CP25Data(); CP25Data();
~CP25Data(); ~CP25Data();
void encodeHeader(unsigned char* data); void encodeHeader(unsigned char* data);
bool decodeLDU1(const unsigned char* data); bool decodeLDU1(const unsigned char* data);
void encodeLDU1(unsigned char* data); void encodeLDU1(unsigned char* data);
void encodeLDU2(unsigned char* data); void encodeLDU2(unsigned char* data);
bool decodeTSDU(const unsigned char* data); bool decodeTSDU(const unsigned char* data);
void encodeTSDU(unsigned char* data); void encodeTSDU(unsigned char* data);
void setMI(const unsigned char* mi); void setMI(const unsigned char* mi);
void getMI(unsigned char* mi) const; void getMI(unsigned char* mi) const;
void setMFId(unsigned char id); void setMFId(unsigned char id);
unsigned char getMFId() const; unsigned char getMFId() const;
void setAlgId(unsigned char id); void setAlgId(unsigned char id);
unsigned char getAlgId() const; unsigned char getAlgId() const;
void setKId(unsigned int id); void setKId(unsigned int id);
unsigned int getKId() const; unsigned int getKId() const;
void setEmergency(bool on); void setEmergency(bool on);
bool getEmergency() const; bool getEmergency() const;
void setSrcId(unsigned int Id); void setSrcId(unsigned int Id);
unsigned int getSrcId() const; unsigned int getSrcId() const;
void setLCF(unsigned char lcf); void setLCF(unsigned char lcf);
unsigned char getLCF() const; unsigned char getLCF() const;
void setDstId(unsigned int id); void setDstId(unsigned int id);
unsigned int getDstId() const; unsigned int getDstId() const;
void setServiceType(unsigned char type); void setServiceType(unsigned char type);
unsigned char getServiceType() const; unsigned char getServiceType() const;
void reset(); void reset();
private: private:
unsigned char* m_mi; unsigned char* m_mi;
unsigned char m_mfId; unsigned char m_mfId;
unsigned char m_algId; unsigned char m_algId;
unsigned int m_kId; unsigned int m_kId;
unsigned char m_lcf; unsigned char m_lcf;
bool m_emergency; bool m_emergency;
unsigned int m_srcId; unsigned int m_srcId;
unsigned int m_dstId; unsigned int m_dstId;
unsigned char m_serviceType; unsigned char m_serviceType;
CRS241213 m_rs241213; CRS241213 m_rs241213;
CP25Trellis m_trellis; CP25Trellis m_trellis;
void decodeLDUHamming(const unsigned char* raw, unsigned char* data); void decodeLDUHamming(const unsigned char* raw, unsigned char* data);
void encodeLDUHamming(unsigned char* data, const unsigned char* raw); void encodeLDUHamming(unsigned char* data, const unsigned char* raw);
}; };
#endif #endif

156
P25Defines.h
View file

@ -1,78 +1,78 @@
/* /*
* Copyright (C) 2016 by Jonathan Naylor G4KLX * Copyright (C) 2016 by Jonathan Naylor G4KLX
* Copyright (C) 2018 by Bryan Biedenkapp <gatekeep@gmail.com> * Copyright (C) 2018 by Bryan Biedenkapp <gatekeep@gmail.com>
* *
* This program is free software; you can redistribute it and/or modify * 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 * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or * the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/ */
#if !defined(P25DEFINES_H) #if !defined(P25DEFINES_H)
#define P25DEFINES_H #define P25DEFINES_H
const unsigned int P25_HDR_FRAME_LENGTH_BYTES = 99U; const unsigned int P25_HDR_FRAME_LENGTH_BYTES = 99U;
const unsigned int P25_HDR_FRAME_LENGTH_BITS = P25_HDR_FRAME_LENGTH_BYTES * 8U; const unsigned int P25_HDR_FRAME_LENGTH_BITS = P25_HDR_FRAME_LENGTH_BYTES * 8U;
const unsigned int P25_LDU_FRAME_LENGTH_BYTES = 216U; const unsigned int P25_LDU_FRAME_LENGTH_BYTES = 216U;
const unsigned int P25_LDU_FRAME_LENGTH_BITS = P25_LDU_FRAME_LENGTH_BYTES * 8U; const unsigned int P25_LDU_FRAME_LENGTH_BITS = P25_LDU_FRAME_LENGTH_BYTES * 8U;
const unsigned int P25_TERM_FRAME_LENGTH_BYTES = 18U; const unsigned int P25_TERM_FRAME_LENGTH_BYTES = 18U;
const unsigned int P25_TERM_FRAME_LENGTH_BITS = P25_TERM_FRAME_LENGTH_BYTES * 8U; const unsigned int P25_TERM_FRAME_LENGTH_BITS = P25_TERM_FRAME_LENGTH_BYTES * 8U;
const unsigned int P25_TERMLC_FRAME_LENGTH_BYTES = 54U; const unsigned int P25_TERMLC_FRAME_LENGTH_BYTES = 54U;
const unsigned int P25_TERMLC_FRAME_LENGTH_BITS = P25_TERMLC_FRAME_LENGTH_BYTES * 8U; const unsigned int P25_TERMLC_FRAME_LENGTH_BITS = P25_TERMLC_FRAME_LENGTH_BYTES * 8U;
const unsigned int P25_TSDU_FRAME_LENGTH_BYTES = 45U; const unsigned int P25_TSDU_FRAME_LENGTH_BYTES = 45U;
const unsigned int P25_TSDU_FRAME_LENGTH_BITS = P25_TSDU_FRAME_LENGTH_BYTES * 8U; const unsigned int P25_TSDU_FRAME_LENGTH_BITS = P25_TSDU_FRAME_LENGTH_BYTES * 8U;
const unsigned int P25_SYNC_LENGTH_BYTES = 6U; const unsigned int P25_SYNC_LENGTH_BYTES = 6U;
const unsigned int P25_SYNC_LENGTH_BITS = P25_SYNC_LENGTH_BYTES * 8U; const unsigned int P25_SYNC_LENGTH_BITS = P25_SYNC_LENGTH_BYTES * 8U;
const unsigned int P25_NID_LENGTH_BYTES = 8U; const unsigned int P25_NID_LENGTH_BYTES = 8U;
const unsigned int P25_NID_LENGTH_BITS = P25_NID_LENGTH_BYTES * 8U; const unsigned int P25_NID_LENGTH_BITS = P25_NID_LENGTH_BYTES * 8U;
const unsigned char P25_SYNC_BYTES[] = {0x55U, 0x75U, 0xF5U, 0xFFU, 0x77U, 0xFFU}; const unsigned char P25_SYNC_BYTES[] = {0x55U, 0x75U, 0xF5U, 0xFFU, 0x77U, 0xFFU};
const unsigned char P25_SYNC_BYTES_LENGTH = 6U; const unsigned char P25_SYNC_BYTES_LENGTH = 6U;
const unsigned int P25_MAX_PDU_COUNT = 10U; const unsigned int P25_MAX_PDU_COUNT = 10U;
const unsigned int P25_PDU_HEADER_LENGTH_BYTES = 12U; const unsigned int P25_PDU_HEADER_LENGTH_BYTES = 12U;
const unsigned int P25_PDU_CONFIRMED_LENGTH_BYTES = 18U; const unsigned int P25_PDU_CONFIRMED_LENGTH_BYTES = 18U;
const unsigned int P25_PDU_UNCONFIRMED_LENGTH_BYTES = 12U; const unsigned int P25_PDU_UNCONFIRMED_LENGTH_BYTES = 12U;
const unsigned int P25_PDU_FEC_LENGTH_BYTES = 24U; const unsigned int P25_PDU_FEC_LENGTH_BYTES = 24U;
const unsigned int P25_PDU_FEC_LENGTH_BITS = P25_PDU_FEC_LENGTH_BYTES * 8U; const unsigned int P25_PDU_FEC_LENGTH_BITS = P25_PDU_FEC_LENGTH_BYTES * 8U;
const unsigned int P25_MI_LENGTH_BYTES = 9U; const unsigned int P25_MI_LENGTH_BYTES = 9U;
const unsigned char P25_LCF_GROUP = 0x00U; const unsigned char P25_LCF_GROUP = 0x00U;
const unsigned char P25_LCF_PRIVATE = 0x03U; const unsigned char P25_LCF_PRIVATE = 0x03U;
const unsigned char P25_LCF_TSBK_CALL_ALERT = 0x1FU; const unsigned char P25_LCF_TSBK_CALL_ALERT = 0x1FU;
const unsigned char P25_LCF_TSBK_ACK_RSP_FNE = 0x20U; const unsigned char P25_LCF_TSBK_ACK_RSP_FNE = 0x20U;
const unsigned int P25_SS0_START = 70U; const unsigned int P25_SS0_START = 70U;
const unsigned int P25_SS1_START = 71U; const unsigned int P25_SS1_START = 71U;
const unsigned int P25_SS_INCREMENT = 72U; const unsigned int P25_SS_INCREMENT = 72U;
const unsigned char P25_DUID_HEADER = 0x00U; const unsigned char P25_DUID_HEADER = 0x00U;
const unsigned char P25_DUID_TERM = 0x03U; const unsigned char P25_DUID_TERM = 0x03U;
const unsigned char P25_DUID_LDU1 = 0x05U; const unsigned char P25_DUID_LDU1 = 0x05U;
const unsigned char P25_DUID_TSDU = 0x07U; const unsigned char P25_DUID_TSDU = 0x07U;
const unsigned char P25_DUID_LDU2 = 0x0AU; const unsigned char P25_DUID_LDU2 = 0x0AU;
const unsigned char P25_DUID_PDU = 0x0CU; const unsigned char P25_DUID_PDU = 0x0CU;
const unsigned char P25_DUID_TERM_LC = 0x0FU; const unsigned char P25_DUID_TERM_LC = 0x0FU;
const unsigned char P25_NULL_IMBE[] = {0x04U, 0x0CU, 0xFDU, 0x7BU, 0xFBU, 0x7DU, 0xF2U, 0x7BU, 0x3DU, 0x9EU, 0x45U}; const unsigned char P25_NULL_IMBE[] = {0x04U, 0x0CU, 0xFDU, 0x7BU, 0xFBU, 0x7DU, 0xF2U, 0x7BU, 0x3DU, 0x9EU, 0x45U};
#endif #endif