DMR User Mode rx only

DMRDefines.h

@@ -75,6 +75,11 @@ const uint32_t DMR_BS_DATA_SYNC_SYMBOLS  = 0x00439B4DU;
 const uint32_t DMR_BS_VOICE_SYNC_SYMBOLS = 0x00BC64B2U;
 const uint32_t DMR_SYNC_SYMBOLS_MASK     = 0x00FFFFFFU;
 
+// D     F      F     5      7     D      7     5      D     F      5     D 
+// 11 01 11 11  11 11 01 01  01 11 11 01  01 11 01 01  11 01 11 11  01 01 11 01
+// -3 +3 -3 -3  -3 -3 +3 +3  +3 -3 -3 +3  +3 -3 +3 +3  -3 +3 -3 -3  +3 +3 -3 +3
+const int8_t DMR_BS_DATA_SYNC_SYMBOLS_VALUES[] = {-3, +3, -3, -3, -3, -3, +3, +3, +3, -3, -3, +3, +3, -3, +3, +3, -3, +3, -3, -3, +3, +3, -3, +3};
+
 // D     5      D     7      F     7      7     F      D     7      5     7
 // 11 01 01 01  11 01 01 11  11 11 01 11  01 11 11 11  11 01 01 11  01 01 01 11
 // -3 +3 +3 +3  -3 +3 +3 -3  -3 -3 +3 -3  +3 -3 -3 -3  -3 +3 +3 -3  +3 +3 +3 -3

DMRUserRX.cpp

@@ -0,0 +1,294 @@
+/*
+ *   Copyright (C) 2009-2017,2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2025 by Rob Williams M1BGT
+ *
+ *   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
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "Config.h"
+
+#if defined(MODE_DMR)
+
+#include "Globals.h"
+#include "DMRUserRX.h"
+#include "DMRSlotType.h"
+#include "Utils.h"
+
+const q15_t SCALING_FACTOR = 19505;      // Q15(0.60)
+
+const uint8_t MAX_SYNC_SYMBOLS_ERRS = 2U;
+const uint8_t MAX_SYNC_BYTES_ERRS   = 3U;
+
+const uint8_t BIT_MASK_TABLE[] = {0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02U, 0x01U};
+
+#define WRITE_BIT1(p,i,b) p[(i)>>3] = (b) ? (p[(i)>>3] | BIT_MASK_TABLE[(i)&7]) : (p[(i)>>3] & ~BIT_MASK_TABLE[(i)&7])
+
+const uint16_t NOENDPTR = 9999U;
+
+const uint8_t CONTROL_IDLE = 0x80U;
+const uint8_t CONTROL_DATA = 0x40U;
+
+const uint8_t cachInterleave[DMR_CACH_LENGTH_BITS] = {
+  0, 7, 8, 9, 1, 10, 11, 12, 2, 13, 14,
+  15, 3, 16, 4, 17, 18, 19, 5, 20, 21, 22, 6, 23
+};
+
+extern bool decodeDMRHamming74(uint8_t *received);
+
+CDMRUserRX::CDMRUserRX() :
+m_bitBuffer(),
+m_buffer(),
+m_bitPtr(0U),
+m_dataPtr(0U),
+m_endPtr(NOENDPTR),
+m_maxCorr(0),
+m_centre(0),
+m_threshold(0),
+m_colorCode(0U),
+m_slot(false)
+{
+}
+
+void CDMRUserRX::reset()
+{
+  m_dataPtr   = 0U;
+  m_bitPtr    = 0U;
+  m_maxCorr   = 0;
+  m_threshold = 0;
+  m_centre    = 0;
+  m_slot      = false;
+  m_endPtr    = NOENDPTR;
+}
+
+void CDMRUserRX::samples(const q15_t* samples, uint8_t length)
+{
+  for (uint8_t i = 0U; i < length; i++)
+    processSample(samples[i]);
+}
+
+void CDMRUserRX::processSample(q15_t sample)
+{
+  m_bitBuffer[m_bitPtr] <<= 1;
+  if (sample < 0)
+    m_bitBuffer[m_bitPtr] |= 0x01U;
+
+  m_buffer[m_dataPtr] = sample;
+
+  bool bsDataSyncFound = countBits32((m_bitBuffer[m_bitPtr] & DMR_SYNC_SYMBOLS_MASK) ^ DMR_BS_DATA_SYNC_SYMBOLS) <= MAX_SYNC_SYMBOLS_ERRS;
+  if (
+    bsDataSyncFound
+  ) {
+    // Sync pattern found
+
+    // | CACH (24 bits/60 samples) | Payload (98 bits) | Slot type (10 bits) | Sync (DMR_SYNC_LENGTH_SAMPLES) | Slot type  Slot type (10 bits) | Payload (98 bits) |
+
+    uint16_t ptr = m_dataPtr + DMR_FRAME_PLUS_CACH_LENGTH_SAMPLES - DMR_SYNC_LENGTH_SAMPLES + DMR_RADIO_SYMBOL_LENGTH;
+    if (ptr >= DMR_FRAME_PLUS_CACH_LENGTH_SAMPLES)
+      ptr -= DMR_FRAME_PLUS_CACH_LENGTH_SAMPLES;
+    // ptr is start of first sync sample
+
+    q31_t corr = 0;
+    q15_t max = -16000;
+    q15_t min =  16000;
+
+    for (uint8_t i = 0U; i < DMR_SYNC_LENGTH_SYMBOLS; i++) {
+      q15_t val = m_buffer[ptr];
+
+      if (val > max)
+        max = val;
+      if (val < min)
+        min = val;
+
+      switch (DMR_BS_DATA_SYNC_SYMBOLS_VALUES[i]) {
+      case +3:
+        corr -= (val + val + val);
+        break;
+      case +1:
+        corr -= val;
+        break;
+      case -1:
+        corr += val;
+        break;
+      default:  // -3
+        corr += (val + val + val);
+        break;
+      }
+
+      ptr += DMR_RADIO_SYMBOL_LENGTH;
+      if (ptr >= DMR_FRAME_PLUS_CACH_LENGTH_SAMPLES)
+        ptr -= DMR_FRAME_PLUS_CACH_LENGTH_SAMPLES;
+    }
+
+    if (corr > m_maxCorr) {
+      q15_t centre = (max + min) >> 1;
+
+      q31_t v1 = (max - centre) * SCALING_FACTOR;
+      q15_t threshold = q15_t(v1 >> 15);
+
+      uint8_t sync[DMR_SYNC_BYTES_LENGTH];
+
+      uint16_t ptr = m_dataPtr + DMR_FRAME_PLUS_CACH_LENGTH_SAMPLES - DMR_SYNC_LENGTH_SAMPLES + DMR_RADIO_SYMBOL_LENGTH;
+      if (ptr >= DMR_FRAME_PLUS_CACH_LENGTH_SAMPLES)
+        ptr -= DMR_FRAME_PLUS_CACH_LENGTH_SAMPLES;
+
+      samplesToBits(ptr, DMR_SYNC_LENGTH_SYMBOLS, sync, 4U, centre, threshold);
+
+      uint8_t errs = 0U;
+      for (uint8_t i = 0U; i < DMR_SYNC_BYTES_LENGTH; i++)
+        errs += countBits8((sync[i] & DMR_SYNC_BYTES_MASK[i]) ^  DMR_BS_DATA_SYNC_BYTES[i]);
+
+      if (errs <= MAX_SYNC_BYTES_ERRS) {
+        //DEBUG3("DMRUserRX: data sync found centre/threshold", centre, threshold);
+        m_maxCorr   = corr;
+        m_centre    = centre;
+        m_threshold = threshold;
+
+        m_endPtr    = m_dataPtr + DMR_SLOT_TYPE_LENGTH_SAMPLES / 2U + DMR_INFO_LENGTH_SAMPLES / 2U - 1U;
+        if (m_endPtr >= DMR_FRAME_PLUS_CACH_LENGTH_SAMPLES)
+          m_endPtr -= DMR_FRAME_PLUS_CACH_LENGTH_SAMPLES;
+      }
+    }
+  }
+
+  if (m_dataPtr == m_endPtr) {
+    uint16_t ptr = m_endPtr + DMR_RADIO_SYMBOL_LENGTH + 1U + DMR_CACH_LENGTH_SAMPLES;
+    if (ptr >= DMR_FRAME_PLUS_CACH_LENGTH_SAMPLES)
+	  ptr -= DMR_FRAME_PLUS_CACH_LENGTH_SAMPLES;
+
+    uint16_t cachePtr = m_endPtr + DMR_RADIO_SYMBOL_LENGTH + 1U;
+    if (cachePtr >= DMR_FRAME_PLUS_CACH_LENGTH_SAMPLES)
+	  cachePtr -= DMR_FRAME_PLUS_CACH_LENGTH_SAMPLES;
+
+    uint8_t frame[DMR_FRAME_LENGTH_BYTES + 1U];
+    samplesToBits(ptr, DMR_FRAME_LENGTH_SYMBOLS, frame, 8U, m_centre, m_threshold);
+
+    uint8_t colorCode;
+    uint8_t dataType;
+    CDMRSlotType slotType;
+    slotType.decode(frame + 1U, colorCode, dataType);
+
+    //DEBUG4("At end, cachePtr/ptr/endPtr", cachePtr, ptr, m_endPtr);
+
+    if (colorCode == m_colorCode && dataType != DT_IDLE) {
+
+      // Read the CACH in order to get the time slot
+      uint8_t cach[DMR_CACH_LENGTH_BYTES];
+      samplesToBits(cachePtr, DMR_CACH_LENGTH_SYMBOLS, cach, 0U, m_centre, m_threshold);
+      
+      if(cachCheck(cach))
+      {
+        frame[0U] = CONTROL_DATA | dataType;
+        serial.writeDMRData(m_slot, frame, DMR_FRAME_LENGTH_BYTES + 1U);
+      } else {
+        DEBUG1("CACH check failed");
+      }
+    }
+
+    m_endPtr  = NOENDPTR;
+    m_maxCorr = 0;
+  }
+
+  m_dataPtr++;
+  if (m_dataPtr >= DMR_FRAME_PLUS_CACH_LENGTH_SAMPLES)
+    m_dataPtr = 0U;
+
+  m_bitPtr++;
+  if (m_bitPtr >= DMR_RADIO_SYMBOL_LENGTH)
+    m_bitPtr = 0U;
+}
+
+ #define READ_BIT1(p,i)    ((p[(i)>>3] & BIT_MASK_TABLE[(i)&7]) >> (7 - ((i)&7)))
+
+void CDMRUserRX::extractBits(uint8_t* bytes, uint16_t start, uint8_t count_bits, bool* buffer)
+{
+    for (uint8_t i = 0U; i < count_bits; i++) {
+        buffer[i]  = READ_BIT1(bytes, start) == 0x01;
+        start++;
+    }
+}
+
+bool CDMRUserRX::cachCheck(uint8_t* cach)
+{
+  uint8_t i;
+
+  bool bits[DMR_CACH_LENGTH_BITS];
+  extractBits(cach, 0, DMR_CACH_LENGTH_BITS, bits);
+
+  bool cachdata[DMR_CACH_LENGTH_BITS];
+    
+  for (i = 0; i < DMR_CACH_LENGTH_BITS; i++)
+  {
+    cachdata[cachInterleave[i]] = bits[i];
+  }
+
+  uint8_t tactBits[7];
+
+  for (i = 0; i < 7; i++)
+  {
+    tactBits[i] = cachdata[i];
+  }
+
+  if(!decodeDMRHamming74(tactBits))
+  {
+    return false;
+  }
+
+  // bool at_continuous = tactBits[0];
+
+  m_slot = tactBits[1]; // TDMA Channel (TC)
+
+  return true;
+}
+
+void CDMRUserRX::samplesToBits(uint16_t start, uint8_t count, uint8_t* buffer, uint16_t offset, q15_t centre, q15_t threshold)
+{
+  for (uint8_t i = 0U; i < count; i++) {
+    q15_t sample = m_buffer[start] - centre;
+
+    if (sample < -threshold) {
+      WRITE_BIT1(buffer, offset, false);
+      offset++;
+      WRITE_BIT1(buffer, offset, true);
+      offset++;
+    } else if (sample < 0) {
+      WRITE_BIT1(buffer, offset, false);
+      offset++;
+      WRITE_BIT1(buffer, offset, false);
+      offset++;
+    } else if (sample < threshold) {
+      WRITE_BIT1(buffer, offset, true);
+      offset++;
+      WRITE_BIT1(buffer, offset, false);
+      offset++;
+    } else {
+      WRITE_BIT1(buffer, offset, true);
+      offset++;
+      WRITE_BIT1(buffer, offset, true);
+      offset++;
+    }
+
+    start += DMR_RADIO_SYMBOL_LENGTH;
+    if (start >= DMR_FRAME_PLUS_CACH_LENGTH_SAMPLES)
+      start -= DMR_FRAME_PLUS_CACH_LENGTH_SAMPLES;
+  }
+}
+
+void CDMRUserRX::setColorCode(uint8_t colorCode)
+{
+  m_colorCode = colorCode;
+}
+
+#endif
+

DMRUserRX.h

@@ -0,0 +1,62 @@
+/*
+ *   Copyright (C) 2015,2020 by Jonathan Naylor G4KLX
+ *
+ *   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
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "Config.h"
+
+#if defined(MODE_DMR)
+
+#if !defined(DMRUSERRX_H)
+#define  DMRUSERRX_H
+
+#include "DMRDefines.h"
+
+const unsigned int DMR_FRAME_PLUS_CACH_LENGTH_SAMPLES = DMR_FRAME_LENGTH_SAMPLES + DMR_CACH_LENGTH_SAMPLES;
+
+class CDMRUserRX {
+public:
+  CDMRUserRX();
+
+  void samples(const q15_t* samples, uint8_t length);
+
+  void setColorCode(uint8_t colorCode);
+
+  void reset();
+
+private:
+  uint32_t m_bitBuffer[DMR_RADIO_SYMBOL_LENGTH];
+  q15_t    m_buffer[DMR_FRAME_PLUS_CACH_LENGTH_SAMPLES];
+  uint16_t m_bitPtr;
+  uint16_t m_dataPtr;
+  uint16_t m_endPtr;
+  q31_t    m_maxCorr;
+  q15_t    m_centre;
+  q15_t    m_threshold;
+  uint8_t  m_colorCode;
+  bool     m_slot;
+
+  bool cachCheck(uint8_t* cach);
+  void extractBits(uint8_t* bytes, uint16_t start, uint8_t count_bits, bool* buffer);
+
+  void processSample(q15_t sample);
+  void samplesToBits(uint16_t start, uint8_t count, uint8_t* buffer, uint16_t offset, q15_t centre, q15_t threshold);
+};
+
+#endif
+
+#endif
+

Globals.h

@@ -81,6 +81,7 @@ enum MMDVM_STATE {
 #include "DStarTX.h"
 #include "DMRRX.h"
 #include "DMRTX.h"
+#include "DMRUserRX.h"
 #include "YSFRX.h"
 #include "YSFTX.h"
 #include "P25RX.h"
@@ -134,6 +135,7 @@ extern bool m_fmEnable;
 extern bool m_ax25Enable;
 
 extern bool m_duplex;
+extern bool m_dmrUserMode;
 
 extern bool m_tx;
 extern bool m_dcd;
@@ -154,6 +156,7 @@ extern CDMRIdleRX dmrIdleRX;
 extern CDMRRX dmrRX;
 extern CDMRTX dmrTX;
 
+extern CDMRUserRX dmrUserRX;
 extern CDMRDMORX dmrDMORX;
 extern CDMRDMOTX dmrDMOTX;
 

Hamming.cpp

@@ -0,0 +1,94 @@
+/*
+ *   Copyright (C) 2025 by Rob Williams M1BGT
+ *
+ *   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
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <stdint.h>
+//#include <cstdio> // Only required for additional debug
+#include "Globals.h"
+
+// Map from syndrome value to error bit index in DMR order
+const int syndromeMap[8] = {
+    -1, // 0: no error
+    4, // syndrome 1 → P1 (bit 4)
+    5, // syndrome 2 → P2 (bit 5)
+    2, // syndrome 3 → D3 (bit 2)
+    6, // syndrome 4 → P3 (bit 6)
+    0, // syndrome 5 → D2 (bit 1)
+    3, // syndrome 6 → D4 (bit 3)
+    1, // syndrome 7 → D2 (bit 1)
+};
+
+// Decode DMR CACH Hamming(7,4)
+bool decodeSingleDMRHamming74(uint8_t *received) {
+    /*
+    D1 2 3 4 P1 2 3
+     1 0 0 0  1 0 1. (5)
+     0 1 0 0  1 1 1. (7)
+     0 0 1 0  1 1 0. (3)
+     0 0 0 1  0 1 1  (6)
+    */
+    
+    uint8_t D1 = received[0];
+    uint8_t D2 = received[1];
+    uint8_t D3 = received[2];
+    uint8_t D4 = received[3];
+
+    uint8_t P1 = received[4];
+    uint8_t P2 = received[5];
+    uint8_t P3 = received[6];
+    
+    // Calculate syndrome bits
+    uint8_t S1 = P1 ^ D1 ^ D2 ^ D3;
+    uint8_t S2 = P2 ^ D2 ^ D3 ^ D4;
+    uint8_t S3 = P3 ^ D1 ^ D2 ^ D4;
+
+    uint8_t syndrome = (S3 << 2) | (S2 << 1) | S1;
+
+    if (syndrome != 0) {
+        int errorBit = syndromeMap[syndrome];
+        if (errorBit != -1) {
+            DEBUG2("Error detected, flipping bit.", errorBit);
+            received[errorBit] ^= 1;  // Flip bit
+
+            // Return false to indicate a change was made (it might be good now)
+            return false;
+        }
+    }
+
+    // No bits flipped - good
+    return true;
+}
+
+bool decodeDMRHamming74(uint8_t *received) {
+    // Check it multiple times to make sure we know all are valid
+
+    //char receivedLog[28];
+    //snprintf(receivedLog, 28, "Input Hamming 7,4: %d%d%d%d %d%d%d", 
+    //    received[0], received[1], received[2], received[3], 
+    //    received[4], received[5], received[6]);
+    //DEBUG1(receivedLog);
+
+    // The first pass may result in a bit flip, the second must not
+    for(uint8_t i=0;i<2;i++)
+    {
+        if(decodeSingleDMRHamming74(received)) {
+            return true;
+        }
+    }
+
+    return false;
+}

IO.cpp

@@ -471,7 +471,10 @@ void CIO::process()
         q15_t DMRVals[RX_BLOCK_SIZE];
         ::arm_fir_fast_q15(&m_rrc02Filter1, samples, DMRVals, RX_BLOCK_SIZE);
 
-        if (m_duplex)
+        if(m_dmrUserMode) {
+          dmrUserRX.samples(DMRVals, RX_BLOCK_SIZE);
+        }
+        else if (m_duplex)
           dmrIdleRX.samples(DMRVals, RX_BLOCK_SIZE);
         else
           dmrDMORX.samples(DMRVals, rssi, RX_BLOCK_SIZE);
@@ -544,7 +547,9 @@ void CIO::process()
         q15_t DMRVals[RX_BLOCK_SIZE];
         ::arm_fir_fast_q15(&m_rrc02Filter1, samples, DMRVals, RX_BLOCK_SIZE);
 
-        if (m_duplex) {
+        if(m_dmrUserMode) {
+          dmrUserRX.samples(DMRVals, RX_BLOCK_SIZE);
+        } else if (m_duplex) {
           // If the transmitter isn't on, use the DMR idle RX to detect the wakeup CSBKs
           if (m_tx)
             dmrRX.samples(DMRVals, rssi, control, RX_BLOCK_SIZE);

MMDVM.cpp

@@ -37,6 +37,7 @@ bool m_fmEnable     = true;
 bool m_ax25Enable   = true;
 
 bool m_duplex = true;
+bool m_dmrUserMode = false;
 
 bool m_tx  = false;
 bool m_dcd = false;
@@ -57,6 +58,8 @@ CDMRTX dmrTX;
 CDMRDMORX dmrDMORX;
 CDMRDMOTX dmrDMOTX;
 
+CDMRUserRX dmrUserRX;
+
 CCalDMR calDMR;
 #endif
 
@@ -127,7 +130,9 @@ void loop()
 
 #if defined(MODE_DMR)
   if (m_dmrEnable && m_modemState == STATE_DMR) {
-    if (m_duplex)
+    if(m_dmrUserMode) {
+      // Do nothing - receive only
+    } else if (m_duplex)
       dmrTX.process();
     else
       dmrDMOTX.process();

MMDVM.ino

@@ -34,6 +34,7 @@ bool m_fmEnable     = true;
 bool m_ax25Enable   = true;
 
 bool m_duplex = true;
+bool m_dmrUserMode = false;
 
 bool m_tx  = false;
 bool m_dcd = false;
@@ -54,6 +55,8 @@ CDMRTX dmrTX;
 CDMRDMORX dmrDMORX;
 CDMRDMOTX dmrDMOTX;
 
+CDMRUserRX dmrUserRX;
+
 CCalDMR calDMR;
 #endif
 
@@ -124,7 +127,9 @@ void loop()
 
 #if defined(MODE_DMR)
   if (m_dmrEnable && m_modemState == STATE_DMR) {
-    if (m_duplex)
+    if(m_dmrUserMode) {
+      // Do nothing - receive only
+    } else if (m_duplex)
       dmrTX.process();
     else
       dmrDMOTX.process();

SerialPort.cpp

@@ -358,7 +358,7 @@ void CSerialPort::getVersion()
   io.getUDID(reply + 7U);
 
   uint8_t count = 23U;
-  for (uint8_t i = 0U; HARDWARE[i] != 0x00U; i++, count++)
+  for (uint8_t i = 0U; HARDWARE[i] != 0x00U && i<200U; i++, count++)
     reply[count] = HARDWARE[i];
 
   reply[1U] = count;
@@ -380,6 +380,9 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint16_t length)
   bool useCOSAsLockout = (data[0U] & 0x20U) == 0x20U;
   bool simplex         = (data[0U] & 0x80U) == 0x80U;
 
+  // add dmr user mode here or as a new mode?
+  bool dmrUserModeEnabled =  (data[0U] & 0x40U) == 0x40U;
+
   m_debug = (data[0U] & 0x10U) == 0x10U;
 
 #if defined(MODE_DSTAR)
@@ -387,6 +390,16 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint16_t length)
 #endif
 #if defined(MODE_DMR)
   bool dmrEnable    = (data[1U] & 0x02U) == 0x02U;
+
+  if(dmrUserModeEnabled && (!m_dmrEnable || !simplex))
+  {
+    DEBUG1("DMR User mode can only be enabled when simplex DMR is enabled");
+    return 4U;
+  }
+
+  m_dmrUserMode = dmrUserModeEnabled && m_dmrEnable;
+#else
+  m_dmrUserMode = false;
 #endif
 #if defined(MODE_YSF)
   bool ysfEnable    = (data[1U] & 0x04U) == 0x04U;
@@ -549,6 +562,7 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint16_t length)
   dmrRX.setDelay(dmrDelay);
   dmrDMORX.setColorCode(colorCode);
   dmrIdleRX.setColorCode(colorCode);
+  dmrUserRX.setColorCode(colorCode);
 #endif
 #if defined(MODE_YSF)
   m_ysfEnable    = ysfEnable;
@@ -858,6 +872,7 @@ void CSerialPort::setMode(MMDVM_STATE modemState)
     dmrIdleRX.reset();
     dmrDMORX.reset();
     dmrRX.reset();
+    dmrUserRX.reset();
   }
 #endif
 
@@ -1182,36 +1197,50 @@ void CSerialPort::processMessage(uint8_t type, const uint8_t* buffer, uint16_t l
 
 #if defined(MODE_DMR)
     case MMDVM_DMR_DATA1:
-      if (m_dmrEnable) {
+      if(m_dmrUserMode) {
-        if (m_modemState == STATE_IDLE || m_modemState == STATE_DMR) {
+        // Ignore
-          if (m_duplex)
+        err = 9;
-            err = dmrTX.writeData1(buffer, length);
+        DEBUG2("DMR user mode is rxonly", err);
-        }
-      }
-      if (err == 0U) {
-        if (m_modemState == STATE_IDLE)
-          setMode(STATE_DMR);
-      } else {
-        DEBUG2("Received invalid DMR data", err);
         sendNAK(type, err);
+      } else {
+        if (m_dmrEnable) {
+          if (m_modemState == STATE_IDLE || m_modemState == STATE_DMR) {
+            if (m_duplex)
+              err = dmrTX.writeData1(buffer, length);
+          }
+        }
+        if (err == 0U) {
+          if (m_modemState == STATE_IDLE)
+            setMode(STATE_DMR);
+        } else {
+          DEBUG2("Received invalid DMR data", err);
+          sendNAK(type, err);
+        }
       }
       break;
 
     case MMDVM_DMR_DATA2:
-      if (m_dmrEnable) {
+      if(m_dmrUserMode) {
-        if (m_modemState == STATE_IDLE || m_modemState == STATE_DMR) {
+        // Ignore
-          if (m_duplex)
+        err = 9;
-            err = dmrTX.writeData2(buffer, length);
+        DEBUG2("DMR user mode is rxonly", err);
-          else
-            err = dmrDMOTX.writeData(buffer, length);
-        }
-      }
-      if (err == 0U) {
-        if (m_modemState == STATE_IDLE)
-          setMode(STATE_DMR);
-      } else {
-        DEBUG2("Received invalid DMR data", err);
         sendNAK(type, err);
+      } else {
+        if (m_dmrEnable) {
+          if (m_modemState == STATE_IDLE || m_modemState == STATE_DMR) {
+            if (m_duplex)
+              err = dmrTX.writeData2(buffer, length);
+            else
+              err = dmrDMOTX.writeData(buffer, length);
+          }
+        }
+        if (err == 0U) {
+          if (m_modemState == STATE_IDLE)
+            setMode(STATE_DMR);
+        } else {
+          DEBUG2("Received invalid DMR data", err);
+          sendNAK(type, err);
+        }
       }
       break;