Superminaren
/
MMDVM
mirror of https://github.com/g4klx/MMDVM.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add actual NXDN values.

This commit is contained in:
Jonathan Naylor 2018-01-10 21:39:29 +00:00
parent b5ca5e3839
commit 9b5bbee265
4 changed files with 72 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
NXDNDefines.h
View File

@ -21,34 +21,30 @@
const unsigned int NXDN_RADIO_SYMBOL_LENGTH = 5U; // At 24 kHz sample rate const unsigned int NXDN_RADIO_SYMBOL_LENGTH = 5U; // At 24 kHz sample rate
const unsigned int NXDN_FRAME_LENGTH_BYTES = 120U; const unsigned int NXDN_FRAME_LENGTH_BITS = 384U;
const unsigned int NXDN_FRAME_LENGTH_BITS = NXDN_FRAME_LENGTH_BYTES * 8U; const unsigned int NXDN_FRAME_LENGTH_BYTES = NXDN_FRAME_LENGTH_BITS / 8U;
const unsigned int NXDN_FRAME_LENGTH_SYMBOLS = NXDN_FRAME_LENGTH_BYTES * 4U; const unsigned int NXDN_FRAME_LENGTH_SYMBOLS = NXDN_FRAME_LENGTH_BITS / 2U;
const unsigned int NXDN_FRAME_LENGTH_SAMPLES = NXDN_FRAME_LENGTH_SYMBOLS * NXDN_RADIO_SYMBOL_LENGTH; const unsigned int NXDN_FRAME_LENGTH_SAMPLES = NXDN_FRAME_LENGTH_SYMBOLS * NXDN_RADIO_SYMBOL_LENGTH;
const unsigned int NXDN_SYNC_LENGTH_BYTES = 5U; const unsigned int NXDN_FSW_LENGTH_BITS = 20U;
const unsigned int NXDN_SYNC_LENGTH_BITS = NXDN_SYNC_LENGTH_BYTES * 8U; const unsigned int NXDN_FSW_LENGTH_SYMBOLS = NXDN_FSW_LENGTH_BITS / 2U;
const unsigned int NXDN_SYNC_LENGTH_SYMBOLS = NXDN_SYNC_LENGTH_BYTES * 4U; const unsigned int NXDN_FSW_LENGTH_SAMPLES = NXDN_FSW_LENGTH_SYMBOLS * NXDN_RADIO_SYMBOL_LENGTH;
const unsigned int NXDN_SYNC_LENGTH_SAMPLES = NXDN_SYNC_LENGTH_SYMBOLS * NXDN_RADIO_SYMBOL_LENGTH;
const unsigned int NXDN_FICH_LENGTH_BITS = 200U; const uint8_t NXDN_FSW_BYTES[] = {0x0CU, 0xDFU, 0x59U};
const unsigned int NXDN_FICH_LENGTH_SYMBOLS = 100U; const uint8_t NXDN_FSW_BYTES_MASK[] = {0x0FU, 0xFFU, 0xFFU};
const unsigned int NXDN_FICH_LENGTH_SAMPLES = NXDN_FICH_LENGTH_SYMBOLS * NXDN_RADIO_SYMBOL_LENGTH; const uint8_t NXDN_FSW_BYTES_LENGTH = 3U;
const uint8_t NXDN_SYNC_BYTES[] = {0xD4U, 0x71U, 0xC9U, 0x63U, 0x4DU}; const uint32_t NXDN_FSW_BITS = 0x000CDF59U;
const uint8_t NXDN_SYNC_BYTES_LENGTH = 5U; const uint32_t NXDN_FSW_BITS_MASK = 0x000FFFFFU;
const uint64_t NXDN_SYNC_BITS = 0x000000D471C9634DU; // C D F 5 9
const uint64_t NXDN_SYNC_BITS_MASK = 0x000000FFFFFFFFFFU; // 11 00 11 01 11 11 01 01 10 01
// -3 +1 -3 +3 -3 -3 +3 +3 -1 +3
// D 4 7 1 C 9 6 3 4 D const int8_t NXDN_FSW_SYMBOLS_VALUES[] = {-3, +1, -3, +3, -3, -3, +3, +3, -1, +3};
// 11 01 01 00 01 11 00 01 11 00 10 01 01 10 00 11 01 00 11 01
// -3 +3 +3 +1 +3 -3 +1 +3 -3 +1 -1 +3 +3 -1 +3 -3 +3 +1 -3 +3
const int8_t NXDN_SYNC_SYMBOLS_VALUES[] = {-3, +3, +3, +1, +3, -3, +1, +3, -3, +1, -1, +3, +3, -1, +3, -3, +3, +1, -3, +3}; const uint16_t NXDN_FSW_SYMBOLS = 0x014DU;
const uint16_t NXDN_FSW_SYMBOLS_MASK = 0x03FFU;
const uint32_t NXDN_SYNC_SYMBOLS = 0x0007B5ADU;
const uint32_t NXDN_SYNC_SYMBOLS_MASK = 0x000FFFFFU;
#endif #endif

92
NXDNRX.cpp
View File

@ -23,10 +23,10 @@
const q15_t SCALING_FACTOR = 18750; // Q15(0.55) const q15_t SCALING_FACTOR = 18750; // Q15(0.55)
const uint8_t MAX_SYNC_BIT_START_ERRS = 2U; const uint8_t MAX_FSW_BIT_START_ERRS = 2U;
const uint8_t MAX_SYNC_BIT_RUN_ERRS = 4U; const uint8_t MAX_FSW_BIT_RUN_ERRS = 4U;
const uint8_t MAX_SYNC_SYMBOLS_ERRS = 3U; const uint8_t MAX_FSW_SYMBOLS_ERRS = 3U;
const uint8_t BIT_MASK_TABLE[] = {0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02U, 0x01U}; const uint8_t BIT_MASK_TABLE[] = {0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02U, 0x01U};
@ -36,7 +36,7 @@ const uint8_t NOAVEPTR = 99U;
const uint16_t NOENDPTR = 9999U; const uint16_t NOENDPTR = 9999U;
const unsigned int MAX_SYNC_FRAMES = 4U + 1U; const unsigned int MAX_FSW_FRAMES = 4U + 1U;
CNXDNRX::CNXDNRX() : CNXDNRX::CNXDNRX() :
m_state(NXDNRXS_NONE), m_state(NXDNRXS_NONE),
@ -46,9 +46,9 @@ m_bitPtr(0U),
m_dataPtr(0U), m_dataPtr(0U),
m_startPtr(NOENDPTR), m_startPtr(NOENDPTR),
m_endPtr(NOENDPTR), m_endPtr(NOENDPTR),
m_syncPtr(NOENDPTR), m_fswPtr(NOENDPTR),
m_minSyncPtr(NOENDPTR), m_minFSWPtr(NOENDPTR),
m_maxSyncPtr(NOENDPTR), m_maxFSWPtr(NOENDPTR),
m_maxCorr(0), m_maxCorr(0),
m_lostCount(0U), m_lostCount(0U),
m_countdown(0U), m_countdown(0U),
@ -71,9 +71,9 @@ void CNXDNRX::reset()
m_averagePtr = NOAVEPTR; m_averagePtr = NOAVEPTR;
m_startPtr = NOENDPTR; m_startPtr = NOENDPTR;
m_endPtr = NOENDPTR; m_endPtr = NOENDPTR;
m_syncPtr = NOENDPTR; m_fswPtr = NOENDPTR;
m_minSyncPtr = NOENDPTR; m_minFSWPtr = NOENDPTR;
m_maxSyncPtr = NOENDPTR; m_maxFSWPtr = NOENDPTR;
m_centreVal = 0; m_centreVal = 0;
m_thresholdVal = 0; m_thresholdVal = 0;
m_lostCount = 0U; m_lostCount = 0U;
@ -117,7 +117,7 @@ void CNXDNRX::samples(const q15_t* samples, uint16_t* rssi, uint8_t length)
void CNXDNRX::processNone(q15_t sample) void CNXDNRX::processNone(q15_t sample)
{ {
bool ret = correlateSync(); bool ret = correlateFSW();
if (ret) { if (ret) {
// On the first sync, start the countdown to the state change // On the first sync, start the countdown to the state change
if (m_countdown == 0U) { if (m_countdown == 0U) {
@ -137,13 +137,13 @@ void CNXDNRX::processNone(q15_t sample)
m_countdown--; m_countdown--;
if (m_countdown == 1U) { if (m_countdown == 1U) {
m_minSyncPtr = m_syncPtr + NXDN_FRAME_LENGTH_SAMPLES - 1U; m_minFSWPtr = m_fswPtr + NXDN_FRAME_LENGTH_SAMPLES - 1U;
if (m_minSyncPtr >= NXDN_FRAME_LENGTH_SAMPLES) if (m_minFSWPtr >= NXDN_FRAME_LENGTH_SAMPLES)
m_minSyncPtr -= NXDN_FRAME_LENGTH_SAMPLES; m_minFSWPtr -= NXDN_FRAME_LENGTH_SAMPLES;
m_maxSyncPtr = m_syncPtr + 1U; m_maxFSWPtr = m_fswPtr + 1U;
if (m_maxSyncPtr >= NXDN_FRAME_LENGTH_SAMPLES) if (m_maxFSWPtr >= NXDN_FRAME_LENGTH_SAMPLES)
m_maxSyncPtr -= NXDN_FRAME_LENGTH_SAMPLES; m_maxFSWPtr -= NXDN_FRAME_LENGTH_SAMPLES;
m_state = NXDNRXS_DATA; m_state = NXDNRXS_DATA;
m_countdown = 0U; m_countdown = 0U;
@ -152,29 +152,29 @@ void CNXDNRX::processNone(q15_t sample)
void CNXDNRX::processData(q15_t sample) void CNXDNRX::processData(q15_t sample)
{ {
if (m_minSyncPtr < m_maxSyncPtr) { if (m_minFSWPtr < m_maxFSWPtr) {
if (m_dataPtr >= m_minSyncPtr && m_dataPtr <= m_maxSyncPtr) if (m_dataPtr >= m_minFSWPtr && m_dataPtr <= m_maxFSWPtr)
correlateSync(); correlateFSW();
} else { } else {
if (m_dataPtr >= m_minSyncPtr || m_dataPtr <= m_maxSyncPtr) if (m_dataPtr >= m_minFSWPtr || m_dataPtr <= m_maxFSWPtr)
correlateSync(); correlateFSW();
} }
if (m_dataPtr == m_endPtr) { if (m_dataPtr == m_endPtr) {
// Only update the centre and threshold if they are from a good sync // Only update the centre and threshold if they are from a good sync
if (m_lostCount == MAX_SYNC_FRAMES) { if (m_lostCount == MAX_FSW_FRAMES) {
m_minSyncPtr = m_syncPtr + NXDN_FRAME_LENGTH_SAMPLES - 1U; m_minFSWPtr = m_fswPtr + NXDN_FRAME_LENGTH_SAMPLES - 1U;
if (m_minSyncPtr >= NXDN_FRAME_LENGTH_SAMPLES) if (m_minFSWPtr >= NXDN_FRAME_LENGTH_SAMPLES)
m_minSyncPtr -= NXDN_FRAME_LENGTH_SAMPLES; m_minFSWPtr -= NXDN_FRAME_LENGTH_SAMPLES;
m_maxSyncPtr = m_syncPtr + 1U; m_maxFSWPtr = m_fswPtr + 1U;
if (m_maxSyncPtr >= NXDN_FRAME_LENGTH_SAMPLES) if (m_maxFSWPtr >= NXDN_FRAME_LENGTH_SAMPLES)
m_maxSyncPtr -= NXDN_FRAME_LENGTH_SAMPLES; m_maxFSWPtr -= NXDN_FRAME_LENGTH_SAMPLES;
} }
calculateLevels(m_startPtr, NXDN_FRAME_LENGTH_SYMBOLS); calculateLevels(m_startPtr, NXDN_FRAME_LENGTH_SYMBOLS);
DEBUG4("NXDNRX: sync found pos/centre/threshold", m_syncPtr, m_centreVal, m_thresholdVal); DEBUG4("NXDNRX: sync found pos/centre/threshold", m_fswPtr, m_centreVal, m_thresholdVal);
uint8_t frame[NXDN_FRAME_LENGTH_BYTES + 3U]; uint8_t frame[NXDN_FRAME_LENGTH_BYTES + 3U];
samplesToBits(m_startPtr, NXDN_FRAME_LENGTH_SYMBOLS, frame, 8U, m_centreVal, m_thresholdVal); samplesToBits(m_startPtr, NXDN_FRAME_LENGTH_SYMBOLS, frame, 8U, m_centreVal, m_thresholdVal);
@ -195,17 +195,17 @@ void CNXDNRX::processData(q15_t sample)
m_countdown = 0U; m_countdown = 0U;
m_maxCorr = 0; m_maxCorr = 0;
} else { } else {
frame[0U] = m_lostCount == (MAX_SYNC_FRAMES - 1U) ? 0x01U : 0x00U; frame[0U] = m_lostCount == (MAX_FSW_FRAMES - 1U) ? 0x01U : 0x00U;
writeRSSIData(frame); writeRSSIData(frame);
m_maxCorr = 0; m_maxCorr = 0;
} }
} }
} }
bool CNXDNRX::correlateSync() bool CNXDNRX::correlateFSW()
{ {
if (countBits32((m_bitBuffer[m_bitPtr] & NXDN_SYNC_SYMBOLS_MASK) ^ NXDN_SYNC_SYMBOLS) <= MAX_SYNC_SYMBOLS_ERRS) { if (countBits32((m_bitBuffer[m_bitPtr] & NXDN_FSW_SYMBOLS_MASK) ^ NXDN_FSW_SYMBOLS) <= MAX_FSW_SYMBOLS_ERRS) {
uint16_t ptr = m_dataPtr + NXDN_FRAME_LENGTH_SAMPLES - NXDN_SYNC_LENGTH_SAMPLES + NXDN_RADIO_SYMBOL_LENGTH; uint16_t ptr = m_dataPtr + NXDN_FRAME_LENGTH_SAMPLES - NXDN_FSW_LENGTH_SAMPLES + NXDN_RADIO_SYMBOL_LENGTH;
if (ptr >= NXDN_FRAME_LENGTH_SAMPLES) if (ptr >= NXDN_FRAME_LENGTH_SAMPLES)
ptr -= NXDN_FRAME_LENGTH_SAMPLES; ptr -= NXDN_FRAME_LENGTH_SAMPLES;
@ -213,7 +213,7 @@ bool CNXDNRX::correlateSync()
q15_t min = 16000; q15_t min = 16000;
q15_t max = -16000; q15_t max = -16000;
for (uint8_t i = 0U; i < NXDN_SYNC_LENGTH_SYMBOLS; i++) { for (uint8_t i = 0U; i < NXDN_FSW_LENGTH_SYMBOLS; i++) {
q15_t val = m_buffer[ptr]; q15_t val = m_buffer[ptr];
if (val > max) if (val > max)
@ -221,7 +221,7 @@ bool CNXDNRX::correlateSync()
if (val < min) if (val < min)
min = val; min = val;
switch (NXDN_SYNC_SYMBOLS_VALUES[i]) { switch (NXDN_FSW_SYMBOLS_VALUES[i]) {
case +3: case +3:
corr -= (val + val + val); corr -= (val + val + val);
break; break;
@ -249,31 +249,31 @@ bool CNXDNRX::correlateSync()
m_thresholdVal = q15_t(v1 >> 15); m_thresholdVal = q15_t(v1 >> 15);
} }
uint16_t startPtr = m_dataPtr + NXDN_FRAME_LENGTH_SAMPLES - NXDN_SYNC_LENGTH_SAMPLES + NXDN_RADIO_SYMBOL_LENGTH; uint16_t startPtr = m_dataPtr + NXDN_FRAME_LENGTH_SAMPLES - NXDN_FSW_LENGTH_SAMPLES + NXDN_RADIO_SYMBOL_LENGTH;
if (startPtr >= NXDN_FRAME_LENGTH_SAMPLES) if (startPtr >= NXDN_FRAME_LENGTH_SAMPLES)
startPtr -= NXDN_FRAME_LENGTH_SAMPLES; startPtr -= NXDN_FRAME_LENGTH_SAMPLES;
uint8_t sync[NXDN_SYNC_BYTES_LENGTH]; uint8_t sync[NXDN_FSW_BYTES_LENGTH];
samplesToBits(startPtr, NXDN_SYNC_LENGTH_SYMBOLS, sync, 0U, m_centreVal, m_thresholdVal); samplesToBits(startPtr, NXDN_FSW_LENGTH_SYMBOLS, sync, 0U, m_centreVal, m_thresholdVal);
uint8_t maxErrs; uint8_t maxErrs;
if (m_state == NXDNRXS_NONE) if (m_state == NXDNRXS_NONE)
maxErrs = MAX_SYNC_BIT_START_ERRS; maxErrs = MAX_FSW_BIT_START_ERRS;
else else
maxErrs = MAX_SYNC_BIT_RUN_ERRS; maxErrs = MAX_FSW_BIT_RUN_ERRS;
uint8_t errs = 0U; uint8_t errs = 0U;
for (uint8_t i = 0U; i < NXDN_SYNC_BYTES_LENGTH; i++) for (uint8_t i = 0U; i < NXDN_FSW_BYTES_LENGTH; i++)
errs += countBits8(sync[i] ^ NXDN_SYNC_BYTES[i]); errs += countBits8((sync[i] & NXDN_FSW_BYTES_MASK[i]) ^ NXDN_FSW_BYTES[i]);
if (errs <= maxErrs) { if (errs <= maxErrs) {
m_maxCorr = corr; m_maxCorr = corr;
m_lostCount = MAX_SYNC_FRAMES; m_lostCount = MAX_FSW_FRAMES;
m_syncPtr = m_dataPtr; m_fswPtr = m_dataPtr;
m_startPtr = startPtr; m_startPtr = startPtr;
m_endPtr = m_dataPtr + NXDN_FRAME_LENGTH_SAMPLES - NXDN_SYNC_LENGTH_SAMPLES - 1U; m_endPtr = m_dataPtr + NXDN_FRAME_LENGTH_SAMPLES - NXDN_FSW_LENGTH_SAMPLES - 1U;
if (m_endPtr >= NXDN_FRAME_LENGTH_SAMPLES) if (m_endPtr >= NXDN_FRAME_LENGTH_SAMPLES)
m_endPtr -= NXDN_FRAME_LENGTH_SAMPLES; m_endPtr -= NXDN_FRAME_LENGTH_SAMPLES;

10
NXDNRX.h
View File

@ -37,15 +37,15 @@ public:
private: private:
NXDNRX_STATE m_state; NXDNRX_STATE m_state;
uint32_t m_bitBuffer[NXDN_RADIO_SYMBOL_LENGTH]; uint16_t m_bitBuffer[NXDN_RADIO_SYMBOL_LENGTH];
q15_t m_buffer[NXDN_FRAME_LENGTH_SAMPLES]; q15_t m_buffer[NXDN_FRAME_LENGTH_SAMPLES];
uint16_t m_bitPtr; uint16_t m_bitPtr;
uint16_t m_dataPtr; uint16_t m_dataPtr;
uint16_t m_startPtr; uint16_t m_startPtr;
uint16_t m_endPtr; uint16_t m_endPtr;
uint16_t m_syncPtr; uint16_t m_fswPtr;
uint16_t m_minSyncPtr; uint16_t m_minFSWPtr;
uint16_t m_maxSyncPtr; uint16_t m_maxFSWPtr;
q31_t m_maxCorr; q31_t m_maxCorr;
uint16_t m_lostCount; uint16_t m_lostCount;
uint8_t m_countdown; uint8_t m_countdown;
@ -59,7 +59,7 @@ private:
void processNone(q15_t sample); void processNone(q15_t sample);
void processData(q15_t sample); void processData(q15_t sample);
bool correlateSync(); bool correlateFSW();
void calculateLevels(uint16_t start, uint16_t count); void calculateLevels(uint16_t start, uint16_t count);
void samplesToBits(uint16_t start, uint16_t count, uint8_t* buffer, uint16_t offset, q15_t centre, q15_t threshold); void samplesToBits(uint16_t start, uint16_t count, uint8_t* buffer, uint16_t offset, q15_t centre, q15_t threshold);
void writeRSSIData(uint8_t* data); void writeRSSIData(uint8_t* data);

8
NXDNTX.cpp
View File

@ -29,10 +29,10 @@ static q15_t RRC_0_2_FILTER[] = {0, 0, 0, 0, 850, 219, -720, -1548, -1795, -1172
-4544, -1431, 1447, 3073, 3120, 1927, 237, -1172, -1795, -1548, -720, 219, 850}; // numTaps = 45, L = 5 -4544, -1431, 1447, 3073, 3120, 1927, 237, -1172, -1795, -1548, -720, 219, 850}; // numTaps = 45, L = 5
const uint16_t RRC_0_2_FILTER_PHASE_LEN = 9U; // phaseLength = numTaps/L const uint16_t RRC_0_2_FILTER_PHASE_LEN = 9U; // phaseLength = numTaps/L
const q15_t NXDN_LEVELA = 1893; const q15_t NXDN_LEVELA = 1683;
const q15_t NXDN_LEVELB = 631; const q15_t NXDN_LEVELB = 561;
const q15_t NXDN_LEVELC = -631; const q15_t NXDN_LEVELC = -561;
const q15_t NXDN_LEVELD = -1893; const q15_t NXDN_LEVELD = -1683;
const uint8_t NXDN_START_SYNC = 0x77U; const uint8_t NXDN_START_SYNC = 0x77U;
const uint8_t NXDN_END_SYNC = 0xFFU; const uint8_t NXDN_END_SYNC = 0xFFU;