KB8PMY
/
MMDVM_HS
mirror of https://github.com/juribeparada/MMDVM_HS.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Preliminary support for simultaneous two slot RX in DMR duplex mode

Browse Source
pull/27/head
Andy CA6JAU 8 years ago
parent 8be501eec4
commit 24990dde39
3 changed files with 315 additions and 117 deletions
Show Stats Download Patch File Download Diff File

387
DMRSlotRX.cpp
Unescape View File

@ -41,17 +41,25 @@ m_slot(false),
m_patternBuffer(0x00U), m_patternBuffer(0x00U),
m_buffer(), m_buffer(),
m_dataPtr(0U), m_dataPtr(0U),
m_syncPtr(0U), m_syncPtr1(0U),
m_startPtr(0U), m_startPtr1(0U),
m_endPtr(NOENDPTR), m_endPtr1(NOENDPTR),
m_control1(CONTROL_NONE),
m_syncCount1(0U),
m_state1(DMRRXS_NONE),
m_n1(0U),
m_type1(0U),
m_syncPtr2(0U),
m_startPtr2(0U),
m_endPtr2(NOENDPTR),
m_control2(CONTROL_NONE),
m_syncCount2(0U),
m_state2(DMRRXS_NONE),
m_n2(0U),
m_type2(0U),
m_delayPtr(0U), m_delayPtr(0U),
m_control(CONTROL_NONE),
m_syncCount(0U),
m_colorCode(0U), m_colorCode(0U),
m_delay(0U), m_delay(0U)
m_state(DMRRXS_NONE),
m_n(0U),
m_type(0U)
{ {
} }
@ -63,22 +71,38 @@ void CDMRSlotRX::start(bool slot)
void CDMRSlotRX::reset() void CDMRSlotRX::reset()
{ {
m_syncPtr = 0U;
m_dataPtr = 0U; m_dataPtr = 0U;
m_delayPtr = 0U; m_delayPtr = 0U;
m_control = CONTROL_NONE;
m_syncCount = 0U;
m_state = DMRRXS_NONE;
m_startPtr = 0U;
m_patternBuffer = 0U; m_patternBuffer = 0U;
m_endPtr = NOENDPTR;
m_syncPtr1 = 0U;
m_control1 = CONTROL_NONE;
m_syncCount1 = 0U;
m_state1 = DMRRXS_NONE;
m_startPtr1 = 0U;
m_endPtr1 = NOENDPTR;
m_type1 = 0U;
m_n1 = 0U;
m_syncPtr2 = 0U;
m_control2 = CONTROL_NONE;
m_syncCount2 = 0U;
m_state2 = DMRRXS_NONE;
m_startPtr2 = 0U;
m_endPtr2 = NOENDPTR;
m_type2 = 0U;
m_n2 = 0U;
} }
bool CDMRSlotRX::databit(bool bit) bool CDMRSlotRX::databit(bool bit)
{ {
uint16_t min;
uint16_t max;
m_delayPtr++; m_delayPtr++;
if (m_delayPtr < m_delay) if (m_delayPtr < m_delay)
return m_state != DMRRXS_NONE; return (m_state1 != DMRRXS_NONE) || (m_state2 != DMRRXS_NONE);
m_buffer[m_dataPtr] = bit; m_buffer[m_dataPtr] = bit;
@ -86,12 +110,16 @@ bool CDMRSlotRX::databit(bool bit)
if (bit) if (bit)
m_patternBuffer |= 0x01U; m_patternBuffer |= 0x01U;
if (m_state == DMRRXS_NONE) { if (m_state1 == DMRRXS_NONE || m_state2 == DMRRXS_NONE) {
correlateSync(); correlateSync();
} else { } else {
if(m_slot) {
uint16_t min = m_syncPtr + DMR_BUFFER_LENGTH_BITS - 2; min = m_syncPtr2 + DMR_BUFFER_LENGTH_BITS - 2;
uint16_t max = m_syncPtr + 2; max = m_syncPtr2 + 2;
} else {
min = m_syncPtr1 + DMR_BUFFER_LENGTH_BITS - 2;
max = m_syncPtr1 + 2;
}
if (min >= DMR_BUFFER_LENGTH_BITS) if (min >= DMR_BUFFER_LENGTH_BITS)
min -= DMR_BUFFER_LENGTH_BITS; min -= DMR_BUFFER_LENGTH_BITS;
@ -107,144 +135,285 @@ bool CDMRSlotRX::databit(bool bit)
} }
} }
if (m_dataPtr == m_endPtr) { if(m_slot)
frame[0U] = m_control; procSlot2();
else
procSlot1();
m_dataPtr++;
if (m_dataPtr >= DMR_BUFFER_LENGTH_BITS)
m_dataPtr = 0U;
return (m_state1 != DMRRXS_NONE) || (m_state2 != DMRRXS_NONE);;
}
void CDMRSlotRX::procSlot1()
{
if (m_dataPtr == m_endPtr1) {
frame1[0U] = m_control1;
bitsToBytes(m_startPtr, DMR_FRAME_LENGTH_BYTES, frame + 1U); bitsToBytes(m_startPtr1, DMR_FRAME_LENGTH_BYTES, frame1 + 1U);
if (m_control == CONTROL_DATA) { if (m_control1 == CONTROL_DATA) {
// Data sync // Data sync
uint8_t colorCode; uint8_t colorCode;
uint8_t dataType; uint8_t dataType;
CDMRSlotType slotType; CDMRSlotType slotType;
slotType.decode(frame + 1U, colorCode, dataType); slotType.decode(frame1 + 1U, colorCode, dataType);
if (colorCode == m_colorCode) { if (colorCode == m_colorCode) {
m_syncCount = 0U; m_syncCount1 = 0U;
m_n = 0U; m_n1 = 0U;
frame[0U] |= dataType; frame1[0U] |= dataType;
switch (dataType) { switch (dataType) {
case DT_DATA_HEADER: case DT_DATA_HEADER:
DEBUG3("DMRSlotRX: data header found slot/pos", m_slot ? 2U : 1U, m_syncPtr); DEBUG2("DMRSlot1RX: data header found pos", m_syncPtr1);
writeRSSIData(frame); writeRSSIData1();
m_state = DMRRXS_DATA; m_state1 = DMRRXS_DATA;
m_type = 0x00U; m_type1 = 0x00U;
break; break;
case DT_RATE_12_DATA: case DT_RATE_12_DATA:
case DT_RATE_34_DATA: case DT_RATE_34_DATA:
case DT_RATE_1_DATA: case DT_RATE_1_DATA:
if (m_state == DMRRXS_DATA) { if (m_state1 == DMRRXS_DATA) {
DEBUG3("DMRSlotRX: data payload found slot/pos", m_slot ? 2U : 1U, m_syncPtr); DEBUG2("DMRSlot1RX: data payload found pos", m_syncPtr1);
writeRSSIData(frame); writeRSSIData1();
m_type = dataType; m_type1 = dataType;
} }
break; break;
case DT_VOICE_LC_HEADER: case DT_VOICE_LC_HEADER:
DEBUG3("DMRSlotRX: voice header found slot/pos", m_slot ? 2U : 1U, m_syncPtr); DEBUG2("DMRSlot1RX: voice header found pos", m_syncPtr1);
writeRSSIData(frame); writeRSSIData1();
m_state = DMRRXS_VOICE; m_state1 = DMRRXS_VOICE;
break; break;
case DT_VOICE_PI_HEADER: case DT_VOICE_PI_HEADER:
if (m_state == DMRRXS_VOICE) { if (m_state1 == DMRRXS_VOICE) {
DEBUG3("DMRSlotRX: voice pi header found slot/pos", m_slot ? 2U : 1U, m_syncPtr); DEBUG2("DMRSlot1RX: voice pi header found pos", m_syncPtr1);
writeRSSIData(frame); writeRSSIData1();
} }
m_state = DMRRXS_VOICE; m_state1 = DMRRXS_VOICE;
break; break;
case DT_TERMINATOR_WITH_LC: case DT_TERMINATOR_WITH_LC:
if (m_state == DMRRXS_VOICE) { if (m_state1 == DMRRXS_VOICE) {
DEBUG3("DMRSlotRX: voice terminator found slot/pos", m_slot ? 2U : 1U, m_syncPtr); DEBUG2("DMRSlot1RX: voice terminator found pos", m_syncPtr1);
writeRSSIData(frame); writeRSSIData1();
m_state = DMRRXS_NONE; m_state1 = DMRRXS_NONE;
m_endPtr = NOENDPTR; m_endPtr1 = NOENDPTR;
} }
break; break;
default: // DT_CSBK default: // DT_CSBK
DEBUG3("DMRSlotRX: csbk found slot/pos", m_slot ? 2U : 1U, m_syncPtr); DEBUG2("DMRSlot1RX: csbk found pos", m_syncPtr1);
writeRSSIData(frame); writeRSSIData1();
m_state = DMRRXS_NONE; m_state1 = DMRRXS_NONE;
m_endPtr = NOENDPTR; m_endPtr1 = NOENDPTR;
break; break;
} }
} }
} else if (m_control == CONTROL_VOICE) { } else if (m_control1 == CONTROL_VOICE) {
// Voice sync // Voice sync
DEBUG3("DMRSlotRX: voice sync found slot/pos", m_slot ? 2U : 1U, m_syncPtr); DEBUG2("DMRSlot1RX: voice sync found pos", m_syncPtr1);
writeRSSIData(frame); writeRSSIData1();
m_state = DMRRXS_VOICE; m_state1 = DMRRXS_VOICE;
m_syncCount = 0U; m_syncCount1 = 0U;
m_n = 0U; m_n1 = 0U;
} else { } else {
if (m_state != DMRRXS_NONE) { if (m_state1 != DMRRXS_NONE) {
m_syncCount++; m_syncCount1++;
if (m_syncCount >= MAX_SYNC_LOST_FRAMES) { if (m_syncCount1 >= MAX_SYNC_LOST_FRAMES) {
serial.writeDMRLost(m_slot); serial.writeDMRLost(0U);
m_state = DMRRXS_NONE; m_state1 = DMRRXS_NONE;
m_endPtr = NOENDPTR; m_endPtr1 = NOENDPTR;
} }
} }
if (m_state == DMRRXS_VOICE) { if (m_state1 == DMRRXS_VOICE) {
if (m_n >= 5U) { if (m_n1 >= 5U) {
frame[0U] = CONTROL_VOICE; frame1[0U] = CONTROL_VOICE;
m_n = 0U; m_n1 = 0U;
} else { } else {
frame[0U] = ++m_n; frame1[0U] = ++m_n1;
} }
serial.writeDMRData(m_slot, frame, DMR_FRAME_LENGTH_BYTES + 1U); serial.writeDMRData(0U, frame1, DMR_FRAME_LENGTH_BYTES + 1U);
} else if (m_state == DMRRXS_DATA) { } else if (m_state1 == DMRRXS_DATA) {
if (m_type != 0x00U) { if (m_type1 != 0x00U) {
frame[0U] = CONTROL_DATA | m_type; frame1[0U] = CONTROL_DATA | m_type1;
writeRSSIData(frame); writeRSSIData1();
} }
} }
} }
// End of this slot, reset some items for the next slot. // End of this slot, reset some items for the next slot.
m_control = CONTROL_NONE; m_control1 = CONTROL_NONE;
}
} }
m_dataPtr++; void CDMRSlotRX::procSlot2()
{
if (m_dataPtr == m_endPtr2) {
frame2[0U] = m_control2;
if (m_dataPtr >= DMR_BUFFER_LENGTH_BITS) bitsToBytes(m_startPtr2, DMR_FRAME_LENGTH_BYTES, frame2 + 1U);
m_dataPtr = 0U;
if (m_control2 == CONTROL_DATA) {
// Data sync
uint8_t colorCode;
uint8_t dataType;
CDMRSlotType slotType;
slotType.decode(frame2 + 1U, colorCode, dataType);
if (colorCode == m_colorCode) {
m_syncCount2 = 0U;
m_n2 = 0U;
frame2[0U] |= dataType;
switch (dataType) {
case DT_DATA_HEADER:
DEBUG2("DMRSlot2RX: data header found pos", m_syncPtr2);
writeRSSIData2();
m_state2 = DMRRXS_DATA;
m_type2 = 0x00U;
break;
case DT_RATE_12_DATA:
case DT_RATE_34_DATA:
case DT_RATE_1_DATA:
if (m_state2 == DMRRXS_DATA) {
DEBUG2("DMRSlot2RX: data payload found pos", m_syncPtr2);
writeRSSIData2();
m_type2 = dataType;
}
break;
case DT_VOICE_LC_HEADER:
DEBUG2("DMRSlot2RX: voice header found pos", m_syncPtr2);
writeRSSIData2();
m_state2 = DMRRXS_VOICE;
break;
case DT_VOICE_PI_HEADER:
if (m_state2 == DMRRXS_VOICE) {
DEBUG2("DMRSlot2RX: voice pi header found pos", m_syncPtr2);
writeRSSIData2();
}
m_state2 = DMRRXS_VOICE;
break;
case DT_TERMINATOR_WITH_LC:
if (m_state2 == DMRRXS_VOICE) {
DEBUG2("DMRSlot2RX: voice terminator found pos", m_syncPtr2);
writeRSSIData2();
m_state2 = DMRRXS_NONE;
m_endPtr2 = NOENDPTR;
}
break;
default: // DT_CSBK
DEBUG2("DMRSlot2RX: csbk found pos", m_syncPtr2);
writeRSSIData2();
m_state2 = DMRRXS_NONE;
m_endPtr2 = NOENDPTR;
break;
}
}
} else if (m_control2 == CONTROL_VOICE) {
// Voice sync
DEBUG2("DMRSlot2RX: voice sync found pos", m_syncPtr2);
writeRSSIData2();
m_state2 = DMRRXS_VOICE;
m_syncCount2 = 0U;
m_n2 = 0U;
} else {
if (m_state2 != DMRRXS_NONE) {
m_syncCount2++;
if (m_syncCount2 >= MAX_SYNC_LOST_FRAMES) {
serial.writeDMRLost(1U);
m_state2 = DMRRXS_NONE;
m_endPtr2 = NOENDPTR;
}
}
if (m_state2 == DMRRXS_VOICE) {
if (m_n2 >= 5U) {
frame2[0U] = CONTROL_VOICE;
m_n2 = 0U;
} else {
frame2[0U] = ++m_n2;
}
return m_state != DMRRXS_NONE; serial.writeDMRData(1U, frame2, DMR_FRAME_LENGTH_BYTES + 1U);
} else if (m_state2 == DMRRXS_DATA) {
if (m_type2 != 0x00U) {
frame2[0U] = CONTROL_DATA | m_type2;
writeRSSIData2();
}
}
}
// End of this slot, reset some items for the next slot.
m_control2 = CONTROL_NONE;
}
} }
void CDMRSlotRX::correlateSync() void CDMRSlotRX::correlateSync()
{ {
uint16_t syncPtr;
uint16_t startPtr;
uint16_t endPtr;
uint8_t control;
if (countBits64((m_patternBuffer & DMR_SYNC_BITS_MASK) ^ DMR_MS_DATA_SYNC_BITS) <= MAX_SYNC_BYTES_ERRS) { if (countBits64((m_patternBuffer & DMR_SYNC_BITS_MASK) ^ DMR_MS_DATA_SYNC_BITS) <= MAX_SYNC_BYTES_ERRS) {
m_control = CONTROL_DATA; control = CONTROL_DATA;
m_syncPtr = m_dataPtr; syncPtr = m_dataPtr;
m_startPtr = m_dataPtr + DMR_BUFFER_LENGTH_BITS - DMR_SLOT_TYPE_LENGTH_BITS / 2U - DMR_INFO_LENGTH_BITS / 2U - DMR_SYNC_LENGTH_BITS + 1; startPtr = m_dataPtr + DMR_BUFFER_LENGTH_BITS - DMR_SLOT_TYPE_LENGTH_BITS / 2U - DMR_INFO_LENGTH_BITS / 2U - DMR_SYNC_LENGTH_BITS + 1;
if (m_startPtr >= DMR_BUFFER_LENGTH_BITS) if (startPtr >= DMR_BUFFER_LENGTH_BITS)
m_startPtr -= DMR_BUFFER_LENGTH_BITS; startPtr -= DMR_BUFFER_LENGTH_BITS;
m_endPtr = m_dataPtr + DMR_SLOT_TYPE_LENGTH_BITS / 2U + DMR_INFO_LENGTH_BITS / 2U; endPtr = m_dataPtr + DMR_SLOT_TYPE_LENGTH_BITS / 2U + DMR_INFO_LENGTH_BITS / 2U;
if (m_endPtr >= DMR_BUFFER_LENGTH_BITS) if (endPtr >= DMR_BUFFER_LENGTH_BITS)
m_endPtr -= DMR_BUFFER_LENGTH_BITS; endPtr -= DMR_BUFFER_LENGTH_BITS;
if(m_slot) {
m_syncPtr2 = syncPtr;
m_startPtr2 = startPtr;
m_endPtr2 = endPtr;
m_control2 = control;
} else {
m_syncPtr1 = syncPtr;
m_startPtr1 = startPtr;
m_endPtr1 = endPtr;
m_control1 = control;
}
//DEBUG4("SYNC corr MS Data found pos/start/end:", m_dataPtr, m_startPtr, m_endPtr); //DEBUG5("SYNC corr MS Data found slot/pos/start/end:", m_slot ? 2U : 1U, m_dataPtr, startPtr, endPtr);
} else if (countBits64((m_patternBuffer & DMR_SYNC_BITS_MASK) ^ DMR_MS_VOICE_SYNC_BITS) <= MAX_SYNC_BYTES_ERRS) { } else if (countBits64((m_patternBuffer & DMR_SYNC_BITS_MASK) ^ DMR_MS_VOICE_SYNC_BITS) <= MAX_SYNC_BYTES_ERRS) {
m_control = CONTROL_VOICE; control = CONTROL_VOICE;
m_syncPtr = m_dataPtr; syncPtr = m_dataPtr;
m_startPtr = m_dataPtr + DMR_BUFFER_LENGTH_BITS - DMR_SLOT_TYPE_LENGTH_BITS / 2U - DMR_INFO_LENGTH_BITS / 2U - DMR_SYNC_LENGTH_BITS + 1;
if (m_startPtr >= DMR_BUFFER_LENGTH_BITS) startPtr = m_dataPtr + DMR_BUFFER_LENGTH_BITS - DMR_SLOT_TYPE_LENGTH_BITS / 2U - DMR_INFO_LENGTH_BITS / 2U - DMR_SYNC_LENGTH_BITS + 1;
m_startPtr -= DMR_BUFFER_LENGTH_BITS; if (startPtr >= DMR_BUFFER_LENGTH_BITS)
startPtr -= DMR_BUFFER_LENGTH_BITS;
endPtr = m_dataPtr + DMR_SLOT_TYPE_LENGTH_BITS / 2U + DMR_INFO_LENGTH_BITS / 2U;
if (endPtr >= DMR_BUFFER_LENGTH_BITS)
endPtr -= DMR_BUFFER_LENGTH_BITS;
m_endPtr = m_dataPtr + DMR_SLOT_TYPE_LENGTH_BITS / 2U + DMR_INFO_LENGTH_BITS / 2U; if(m_slot) {
if (m_endPtr >= DMR_BUFFER_LENGTH_BITS) m_syncPtr2 = syncPtr;
m_endPtr -= DMR_BUFFER_LENGTH_BITS; m_startPtr2 = startPtr;
m_endPtr2 = endPtr;
m_control2 = control;
} else {
m_syncPtr1 = syncPtr;
m_startPtr1 = startPtr;
m_endPtr1 = endPtr;
m_control1 = control;
}
//DEBUG4("SYNC corr MS Voice found pos/start/end: ", m_dataPtr, m_startPtr, m_endPtr); //DEBUG5("SYNC corr MS Voice found slot/pos/start/end: ", m_slot ? 2U : 1U, m_dataPtr, startPtr, endPtr);
} }
} }
@ -289,17 +458,31 @@ void CDMRSlotRX::setDelay(uint8_t delay)
m_delay = delay / 5; m_delay = delay / 5;
} }
void CDMRSlotRX::writeRSSIData(uint8_t* frame) void CDMRSlotRX::writeRSSIData1()
{
#if defined(SEND_RSSI_DATA)
uint16_t rssi = io.readRSSI();
frame1[34U] = (rssi >> 8) & 0xFFU;
frame1[35U] = (rssi >> 0) & 0xFFU;
serial.writeDMRData(0U, frame1, DMR_FRAME_LENGTH_BYTES + 3U);
#else
serial.writeDMRData(0U, frame1, DMR_FRAME_LENGTH_BYTES + 1U);
#endif
}
void CDMRSlotRX::writeRSSIData2()
{ {
#if defined(SEND_RSSI_DATA) #if defined(SEND_RSSI_DATA)
uint16_t rssi = io.readRSSI(); uint16_t rssi = io.readRSSI();
frame[34U] = (rssi >> 8) & 0xFFU; frame2[34U] = (rssi >> 8) & 0xFFU;
frame[35U] = (rssi >> 0) & 0xFFU; frame2[35U] = (rssi >> 0) & 0xFFU;
serial.writeDMRData(m_slot, frame, DMR_FRAME_LENGTH_BYTES + 3U); serial.writeDMRData(1U, frame2, DMR_FRAME_LENGTH_BYTES + 3U);
#else #else
serial.writeDMRData(m_slot, frame, DMR_FRAME_LENGTH_BYTES + 1U); serial.writeDMRData(1U, frame2, DMR_FRAME_LENGTH_BYTES + 1U);
#endif #endif
} }

35
DMRSlotRX.h
Unescape View File

@ -51,23 +51,38 @@ private:
bool m_slot; bool m_slot;
uint64_t m_patternBuffer; uint64_t m_patternBuffer;
uint8_t m_buffer[DMR_BUFFER_LENGTH_BITS]; uint8_t m_buffer[DMR_BUFFER_LENGTH_BITS];
uint8_t frame[DMR_FRAME_LENGTH_BYTES + 3U];
uint16_t m_dataPtr; uint16_t m_dataPtr;
uint16_t m_syncPtr;
uint16_t m_startPtr; uint8_t frame1[DMR_FRAME_LENGTH_BYTES + 3U];
uint16_t m_endPtr; uint16_t m_syncPtr1;
uint16_t m_startPtr1;
uint16_t m_endPtr1;
uint8_t m_control1;
uint8_t m_syncCount1;
DMRRX_STATE m_state1;
uint8_t m_n1;
uint8_t m_type1;
uint8_t frame2[DMR_FRAME_LENGTH_BYTES + 3U];
uint16_t m_syncPtr2;
uint16_t m_startPtr2;
uint16_t m_endPtr2;
uint8_t m_control2;
uint8_t m_syncCount2;
DMRRX_STATE m_state2;
uint8_t m_n2;
uint8_t m_type2;
uint16_t m_delayPtr; uint16_t m_delayPtr;
uint8_t m_control;
uint8_t m_syncCount;
uint8_t m_colorCode; uint8_t m_colorCode;
uint16_t m_delay; uint16_t m_delay;
DMRRX_STATE m_state;
uint8_t m_n;
uint8_t m_type;
void procSlot1();
void procSlot2();
void correlateSync(); void correlateSync();
void bitsToBytes(uint16_t start, uint8_t count, uint8_t* buffer); void bitsToBytes(uint16_t start, uint8_t count, uint8_t* buffer);
void writeRSSIData(uint8_t* frame); void writeRSSIData1();
void writeRSSIData2();
}; };
#endif #endif

4
version.h
Unescape View File

@ -24,8 +24,8 @@
#define VER_MAJOR "1" #define VER_MAJOR "1"
#define VER_MINOR "1" #define VER_MINOR "1"
#define VER_REV "1" #define VER_REV "2"
#define VERSION_DATE "20180120" #define VERSION_DATE "20180121"
#if defined(ZUMSPOT_ADF7021) #if defined(ZUMSPOT_ADF7021)
#define BOARD_INFO "ZUMspot" #define BOARD_INFO "ZUMspot"

Write Preview
Loading…
Cancel
Save

Powered by TurnKey Linux.