Merge branch 'master' into mqtt

AX25Demodulator.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020,2023 by Jonathan Naylor G4KLX
  *   Copyright 2015-2019 Mobilinkd LLC <[email protected]>
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -85,7 +85,9 @@ m_hdlcOnes(0U),
 m_hdlcFlag(false),
 m_hdlcBuffer(0U),
 m_hdlcBits(0U),
-m_hdlcState(AX25_IDLE)
+m_hdlcState(AX25_IDLE),
+m_rssiAccum(0U),
+m_rssiCount(0U)
 {
   m_delayLine = new bool[DELAY_LEN];
 
@@ -101,7 +103,7 @@ m_hdlcState(AX25_IDLE)
     m_iirHistory[i] = 0.0F;
 }
 
-bool CAX25Demodulator::process(q15_t* samples, uint8_t length, CAX25Frame& frame)
+bool CAX25Demodulator::process(q15_t* samples, const uint16_t* rssi, uint8_t length, CAX25Frame& frame)
 {
   bool result = false;
 
@@ -119,6 +121,9 @@ bool CAX25Demodulator::process(q15_t* samples, uint8_t length, CAX25Frame& frame
   ::arm_fir_fast_q15(&m_lpfFilter, buffer, fc, RX_BLOCK_SIZE);
 
   for (uint8_t i = 0; i < length; i++) {
+    m_rssiAccum += rssi[i];
+    m_rssiCount++;
+
     bool bit = fc[i] >= 0;
     bool sample = PLL(bit);
 
@@ -266,6 +271,8 @@ bool CAX25Demodulator::HDLC(bool b)
         // Start of frame data.
         m_hdlcState = AX25_RECEIVE;
         m_frame.append(m_hdlcBuffer);
+        m_rssiAccum = 0U;
+        m_rssiCount = 0U;
         m_hdlcBits = 0U;
       }
       break;
@@ -315,5 +322,19 @@ float32_t CAX25Demodulator::iir(float32_t input)
   return result;
 }
 
+uint16_t CAX25Demodulator::getRSSI()
+{
+  if (m_rssiCount > 0U) {
+    uint16_t rssi = m_rssiAccum / m_rssiCount;
+
+    m_rssiAccum = 0U;
+    m_rssiCount = 0U;
+
+    return rssi;
+  }
+
+  return 0U;
+}
+
 #endif
 

AX25Demodulator.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020,2023 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
@@ -36,12 +36,14 @@ class CAX25Demodulator {
 public:
   CAX25Demodulator(int8_t n);
 
-  bool process(q15_t* samples, uint8_t length, CAX25Frame& frame);
+  bool process(q15_t* samples, const uint16_t* rssi, uint8_t length, CAX25Frame& frame);
 
   void setTwist(int8_t n);
 
   bool isDCD();
 
+  uint16_t getRSSI();
+
 private:
   CAX25Frame           m_frame;
   CAX25Twist           m_twist;
@@ -63,6 +65,8 @@ private:
   uint16_t             m_hdlcBuffer;
   uint16_t             m_hdlcBits;
   AX25_STATE           m_hdlcState;
+  uint32_t             m_rssiAccum;
+  uint16_t             m_rssiCount;
 
   bool delay(bool b);
   bool NRZI(bool b);

AX25RX.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020,2023 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
@@ -86,7 +86,7 @@ m_c(0xF6U)
   initRand();
 }
 
-void CAX25RX::samples(q15_t* samples, uint8_t length)
+void CAX25RX::samples(q15_t* samples, const uint16_t* rssi, uint8_t length)
 {
   q15_t output[RX_BLOCK_SIZE];
   ::arm_fir_fast_q15(&m_filter, samples, output, RX_BLOCK_SIZE);
@@ -95,32 +95,56 @@ void CAX25RX::samples(q15_t* samples, uint8_t length)
 
   CAX25Frame frame;
 
-  bool ret = m_demod1.process(output, length, frame);
+  bool ret = m_demod1.process(output, rssi, length, frame);
   if (ret) {
     if (frame.m_fcs != m_lastFCS || m_count > 2U) {
       m_lastFCS = frame.m_fcs;
       m_count   = 0U;
+#if defined(SEND_RSSI_DATA)
+      uint16_t rssi = m_demod1.getRSSI();
+      if (rssi > 0U)
+        serial.writeAX25DataEx(rssi, frame.m_data, frame.m_length - 2U);
+      else
+        serial.writeAX25Data(frame.m_data, frame.m_length - 2U);
+#else
       serial.writeAX25Data(frame.m_data, frame.m_length - 2U);
+#endif
     }
     DEBUG1("Decoder 1 reported");
   }
 
-  ret = m_demod2.process(output, length, frame);
+  ret = m_demod2.process(output, rssi, length, frame);
   if (ret) {
     if (frame.m_fcs != m_lastFCS || m_count > 2U) {
       m_lastFCS = frame.m_fcs;
       m_count   = 0U;
+#if defined(SEND_RSSI_DATA)
+      uint16_t rssi = m_demod2.getRSSI();
+      if (rssi > 0U)
+        serial.writeAX25DataEx(rssi, frame.m_data, frame.m_length - 2U);
+      else
+        serial.writeAX25Data(frame.m_data, frame.m_length - 2U);
+#else
       serial.writeAX25Data(frame.m_data, frame.m_length - 2U);
+#endif
     }
     DEBUG1("Decoder 2 reported");
   }
 
-  ret = m_demod3.process(output, length, frame);
+  ret = m_demod3.process(output, rssi, length, frame);
   if (ret) {
     if (frame.m_fcs != m_lastFCS || m_count > 2U) {
       m_lastFCS = frame.m_fcs;
       m_count   = 0U;
+#if defined(SEND_RSSI_DATA)
+      uint16_t rssi = m_demod3.getRSSI();
+      if (rssi > 0U)
+        serial.writeAX25DataEx(rssi, frame.m_data, frame.m_length - 2U);
+      else
+        serial.writeAX25Data(frame.m_data, frame.m_length - 2U);
+#else
       serial.writeAX25Data(frame.m_data, frame.m_length - 2U);
+#endif
     }
     DEBUG1("Decoder 3 reported");
   }

AX25RX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020,2023 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
@@ -29,7 +29,7 @@ class CAX25RX {
 public:
   CAX25RX();
 
-  void samples(q15_t* samples, uint8_t length);
+  void samples(q15_t* samples, const uint16_t* rssi, uint8_t length);
 
   void setParams(int8_t twist, uint8_t slotTime, uint8_t pPersist);
 

Config.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018,2020,2024 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,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
@@ -38,9 +38,6 @@
 #define MODE_NXDN
 #define USE_NXDN_BOXCAR
 
-// Enable dPMR support.
-#define	MODE_DPMR
-
 // Enable M17 support.
 #define MODE_M17
 
@@ -128,8 +125,5 @@
 // Use the D-Star and YSF LEDs for FM
 #define USE_ALTERNATE_FM_LEDS
 
-// Use the DMR and YSF LEDs for dPMR
-#define USE_ALTERNATE_DPMR_LEDS
-
 #endif
 

DPMRDefines.h

@@ -1,120 +0,0 @@
-/*
- *   Copyright (C) 2016,2017,2018,2024 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.
- */
-
-#if !defined(DPMRDEFINES_H)
-#define  DPMRDEFINES_H
-
-const unsigned int DPMR_RADIO_SYMBOL_LENGTH = 10U;      // At 24 kHz sample rate
-
-const unsigned int DPMR_HEADER_FRAME_LENGTH_BITS    = 312U;
-const unsigned int DPMR_HEADER_FRAME_LENGTH_BYTES   = DPMR_HEADER_FRAME_LENGTH_BITS / 8U;
-const unsigned int DPMR_HEADER_FRAME_LENGTH_SYMBOLS = DPMR_HEADER_FRAME_LENGTH_BITS / 2U;
-const unsigned int DPMR_HEADER_FRAME_LENGTH_SAMPLES = DPMR_HEADER_FRAME_LENGTH_SYMBOLS * DPMR_RADIO_SYMBOL_LENGTH;
-
-const unsigned int DPMR_DATA_FRAME_LENGTH_BITS    = 384U;
-const unsigned int DPMR_DATA_FRAME_LENGTH_BYTES   = DPMR_DATA_FRAME_LENGTH_BITS / 8U;
-const unsigned int DPMR_DATA_FRAME_LENGTH_SYMBOLS = DPMR_DATA_FRAME_LENGTH_BITS / 2U;
-const unsigned int DPMR_DATA_FRAME_LENGTH_SAMPLES = DPMR_DATA_FRAME_LENGTH_SYMBOLS * DPMR_RADIO_SYMBOL_LENGTH;
-
-const unsigned int DPMR_END_FRAME_LENGTH_BITS    = 96U;
-const unsigned int DPMR_END_FRAME_LENGTH_BYTES   = DPMR_END_FRAME_LENGTH_BITS / 8U;
-const unsigned int DPMR_END_FRAME_LENGTH_SYMBOLS = DPMR_END_FRAME_LENGTH_BITS / 2U;
-const unsigned int DPMR_END_FRAME_LENGTH_SAMPLES = DPMR_END_FRAME_LENGTH_SYMBOLS * DPMR_RADIO_SYMBOL_LENGTH;
-
-const unsigned int DPMR_FS1_LENGTH_BITS    = 48U;
-const unsigned int DPMR_FS1_LENGTH_SYMBOLS = DPMR_FS1_LENGTH_BITS / 2U;
-const unsigned int DPMR_FS1_LENGTH_SAMPLES = DPMR_FS1_LENGTH_SYMBOLS * DPMR_RADIO_SYMBOL_LENGTH;
-
-const unsigned int DPMR_FS2_LENGTH_BITS    = 24U;
-const unsigned int DPMR_FS2_LENGTH_SYMBOLS = DPMR_FS2_LENGTH_BITS / 2U;
-const unsigned int DPMR_FS2_LENGTH_SAMPLES = DPMR_FS2_LENGTH_SYMBOLS * DPMR_RADIO_SYMBOL_LENGTH;
-
-const unsigned int DPMR_FS3_LENGTH_BITS    = 24U;
-const unsigned int DPMR_FS3_LENGTH_SYMBOLS = DPMR_FS3_LENGTH_BITS / 2U;
-const unsigned int DPMR_FS3_LENGTH_SAMPLES = DPMR_FS3_LENGTH_SYMBOLS * DPMR_RADIO_SYMBOL_LENGTH;
-
-const unsigned int DPMR_FS4_LENGTH_BITS    = 48U;
-const unsigned int DPMR_FS4_LENGTH_SYMBOLS = DPMR_FS4_LENGTH_BITS / 2U;
-const unsigned int DPMR_FS4_LENGTH_SAMPLES = DPMR_FS4_LENGTH_SYMBOLS * DPMR_RADIO_SYMBOL_LENGTH;
-
-const uint8_t DPMR_FS1_BYTES[]      = {0x57U, 0xFFU, 0x5FU, 0x75U, 0xD5U, 0x77U};
-const uint8_t DPMR_FS1_BYTES_LENGTH = 6U;
-
-const uint8_t DPMR_FS2_BYTES[]      = {0x5FU, 0xF7U, 0x7DU};
-const uint8_t DPMR_FS2_BYTES_LENGTH = 3U;
-
-const uint8_t DPMR_FS3_BYTES[]      = {0x7DU, 0xDFU, 0xF5U};
-const uint8_t DPMR_FS3_BYTES_LENGTH = 3U;
-
-const uint8_t DPMR_FS4_BYTES[]      = {0xFDU, 0x55U, 0xF5U, 0xDFU, 0x7FU, 0xDDU};
-const uint8_t DPMR_FS4_BYTES_LENGTH = 6U;
-
-const uint64_t DPMR_FS1_BITS      = 0x000057FF5F75D577U;
-const uint64_t DPMR_FS1_BITS_MASK = 0x0000FFFFFFFFFFFFU;
-
-const uint64_t DPMR_FS2_BITS      = 0x00000000005FF77DU;
-const uint64_t DPMR_FS2_BITS_MASK = 0x0000000000FFFFFFU;
-
-const uint64_t DPMR_FS3_BITS      = 0x00000000007DDFF5U;
-const uint64_t DPMR_FS3_BITS_MASK = 0x0000000000FFFFFFU;
-
-const uint64_t DPMR_FS4_BITS      = 0x0000FD55F5DF7FDDU;
-const uint64_t DPMR_FS4_BITS_MASK = 0x0000FFFFFFFFFFFFU;
-
-// FS1
-// 5     5      F     F      5     F      7     5      D     5      7     7
-// 01 01 01 11  11 11 11 11  01 01 11 11  01 11 01 01  11 01 01 01  01 11 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
-
-const int8_t DPMR_FS1_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};
-
-const uint32_t DPMR_FS1_SYMBOLS      = 0x00E0CB7AU;
-const uint32_t DPMR_FS1_SYMBOLS_MASK = 0x00FFFFFFU;
-
-// FS2
-// 5     F      F     7      7     D
-// 01 01 11 11  11 11 01 11  01 11 11 01
-// +3 +3 -3 -3  -3 -3 +3 -3  +3 -3 -3 +3
-
-const int8_t DPMR_FS2_SYMBOLS_VALUES[] = {+3, +3, -3, -3, -3, -3, +3, -3, +3, -3, -3, +3};
-
-const uint32_t DPMR_FS2_SYMBOLS      = 0x00000C29U;
-const uint32_t DPMR_FS2_SYMBOLS_MASK = 0x00000FFFU;
-
-// FS3
-// 7     D      D     F      F     5
-// 01 11 11 01  11 01 11 11  11 11 01 01
-// +3 -3 -3 +3  -3 +3 -3 -3  -3 -3 +3 +3
-
-const int8_t DPMR_FS3_SYMBOLS_VALUES[] = {+3, -3, -3, +3, -3, +3, -3, -3, -3, -3, +3, +3};
-
-const uint32_t DPMR_FS3_SYMBOLS      = 0x00000943U;
-const uint32_t DPMR_FS3_SYMBOLS_MASK = 0x00000FFFU;
-
-// FS4
-// F     D      5     5      F     5      D     F      7     F      D     D
-// 11 11 11 01  01 01 01 01  11 11 01 01  11 01 11 11  01 11 11 11  11 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 DPMR_FS4_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};
-
-const uint32_t DPMR_FS4_SYMBOLS      = 0x001F3485U;
-const uint32_t DPMR_FS4_SYMBOLS_MASK = 0x00FFFFFFU;
-
-#endif
-

DPMRRX.cpp

@@ -1,687 +0,0 @@
-/*
- *   Copyright (C) 2009-2018,2020,2024 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_DPMR)
-
-#include "Globals.h"
-#include "DPMRRX.h"
-#include "Utils.h"
-
-const q15_t SCALING_FACTOR = 18750;      // Q15(0.55)
-
-const uint8_t MAX_FS_BIT_START_ERRS = 1U;
-const uint8_t MAX_FS_BIT_RUN_ERRS   = 3U;
-
-const uint8_t MAX_FS_SYMBOLS_ERRS = 2U;
-
-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 uint8_t NOAVEPTR = 99U;
-
-const uint16_t NOENDPTR = 9999U;
-
-const unsigned int MAX_FS_FRAMES = 5U + 1U;
-
-CDPMRRX::CDPMRRX() :
-m_state(DPMRRXS_NONE),
-m_bitBuffer(),
-m_buffer(),
-m_bitPtr(0U),
-m_dataPtr(0U),
-m_startPtr(NOENDPTR),
-m_endPtr(NOENDPTR),
-m_fsPtr(NOENDPTR),
-m_minFSPtr(NOENDPTR),
-m_maxFSPtr(NOENDPTR),
-m_maxCorr(0),
-m_lostCount(0U),
-m_countdown(0U),
-m_centre(),
-m_centreVal(0),
-m_threshold(),
-m_thresholdVal(0),
-m_averagePtr(NOAVEPTR),
-m_rssiAccum(0U),
-m_rssiCount(0U)
-{
-}
-
-void CDPMRRX::reset()
-{
-  m_state        = DPMRRXS_NONE;
-  m_dataPtr      = 0U;
-  m_bitPtr       = 0U;
-  m_maxCorr      = 0;
-  m_averagePtr   = NOAVEPTR;
-  m_startPtr     = NOENDPTR;
-  m_endPtr       = NOENDPTR;
-  m_fsPtr        = NOENDPTR;
-  m_minFSPtr     = NOENDPTR;
-  m_maxFSPtr     = NOENDPTR;
-  m_centreVal    = 0;
-  m_thresholdVal = 0;
-  m_lostCount    = 0U;
-  m_countdown    = 0U;
-  m_rssiAccum    = 0U;
-  m_rssiCount    = 0U;
-}
-
-void CDPMRRX::samples(const q15_t* samples, uint16_t* rssi, uint8_t length)
-{
-  for (uint8_t i = 0U; i < length; i++) {
-    q15_t sample = samples[i];
-
-    m_rssiAccum += rssi[i];
-    m_rssiCount++;
-
-    m_bitBuffer[m_bitPtr] <<= 1;
-    if (sample < 0)
-      m_bitBuffer[m_bitPtr] |= 0x01U;
-
-    m_buffer[m_dataPtr] = sample;
-
-    switch (m_state) {
-    case DPMRRXS_HEADER:
-      processHeader(sample);
-      break;
-    case DPMRRXS_DATA:
-      processData(sample);
-      break;
-    case DPMRRXS_EOT:
-      processEOT(sample);
-      break;
-    default:
-      processNone(sample);
-      break;
-    }
-
-    m_dataPtr++;
-    if (m_dataPtr >= DPMR_DATA_FRAME_LENGTH_SAMPLES)
-      m_dataPtr = 0U;
-
-    m_bitPtr++;
-    if (m_bitPtr >= DPMR_RADIO_SYMBOL_LENGTH)
-      m_bitPtr = 0U;
-  }
-}
-
-void CDPMRRX::processNone(q15_t sample)
-{
-  // Process the FS1/Header sync
-  bool ret = correlateFS1();
-  if (ret) {
-    // On the first sync, start the countdown to the state change
-    if (m_countdown == 0U) {
-      m_rssiAccum = 0U;
-      m_rssiCount = 0U;
-
-      io.setDecode(true);
-      io.setADCDetection(true);
-
-      m_averagePtr = NOAVEPTR;
-
-      m_countdown = 5U;
-    }
-  }
-
-  if (m_countdown > 0U)
-    m_countdown--;
-
-  if (m_countdown == 1U) {
-    m_minFSPtr = m_fsPtr + DPMR_HEADER_FRAME_LENGTH_SAMPLES - 1U;
-    if (m_minFSPtr >= DPMR_DATA_FRAME_LENGTH_SAMPLES)
-      m_minFSPtr -= DPMR_DATA_FRAME_LENGTH_SAMPLES;
-
-    m_maxFSPtr = m_fsPtr + 1U;
-    if (m_maxFSPtr >= DPMR_DATA_FRAME_LENGTH_SAMPLES)
-      m_maxFSPtr -= DPMR_DATA_FRAME_LENGTH_SAMPLES;
-
-    m_state     = DPMRRXS_HEADER;
-    m_countdown = 0U;
-  }
-
-  // Process the FS2/Data sync
-  ret = correlateFS2();
-  if (ret) {
-    // On the first sync, start the countdown to the state change
-    if (m_countdown == 0U) {
-      m_rssiAccum = 0U;
-      m_rssiCount = 0U;
-
-      io.setDecode(true);
-      io.setADCDetection(true);
-
-      m_averagePtr = NOAVEPTR;
-
-      m_countdown = 5U;
-    }
-  }
-
-  if (m_countdown > 0U)
-    m_countdown--;
-
-  if (m_countdown == 1U) {
-    m_minFSPtr = m_fsPtr + DPMR_DATA_FRAME_LENGTH_SAMPLES - 1U;
-    if (m_minFSPtr >= DPMR_DATA_FRAME_LENGTH_SAMPLES)
-      m_minFSPtr -= DPMR_DATA_FRAME_LENGTH_SAMPLES;
-
-    m_maxFSPtr = m_fsPtr + 1U;
-    if (m_maxFSPtr >= DPMR_DATA_FRAME_LENGTH_SAMPLES)
-      m_maxFSPtr -= DPMR_DATA_FRAME_LENGTH_SAMPLES;
-
-    m_state     = DPMRRXS_DATA;
-    m_countdown = 0U;
-  }
-
-  // Don't process FS3/End sync here
-}
-
-void CDPMRRX::processHeader(q15_t sample)
-{
-  if (m_dataPtr == m_endPtr) {
-    m_minFSPtr = m_fsPtr + DPMR_HEADER_FRAME_LENGTH_SAMPLES - 1U;
-    if (m_minFSPtr >= DPMR_DATA_FRAME_LENGTH_SAMPLES)
-      m_minFSPtr -= DPMR_DATA_FRAME_LENGTH_SAMPLES;
-
-    m_maxFSPtr = m_fsPtr + 1U;
-    if (m_maxFSPtr >= DPMR_DATA_FRAME_LENGTH_SAMPLES)
-      m_maxFSPtr -= DPMR_DATA_FRAME_LENGTH_SAMPLES;
-
-    calculateLevels(m_startPtr, DPMR_HEADER_FRAME_LENGTH_SYMBOLS);
-
-    DEBUG4("DPMRRX: FS1 sync found pos/centre/threshold", m_fsPtr, m_centreVal, m_thresholdVal);
-
-    uint8_t frame[DPMR_HEADER_FRAME_LENGTH_BYTES + 3U];
-    samplesToBits(m_startPtr, DPMR_HEADER_FRAME_LENGTH_SYMBOLS, frame, 8U, m_centreVal, m_thresholdVal);
-
-    frame[0U] = 0x01U;
-
-    writeRSSIHeader(frame);
-
-    m_state   = DPMRRXS_DATA;
-    m_maxCorr = 0;
-  }
-}
-
-void CDPMRRX::processData(q15_t sample)
-{
-  if (m_minFSPtr < m_maxFSPtr) {
-    if (m_dataPtr >= m_minFSPtr && m_dataPtr <= m_maxFSPtr) {
-      correlateFS2();
-      bool ret = correlateFS3();
-      if (ret)
-        m_state = DPMRRXS_EOT;
-    }
-  } else {
-    if (m_dataPtr >= m_minFSPtr || m_dataPtr <= m_maxFSPtr) {
-      correlateFS2();
-      bool ret = correlateFS3();
-      if (ret)
-        m_state = DPMRRXS_EOT;
-    }
-  }
-
-  if (m_dataPtr == m_endPtr) {
-    // Only update the centre and threshold if they are from a good sync
-    if (m_lostCount == MAX_FS2_FRAMES) {
-      m_minFSPtr = m_fsPtr + DPMR_DATA_FRAME_LENGTH_SAMPLES - 1U;
-      if (m_minFSPtr >= DPMR_DATA_FRAME_LENGTH_SAMPLES)
-        m_minFSPtr -= DPMR_DATA_FRAME_LENGTH_SAMPLES;
-
-      m_maxFSPtr = m_fsPtr + 1U;
-      if (m_maxFSPtr >= DPMR_DATA_FRAME_LENGTH_SAMPLES)
-        m_maxFSPtr -= DPMR_DATA_FRAME_LENGTH_SAMPLES;
-    }
-
-    calculateLevels(m_startPtr, DPMR_DATA_FRAME_LENGTH_SYMBOLS);
-
-    DEBUG4("DPMRRX: FS2 sync found pos/centre/threshold", m_fsPtr, m_centreVal, m_thresholdVal);
-
-    uint8_t frame[DPMR_DATA_FRAME_LENGTH_BYTES + 3U];
-    samplesToBits(m_startPtr, DPMR_DATA_FRAME_LENGTH_SYMBOLS, frame, 8U, m_centreVal, m_thresholdVal);
-
-    // We've not seen a data sync for too long, signal RXLOST and change to RX_NONE
-    m_lostCount--;
-    if (m_lostCount == 0U) {
-      DEBUG1("DPMRRX: FS2 sync timed out, lost lock");
-
-      io.setDecode(false);
-      io.setADCDetection(false);
-
-      serial.writeDPMRLost();
-
-      m_state      = DPMRRXS_NONE;
-      m_endPtr     = NOENDPTR;
-      m_averagePtr = NOAVEPTR;
-      m_countdown  = 0U;
-      m_maxCorr    = 0;
-    } else {
-      frame[0U] = m_lostCount == (MAX_FS2_FRAMES - 1U) ? 0x01U : 0x00U;
-      writeRSSIData(frame);
-      m_maxCorr = 0;
-    }
-  }
-}
-
-void CDPMRRX::processEnd(q15_t sample)
-{
-  if (m_dataPtr == m_endPtr) {
-    calculateLevels(m_startPtr, DPMR_END_FRAME_LENGTH_SYMBOLS);
-
-    DEBUG4("DPMRRX: FS3 sync found pos/centre/threshold", m_fsPtr, m_centreVal, m_thresholdVal);
-
-    uint8_t frame[DPMR_END_FRAME_LENGTH_BYTES + 3U];
-    samplesToBits(m_startPtr, DPMR_END_FRAME_LENGTH_SYMBOLS, frame, 8U, m_centreVal, m_thresholdVal);
-
-    frame[0U] = 0x01U;
-
-    io.setDecode(false);
-    io.setADCDetection(false);
-
-    writeRSSIEnd(frame);
-
-    m_state      = DPMRRXS_NONE;
-    m_endPtr     = NOENDPTR;
-    m_averagePtr = NOAVEPTR;
-    m_countdown  = 0U;
-    m_maxCorr    = 0;
-  }
-}
-
-bool CDPMRRX::correlateFS1()
-{
-  if (countBits32(m_bitBuffer[m_bitPtr] ^ DPMR_FS1_SYMBOLS) <= MAX_FS1_SYMBOLS_ERRS) {
-    uint16_t ptr = m_dataPtr + DPMR_HEADER_FRAME_LENGTH_SAMPLES - DPMR_FS1_LENGTH_SAMPLES + DPMR_RADIO_SYMBOL_LENGTH;
-    if (ptr >= DPMR_DATA_FRAME_LENGTH_SAMPLES)
-      ptr -= DPMR_DATA_FRAME_LENGTH_SAMPLES;
-
-    q31_t corr = 0;
-    q15_t min =  16000;
-    q15_t max = -16000;
-
-    for (uint8_t i = 0U; i < DPMR_FS1_LENGTH_SYMBOLS; i++) {
-      q15_t val = m_buffer[ptr];
-
-      if (val > max)
-        max = val;
-      if (val < min)
-        min = val;
-
-      switch (DPMR_FS1_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 += DPMR_RADIO_SYMBOL_LENGTH;
-      if (ptr >= DPMR_DATA_FRAME_LENGTH_SAMPLES)
-        ptr -= DPMR_DATA_FRAME_LENGTH_SAMPLES;
-    }
-
-    if (corr > m_maxCorr) {
-      if (m_averagePtr == NOAVEPTR) {
-        m_centreVal = (max + min) >> 1;
-
-        q31_t v1 = (max - m_centreVal) * SCALING_FACTOR;
-        m_thresholdVal = q15_t(v1 >> 15);
-      }
-
-      uint16_t startPtr = m_dataPtr + DPMR_HEADER_FRAME_LENGTH_SAMPLES - DPMR_FS1_LENGTH_SAMPLES + DPMR_RADIO_SYMBOL_LENGTH;
-      if (startPtr >= DPMR_DATA_FRAME_LENGTH_SAMPLES)
-        startPtr -= DPMR_DATA_FRAME_LENGTH_SAMPLES;
-
-      uint8_t sync[DPMR_FS1_BYTES_LENGTH];
-      samplesToBits(startPtr, DPMR_FS1_LENGTH_SYMBOLS, sync, 0U, m_centreVal, m_thresholdVal);
-
-     uint8_t errs = 0U;
-      for (uint8_t i = 0U; i < DPMR_FS1_BYTES_LENGTH; i++)
-        errs += countBits8(sync[i] ^ DPMR_FS1_BYTES[i]);
-
-      if (errs <= MAX_FS1_BIT_START_ERRS) {
-        m_maxCorr   = corr;
-        m_lostCount = MAX_FS1_FRAMES;
-        m_fsPtr     = m_dataPtr;
-
-        m_startPtr = startPtr;
-
-        m_endPtr = m_dataPtr + DPMR_HEADER_FRAME_LENGTH_SAMPLES - DPMR_FS1_LENGTH_SAMPLES - 1U;
-        if (m_endPtr >= DPMR_DATA_FRAME_LENGTH_SAMPLES)
-          m_endPtr -= DPMR_DATA_FRAME_LENGTH_SAMPLES;
-
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
-bool CDPMRRX::correlateFS2()
-{
-  if (countBits32(m_bitBuffer[m_bitPtr] ^ DPMR_FS2_SYMBOLS) <= MAX_FS2_SYMBOLS_ERRS) {
-    uint16_t ptr = m_dataPtr + DPMR_DATA_FRAME_LENGTH_SAMPLES - DPMR_FS2_LENGTH_SAMPLES + DPMR_RADIO_SYMBOL_LENGTH;
-    if (ptr >= DPMR_DATA_FRAME_LENGTH_SAMPLES)
-      ptr -= DPMR_DATA_FRAME_LENGTH_SAMPLES;
-
-    q31_t corr = 0;
-    q15_t min =  16000;
-    q15_t max = -16000;
-
-    for (uint8_t i = 0U; i < DPMR_FS2_LENGTH_SYMBOLS; i++) {
-      q15_t val = m_buffer[ptr];
-
-      if (val > max)
-        max = val;
-      if (val < min)
-        min = val;
-
-      switch (DPMR_FS2_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 += DPMR_RADIO_SYMBOL_LENGTH;
-      if (ptr >= DPMR_DATA_FRAME_LENGTH_SAMPLES)
-        ptr -= DPMR_DATA_FRAME_LENGTH_SAMPLES;
-    }
-
-    if (corr > m_maxCorr) {
-      if (m_averagePtr == NOAVEPTR) {
-        m_centreVal = (max + min) >> 1;
-
-        q31_t v1 = (max - m_centreVal) * SCALING_FACTOR;
-        m_thresholdVal = q15_t(v1 >> 15);
-      }
-
-      uint16_t startPtr = m_dataPtr + DPMR_DATA_FRAME_LENGTH_SAMPLES - DPMR_FS2_LENGTH_SAMPLES + DPMR_RADIO_SYMBOL_LENGTH;
-      if (startPtr >= DPMR_DATA_FRAME_LENGTH_SAMPLES)
-        startPtr -= DPMR_DATA_FRAME_LENGTH_SAMPLES;
-
-      uint8_t sync[DPMR_FS2_BYTES_LENGTH];
-      samplesToBits(startPtr, DPMR_FS2_LENGTH_SYMBOLS, sync, 0U, m_centreVal, m_thresholdVal);
-
-      uint8_t maxErrs;
-      if (m_state == DPMRRXS_NONE)
-        maxErrs = MAX_FS2_BIT_START_ERRS;
-      else
-        maxErrs = MAX_FS2_BIT_RUN_ERRS;
-
-     uint8_t errs = 0U;
-      for (uint8_t i = 0U; i < DPMR_FS2_BYTES_LENGTH; i++)
-        errs += countBits8(sync[i] ^ DPMR_FS2_BYTES[i]);
-
-      if (errs <= maxErrs) {
-        m_maxCorr   = corr;
-        m_lostCount = MAX_FS2_FRAMES;
-        m_fsPtr     = m_dataPtr;
-
-        m_startPtr = startPtr;
-
-        m_endPtr = m_dataPtr + DPMR_DATA_FRAME_LENGTH_SAMPLES - DPMR_FS2_LENGTH_SAMPLES - 1U;
-        if (m_endPtr >= DPMR_DATA_FRAME_LENGTH_SAMPLES)
-          m_endPtr -= DPMR_DATA_FRAME_LENGTH_SAMPLES;
-
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
-bool CDPMRRX::correlateFS3()
-{
-  if (countBits32(m_bitBuffer[m_bitPtr] ^ DPMR_FS3_SYMBOLS) <= MAX_FS3_SYMBOLS_ERRS) {
-    uint16_t ptr = m_dataPtr + DPMR_END_FRAME_LENGTH_SAMPLES - DPMR_FS3_LENGTH_SAMPLES + DPMR_RADIO_SYMBOL_LENGTH;
-    if (ptr >= DPMR_DATA_FRAME_LENGTH_SAMPLES)
-      ptr -= DPMR_DATA_FRAME_LENGTH_SAMPLES;
-
-    q31_t corr = 0;
-    q15_t min =  16000;
-    q15_t max = -16000;
-
-    for (uint8_t i = 0U; i < DPMR_FS3_LENGTH_SYMBOLS; i++) {
-      q15_t val = m_buffer[ptr];
-
-      if (val > max)
-        max = val;
-      if (val < min)
-        min = val;
-
-      switch (DPMR_FS3_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 += DPMR_RADIO_SYMBOL_LENGTH;
-      if (ptr >= DPMR_DATA_FRAME_LENGTH_SAMPLES)
-        ptr -= DPMR_DATA_FRAME_LENGTH_SAMPLES;
-    }
-
-    if (corr > m_maxCorr) {
-      if (m_averagePtr == NOAVEPTR) {
-        m_centreVal = (max + min) >> 1;
-
-        q31_t v1 = (max - m_centreVal) * SCALING_FACTOR;
-        m_thresholdVal = q15_t(v1 >> 15);
-      }
-
-      uint16_t startPtr = m_dataPtr + DPMR_END_FRAME_LENGTH_SAMPLES - DPMR_FS3_LENGTH_SAMPLES + DPMR_RADIO_SYMBOL_LENGTH;
-      if (startPtr >= DPMR_DATA_FRAME_LENGTH_SAMPLES)
-        startPtr -= DPMR_DATA_FRAME_LENGTH_SAMPLES;
-
-      uint8_t sync[DPMR_FS1_BYTES_LENGTH];
-      samplesToBits(startPtr, DPMR_FS3_LENGTH_SYMBOLS, sync, 0U, m_centreVal, m_thresholdVal);
-
-      uint8_t errs = 0U;
-      for (uint8_t i = 0U; i < DPMR_FS3_BYTES_LENGTH; i++)
-        errs += countBits8(sync[i] ^ DPMR_FS3_BYTES[i]);
-
-      if (errs <= MAX_FS3_BIT_RUN_ERRS) {
-        m_maxCorr   = corr;
-        m_lostCount = MAX_FS3_FRAMES;
-        m_fsPtr     = m_dataPtr;
-
-        m_startPtr = startPtr;
-
-        m_endPtr = m_dataPtr + DPMR_END_FRAME_LENGTH_SAMPLES - DPMR_FS3_LENGTH_SAMPLES - 1U;
-        if (m_endPtr >= DPMR_DATA_FRAME_LENGTH_SAMPLES)
-          m_endPtr -= DPMR_DATA_FRAME_LENGTH_SAMPLES;
-
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
-void CDPMRRX::calculateLevels(uint16_t start, uint16_t count)
-{
-  q15_t maxPos = -16000;
-  q15_t minPos =  16000;
-  q15_t maxNeg =  16000;
-  q15_t minNeg = -16000;
-
-  for (uint16_t i = 0U; i < count; i++) {
-    q15_t sample = m_buffer[start];
-
-    if (sample > 0) {
-      if (sample > maxPos)
-        maxPos = sample;
-      if (sample < minPos)
-        minPos = sample;
-    } else {
-      if (sample < maxNeg)
-        maxNeg = sample;
-      if (sample > minNeg)
-        minNeg = sample;
-    }
-
-    start += DPMR_RADIO_SYMBOL_LENGTH;
-    if (start >= DPMR_FRAME_LENGTH_SAMPLES)
-      start -= DPMR_FRAME_LENGTH_SAMPLES;
-  }
-
-  q15_t posThresh = (maxPos + minPos) >> 1;
-  q15_t negThresh = (maxNeg + minNeg) >> 1;
-
-  q15_t centre = (posThresh + negThresh) >> 1;
-
-  q15_t threshold = posThresh - centre;
-
-  DEBUG5("DPMRRX: pos/neg/centre/threshold", posThresh, negThresh, centre, threshold);
-
-  if (m_averagePtr == NOAVEPTR) {
-    for (uint8_t i = 0U; i < 16U; i++) {
-      m_centre[i] = centre;
-      m_threshold[i] = threshold;
-    }
-
-    m_averagePtr = 0U;
-  } else {
-    m_centre[m_averagePtr] = centre;
-    m_threshold[m_averagePtr] = threshold;
-
-    m_averagePtr++;
-    if (m_averagePtr >= 16U)
-      m_averagePtr = 0U;
-  }
-
-  m_centreVal = 0;
-  m_thresholdVal = 0;
-
-  for (uint8_t i = 0U; i < 16U; i++) {
-    m_centreVal += m_centre[i];
-    m_thresholdVal += m_threshold[i];
-  }
-
-  m_centreVal >>= 4;
-  m_thresholdVal >>= 4;
-}
-
-void CDPMRRX::samplesToBits(uint16_t start, uint16_t count, uint8_t* buffer, uint16_t offset, q15_t centre, q15_t threshold)
-{
-  for (uint16_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 += DPMR_RADIO_SYMBOL_LENGTH;
-    if (start >= DPMR_FRAME_LENGTH_SAMPLES)
-      start -= DPMR_FRAME_LENGTH_SAMPLES;
-  }
-}
-
-void CDPMRRX::writeRSSIHeader(uint8_t* data)
-{
-#if defined(SEND_RSSI_DATA)
-  if (m_rssiCount > 0U) {
-    uint16_t rssi = m_rssiAccum / m_rssiCount;
-
-    data[49U] = (rssi >> 8) & 0xFFU;
-    data[50U] = (rssi >> 0) & 0xFFU;
-
-    serial.writeDPMRHeader(data, DPMR_HEADER_FRAME_LENGTH_BYTES + 3U);
-  } else {
-    serial.writeDPMRHeader(data, DPMR_HEADER_FRAME_LENGTH_BYTES + 1U);
-  }
-#else
-  serial.writeDPMRHeader(data, DPMR_HEADER_FRAME_LENGTH_BYTES + 1U);
-#endif
-
-  m_rssiAccum = 0U;
-  m_rssiCount = 0U;
-}
-
-void CDPMRRX::writeRSSIData(uint8_t* data)
-{
-#if defined(SEND_RSSI_DATA)
-  if (m_rssiCount > 0U) {
-    uint16_t rssi = m_rssiAccum / m_rssiCount;
-
-    data[49U] = (rssi >> 8) & 0xFFU;
-    data[50U] = (rssi >> 0) & 0xFFU;
-
-    serial.writeDPMRData(data, DPMR_DATA_FRAME_LENGTH_BYTES + 3U);
-  } else {
-    serial.writeDPMRData(data, DPMR_DATA_FRAME_LENGTH_BYTES + 1U);
-  }
-#else
-  serial.writeDPMRData(data, DPMR_DATA_FRAME_LENGTH_BYTES + 1U);
-#endif
-
-  m_rssiAccum = 0U;
-  m_rssiCount = 0U;
-}
-
-#endif
-

DPMRRX.h

@@ -1,82 +0,0 @@
-/*
- *   Copyright (C) 2015,2016,2017,2018,2020,2024 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_DPMR)
-
-#if !defined(DPMRRX_H)
-#define  DPMRRX_H
-
-#include "DPMRDefines.h"
-
-enum DPMRRX_STATE {
-  DPMRRXS_NONE,
-  DPMRRXS_HEADER,
-  DPMRRXS_DATA,
-  DPMRRXS_END
-};
-
-class CDPMRRX {
-public:
-  CDPMRRX();
-
-  void samples(const q15_t* samples, uint16_t* rssi, uint8_t length);
-
-  void reset();
-
-private:
-  DPMRRX_STATE m_state;
-  uint32_t     m_bitBuffer[DPMR_RADIO_SYMBOL_LENGTH];
-  q15_t        m_buffer[DPMR_DATA_FRAME_LENGTH_SAMPLES];
-  uint16_t     m_bitPtr;
-  uint16_t     m_dataPtr;
-  uint16_t     m_startPtr;
-  uint16_t     m_endPtr;
-  uint16_t     m_fsPtr;
-  uint16_t     m_minFSPtr;
-  uint16_t     m_maxFSPtr;
-  q31_t        m_maxCorr;
-  uint16_t     m_lostCount;
-  uint8_t      m_countdown;
-  q15_t        m_centre[16U];
-  q15_t        m_centreVal;
-  q15_t        m_threshold[16U];
-  q15_t        m_thresholdVal;
-  uint8_t      m_averagePtr;
-  uint32_t     m_rssiAccum;
-  uint16_t     m_rssiCount;
-
-  void processNone(q15_t sample);
-  void processHeader(q15_t sample);
-  void processData(q15_t sample);
-  void processEnd(q15_t sample);
-  bool correlateFS1();
-  bool correlateFS2();
-  bool correlateFS3();
-  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 writeRSSIHeader(uint8_t* data);
-  void writeRSSIData(uint8_t* data);
-  void writeRSSIEnd(uint8_t* data);
-};
-
-#endif
-
-#endif
-

DPMRTX.cpp

@@ -1,238 +0,0 @@
-/*
- *   Copyright (C) 2009-2018,2020,2024 by Jonathan Naylor G4KLX
- *   Copyright (C) 2017 by Andy Uribe CA6JAU
- *
- *   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_DPMR)
-
-#include "Globals.h"
-#include "DPMRTX.h"
-
-#include "DPMRDefines.h"
-
-// Generated using rcosdesign(0.2, 8, 10, 'sqrt') in MATLAB
-static q15_t RRC_0_2_FILTER[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 850, 592, 219, -234, -720, -1179, -1548, -1769, -1795, -1597, -1172,
-                                 -544, 237, 1092, 1927, 2637, 3120, 3286, 3073, 2454, 1447, 116, -1431, -3043, -4544, -5739, -6442,
-                                 -6483, -5735, -4121, -1633, 1669, 5651, 10118, 14822, 19484, 23810, 27520, 30367, 32156, 32767,
-                                 32156, 30367, 27520, 23810, 19484, 14822, 10118, 5651, 1669, -1633, -4121, -5735, -6483, -6442,
-                                 -5739, -4544, -3043, -1431, 116, 1447, 2454, 3073, 3286, 3120, 2637, 1927, 1092, 237, -544, -1172,
-                                 -1597, -1795, -1769, -1548, -1179, -720, -234, 219, 592, 850}; // numTaps = 90, L = 10
-const uint16_t RRC_0_2_FILTER_PHASE_LEN = 9U; // phaseLength = numTaps/L
-
-static q15_t DPMR_SINC_FILTER[] = {572, -1003, -253, 254, 740, 1290, 1902, 2527, 3090, 3517, 3747, 3747, 3517, 3090, 2527, 1902,
-                                   1290, 740, 254, -253, -1003, 572};
-const uint16_t DPMR_SINC_FILTER_LEN = 22U;
-
-const q15_t DPMR_LEVELA =  735;
-const q15_t DPMR_LEVELB =  245;
-const q15_t DPMR_LEVELC = -245;
-const q15_t DPMR_LEVELD = -735;
-
-const uint8_t DPMR_PREAMBLE[] = {0x57U, 0x75U, 0xFDU};
-const uint8_t DPMR_SYNC = 0x5FU;
-
-CDPMRTX::CDPMRTX() :
-m_buffer(TX_BUFFER_LEN),
-m_modFilter(),
-m_sincFilter(),
-m_modState(),
-m_sincState(),
-m_poBuffer(),
-m_poLen(0U),
-m_poPtr(0U),
-m_txDelay(240U),     // 200ms
-m_txHang(3000U),     // 5s
-m_txCount(0U)
-{
-  ::memset(m_modState, 0x00U, 16U * sizeof(q15_t));
-  ::memset(m_sincState, 0x00U, 70U * sizeof(q15_t));
-
-  m_modFilter.L           = DPMR_RADIO_SYMBOL_LENGTH;
-  m_modFilter.phaseLength = RRC_0_2_FILTER_PHASE_LEN;
-  m_modFilter.pCoeffs     = RRC_0_2_FILTER;
-  m_modFilter.pState      = m_modState;
-
-  m_sincFilter.numTaps = DPMR_SINC_FILTER_LEN;
-  m_sincFilter.pState  = m_sincState;
-  m_sincFilter.pCoeffs = DPMR_SINC_FILTER;
-}
-
-void CDPMRTX::process()
-{
-  if (m_poLen == 0U && m_buffer.getData() > 0U) {
-    if (!m_tx) {
-      for (uint16_t i = 0U; i < m_txDelay; i++)
-        m_poBuffer[m_poLen++] = DPMR_SYNC;
-      m_poBuffer[m_poLen++] = DPMR_PREAMBLE[0U];
-      m_poBuffer[m_poLen++] = DPMR_PREAMBLE[1U];
-      m_poBuffer[m_poLen++] = DPMR_PREAMBLE[2U];
-    } else {
-      for (uint8_t i = 0U; i < DPMR_FRAME_LENGTH_BYTES; i++) {
-        uint8_t c = 0U;
-        m_buffer.get(c);
-        m_poBuffer[m_poLen++] = c;
-      }
-    }
-
-    m_poPtr = 0U;
-  }
-
-  if (m_poLen > 0U) {
-    uint16_t space = io.getSpace();
-    
-    while (space > (4U * DPMR_RADIO_SYMBOL_LENGTH)) {
-      uint8_t c = m_poBuffer[m_poPtr++];
-      writeByte(c);
-
-      space -= 4U * DPMR_RADIO_SYMBOL_LENGTH;
-      if (m_duplex)
-        m_txCount = m_txHang;
-      
-      if (m_poPtr >= m_poLen) {
-        m_poPtr = 0U;
-        m_poLen = 0U;
-        return;
-      }
-    }
-  } else if (m_txCount > 0U) {
-    // Transmit silence until the hang timer has expired.
-    uint16_t space = io.getSpace();
-
-    while (space > (4U * DPMR_RADIO_SYMBOL_LENGTH)) {
-      writeSilence();
-
-      space -= 4U * DPMR_RADIO_SYMBOL_LENGTH;
-      m_txCount--;
-
-      if (m_txCount == 0U)
-        return;
-    }
-  }
-}
-
-uint8_t CDPMRTX::writeHeader(const uint8_t* data, uint16_t length)
-{
-  if (length != (DPMR_HEADER_FRAME_LENGTH_BYTES + 1U))
-    return 4U;
-
-  uint16_t space = m_buffer.getSpace();
-  if (space < DPMR_HEADER_FRAME_LENGTH_BYTES)
-    return 5U;
-
-  for (uint8_t i = 0U; i < DPMR_HEADER_FRAME_LENGTH_BYTES; i++)
-    m_buffer.put(data[i + 1U]);
-
-  return 0U;
-}
-
-uint8_t CDPMRTX::writeData(const uint8_t* data, uint16_t length)
-{
-  if (length != (DPMR_DATA_FRAME_LENGTH_BYTES + 1U))
-    return 4U;
-
-  uint16_t space = m_buffer.getSpace();
-  if (space < DPMR_DATA_FRAME_LENGTH_BYTES)
-    return 5U;
-
-  for (uint8_t i = 0U; i < DPMR_DATA_FRAME_LENGTH_BYTES; i++)
-    m_buffer.put(data[i + 1U]);
-
-  return 0U;
-}
-
-uint8_t CDPMRTX::writeEOT(const uint8_t* data, uint16_t length)
-{
-  if (length != (DPMR_END_FRAME_LENGTH_BYTES + 1U))
-    return 4U;
-
-  uint16_t space = m_buffer.getSpace();
-  if (space < DPMR_END_FRAME_LENGTH_BYTES)
-    return 5U;
-
-  for (uint8_t i = 0U; i < DPMR_END_FRAME_LENGTH_BYTES; i++)
-    m_buffer.put(data[i + 1U]);
-
-  return 0U;
-}
-
-void CDPMRTX::writeByte(uint8_t c)
-{
-  q15_t inBuffer[4U];
-  q15_t intBuffer[DPMR_RADIO_SYMBOL_LENGTH * 4U];
-  q15_t outBuffer[DPMR_RADIO_SYMBOL_LENGTH * 4U];
-
-  const uint8_t MASK = 0xC0U;
-
-  for (uint8_t i = 0U; i < 4U; i++, c <<= 2) {
-    switch (c & MASK) {
-      case 0xC0U:
-        inBuffer[i] = DPMR_LEVELA;
-        break;
-      case 0x80U:
-        inBuffer[i] = DPMR_LEVELB;
-        break;
-      case 0x00U:
-        inBuffer[i] = DPMR_LEVELC;
-        break;
-      default:
-        inBuffer[i] = DPMR_LEVELD;
-        break;
-    }
-  }
-
-  ::arm_fir_interpolate_q15(&m_modFilter, inBuffer, intBuffer, 4U);
-
-  ::arm_fir_fast_q15(&m_sincFilter, intBuffer, outBuffer, DPMR_RADIO_SYMBOL_LENGTH * 4U);
-
-  io.write(STATE_DPMR, outBuffer, DPMR_RADIO_SYMBOL_LENGTH * 4U);
-}
-
-void CDPMRTX::writeSilence()
-{
-  q15_t inBuffer[4U] = {0x00U, 0x00U, 0x00U, 0x00U};
-  q15_t intBuffer[DPMR_RADIO_SYMBOL_LENGTH * 4U];
-  q15_t outBuffer[DPMR_RADIO_SYMBOL_LENGTH * 4U];
-
-  ::arm_fir_interpolate_q15(&m_modFilter, inBuffer, intBuffer, 4U);
-
-  ::arm_fir_fast_q15(&m_sincFilter, intBuffer, outBuffer, DPMR_RADIO_SYMBOL_LENGTH * 4U);
-
-  io.write(STATE_DPMR, outBuffer, DPMR_RADIO_SYMBOL_LENGTH * 4U);
-}
-
-void CDPMRTX::setTXDelay(uint8_t delay)
-{
-  m_txDelay = 300U + uint16_t(delay) * 6U;        // 500ms + tx delay
-
-  if (m_txDelay > 1200U)
-    m_txDelay = 1200U;
-}
-
-uint8_t CDPMRTX::getSpace() const
-{
-  return m_buffer.getSpace() / DPMR_FRAME_LENGTH_BYTES;
-}
-
-void CDPMRTX::setParams(uint8_t txHang)
-{
-  m_txHang = txHang * 600U;
-}
-
-#endif
-

DPMRTX.h

@@ -1,64 +0,0 @@
-/*
- *   Copyright (C) 2015,2016,2017,2018,2020,2024 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_DPMR)
-
-#if !defined(DPMRTX_H)
-#define  DPMRTX_H
-
-#include "RingBuffer.h"
-
-class CDPMRTX {
-public:
-  CDPMRTX();
-
-  uint8_t writeHeader(const uint8_t* data, uint16_t length);
-  uint8_t writeData(const uint8_t* data, uint16_t length);
-  uint8_t writeEOT(const uint8_t* data, uint16_t length);
-
-  void process();
-
-  void setTXDelay(uint8_t delay);
-
-  uint8_t getSpace() const;
-
-  void setParams(uint8_t txHang);
-
-private:
-  CRingBuffer<uint8_t>             m_buffer;
-  arm_fir_interpolate_instance_q15 m_modFilter;
-  arm_fir_instance_q15             m_sincFilter;
-  q15_t                            m_modState[16U];    // blockSize + phaseLength - 1, 4 + 9 - 1 plus some spare
-  q15_t                            m_sincState[70U];   // NoTaps + BlockSize - 1, 22 + 40 - 1 plus some spare
-  uint8_t                          m_poBuffer[1200U];
-  uint16_t                         m_poLen;
-  uint16_t                         m_poPtr;
-  uint16_t                         m_txDelay;
-  uint32_t                         m_txHang;
-  uint32_t                         m_txCount;
-
-  void writeByte(uint8_t c);
-  void writeSilence();
-};
-
-#endif
-
-#endif
-

FM.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2020,2021 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020,2021,2023 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
@@ -28,6 +28,19 @@ const uint16_t FM_SERIAL_BLOCK_SIZE = 80U;//this is the number of sample pairs t
                                           //three times this value shall never exceed 252
 const uint16_t FM_SERIAL_BLOCK_SIZE_BYTES = FM_SERIAL_BLOCK_SIZE * 3U;
 
+const uint8_t FS_LISTENING         = 0U;
+const uint8_t FS_KERCHUNK_RF       = 1U;
+const uint8_t FS_RELAYING_RF       = 2U;
+const uint8_t FS_RELAYING_WAIT_RF  = 3U;
+const uint8_t FS_TIMEOUT_RF        = 4U;
+const uint8_t FS_TIMEOUT_WAIT_RF   = 5U;
+const uint8_t FS_KERCHUNK_EXT      = 6U;
+const uint8_t FS_RELAYING_EXT      = 7U;
+const uint8_t FS_RELAYING_WAIT_EXT = 8U;
+const uint8_t FS_TIMEOUT_EXT       = 9U;
+const uint8_t FS_TIMEOUT_WAIT_EXT  = 10U;
+const uint8_t FS_HANG              = 11U;
+
 
 CFM::CFM() :
 m_callsign(),
@@ -48,7 +61,6 @@ m_kerchunkTimer(),
 m_ackMinTimer(),
 m_ackDelayTimer(),
 m_hangTimer(),
-m_statusTimer(),
 m_reverseTimer(),
 m_needReverse(false),
 m_filterStage1(  724,   1448,   724, 32768, -37895, 21352),//3rd order Cheby Filter 300 to 2700Hz, 0.2dB passband ripple, sampling rate 24kHz
@@ -68,23 +80,24 @@ m_inputRFRB(2401U),   // 100ms of audio + 1 sample
 m_outputRFRB(2400U),  // 100ms of audio
 m_inputExtRB(),
 m_rfSignal(false),
-m_extSignal(false)
+m_extSignal(false),
+m_rssiAccum(0U),
+m_rssiCount(0U)
 {
-  m_statusTimer.setTimeout(1U, 0U);
   m_reverseTimer.setTimeout(0U, 150U);
 
   insertDelay(100U);
 }
 
-void CFM::samples(bool cos, q15_t* samples, uint8_t length)
+void CFM::samples(bool cos, q15_t* samples, const uint16_t* rssi, uint8_t length)
 {
   if (m_linkMode)
     linkSamples(cos, samples, length);
   else
-    repeaterSamples(cos, samples, length);
+    repeaterSamples(cos, samples, rssi, length);
 }
 
-void CFM::repeaterSamples(bool cos, q15_t* samples, uint8_t length)
+void CFM::repeaterSamples(bool cos, q15_t* samples, const uint16_t* rssi, uint8_t length)
 {
   if (m_cosInvert)
     cos = !cos;
@@ -93,6 +106,11 @@ void CFM::repeaterSamples(bool cos, q15_t* samples, uint8_t length)
 
   uint8_t i = 0U;
   for (; i < length; i++) {
+    if (m_state == FS_RELAYING_RF) {
+      m_rssiAccum += rssi[i];
+      m_rssiCount++;
+    }
+
     // ARMv7-M has hardware integer division 
     q15_t currentRFSample = q15_t((q31_t(samples[i]) << 8) / m_rxLevel);
 
@@ -377,7 +395,6 @@ void CFM::reset()
   m_ackMinTimer.stop();
   m_ackDelayTimer.stop();
   m_hangTimer.stop();
-  m_statusTimer.stop();
   m_reverseTimer.stop();
 
   m_ctcssRX.reset();
@@ -583,13 +600,7 @@ void CFM::clock(uint8_t length)
   m_ackMinTimer.clock(length);
   m_ackDelayTimer.clock(length);
   m_hangTimer.clock(length);
-  m_statusTimer.clock(length);
   m_reverseTimer.clock(length);
-
-  if (m_statusTimer.isRunning() && m_statusTimer.hasExpired()) {
-    serial.writeFMStatus(m_state);
-    m_statusTimer.start();
-  }
 }
 
 void CFM::listeningStateDuplex(bool validRFSignal, bool validExtSignal)
@@ -598,12 +609,19 @@ void CFM::listeningStateDuplex(bool validRFSignal, bool validExtSignal)
     if (m_kerchunkTimer.getTimeout() > 0U) {
       DEBUG1("State to KERCHUNK_RF");
       m_state = FS_KERCHUNK_RF;
+      serial.writeFMStatus(m_state);
+
       m_kerchunkTimer.start();
       if (m_callsignAtStart && !m_callsignAtLatch)
         sendCallsign();
     } else {
       DEBUG1("State to RELAYING_RF");
       m_state = FS_RELAYING_RF;
+      serial.writeFMStatus(m_state);
+
+      m_rssiAccum = 0U;
+      m_rssiCount = 0U;
+
       if (m_callsignAtStart)
         sendCallsign();
     }
@@ -618,20 +636,21 @@ void CFM::listeningStateDuplex(bool validRFSignal, bool validExtSignal)
 
       io.setDecode(true);
       io.setADCDetection(true);
-
-      m_statusTimer.start();
-      serial.writeFMStatus(m_state);
     }
   } else if (validExtSignal) {
     if (m_kerchunkTimer.getTimeout() > 0U) {
       DEBUG1("State to KERCHUNK_EXT");
       m_state = FS_KERCHUNK_EXT;
+      serial.writeFMStatus(m_state);
+
       m_kerchunkTimer.start();
       if (m_callsignAtStart && !m_callsignAtLatch)
         sendCallsign();
     } else {
       DEBUG1("State to RELAYING_EXT");
       m_state = FS_RELAYING_EXT;
+      serial.writeFMStatus(m_state);
+
       if (m_callsignAtStart)
         sendCallsign();
     }
@@ -643,9 +662,6 @@ void CFM::listeningStateDuplex(bool validRFSignal, bool validExtSignal)
 
       m_callsignTimer.start();
       m_reverseTimer.stop();
-
-      m_statusTimer.start();
-      serial.writeFMStatus(m_state);
     }
   }
 }
@@ -655,26 +671,22 @@ void CFM::listeningStateSimplex(bool validRFSignal, bool validExtSignal)
   if (validRFSignal) {
     DEBUG1("State to RELAYING_RF");
     m_state = FS_RELAYING_RF;
+    serial.writeFMStatus(m_state);
 
     io.setDecode(true);
     io.setADCDetection(true);
 
     m_timeoutTimer.start();
     m_reverseTimer.stop();
-
-    m_statusTimer.start();
-    serial.writeFMStatus(m_state);
   } else if (validExtSignal) {
     DEBUG1("State to RELAYING_EXT");
     m_state = FS_RELAYING_EXT;
+    serial.writeFMStatus(m_state);
 
     insertSilence(50U);
 
     m_timeoutTimer.start();
     m_reverseTimer.stop();
-
-    m_statusTimer.start();
-    serial.writeFMStatus(m_state);
   }
 }
 
@@ -684,6 +696,11 @@ void CFM::kerchunkRFStateDuplex(bool validSignal)
     if (m_kerchunkTimer.hasExpired()) {
       DEBUG1("State to RELAYING_RF");
       m_state = FS_RELAYING_RF;
+      serial.writeFMStatus(m_state);
+
+      m_rssiAccum = 0U;
+      m_rssiCount = 0U;
+
       m_kerchunkTimer.stop();
       if (m_callsignAtStart && m_callsignAtLatch) {
         sendCallsign();
@@ -696,11 +713,12 @@ void CFM::kerchunkRFStateDuplex(bool validSignal)
 
     DEBUG1("State to LISTENING");
     m_state = FS_LISTENING;
+    serial.writeFMStatus(m_state);
+
     m_kerchunkTimer.stop();
     m_timeoutTimer.stop();
     m_ackMinTimer.stop();
     m_callsignTimer.stop();
-    m_statusTimer.stop();
     m_needReverse = true;
     if (m_extEnabled)
       serial.writeFMEOT();
@@ -710,9 +728,21 @@ void CFM::kerchunkRFStateDuplex(bool validSignal)
 void CFM::relayingRFStateDuplex(bool validSignal)
 {
   if (validSignal) {
+#if defined(SEND_RSSI_DATA)
+    if (m_rssiCount >= 24000U) {
+      uint16_t rssi = m_rssiAccum / m_rssiCount;
+      serial.writeFMRSSI(rssi);
+
+      m_rssiAccum = 0U;
+      m_rssiCount = 0U;
+    }
+#endif
+
     if (m_timeoutTimer.isRunning() && m_timeoutTimer.hasExpired()) {
       DEBUG1("State to TIMEOUT_RF");
       m_state = FS_TIMEOUT_RF;
+      serial.writeFMStatus(m_state);
+
       m_ackMinTimer.stop();
       m_timeoutTimer.stop();
       m_timeoutTone.start();
@@ -726,6 +756,8 @@ void CFM::relayingRFStateDuplex(bool validSignal)
 
     DEBUG1("State to RELAYING_WAIT_RF");
     m_state = FS_RELAYING_WAIT_RF;
+    serial.writeFMStatus(m_state);
+
     m_ackDelayTimer.start();
 
     if (m_extEnabled)
@@ -744,6 +776,7 @@ void CFM::relayingRFStateSimplex(bool validSignal)
     if (m_timeoutTimer.isRunning() && m_timeoutTimer.hasExpired()) {
       DEBUG1("State to TIMEOUT_RF");
       m_state = FS_TIMEOUT_RF;
+      serial.writeFMStatus(m_state);
 
       m_timeoutTimer.stop();
 
@@ -756,6 +789,8 @@ void CFM::relayingRFStateSimplex(bool validSignal)
 
     DEBUG1("State to RELAYING_WAIT_RF");
     m_state = FS_RELAYING_WAIT_RF;
+    serial.writeFMStatus(m_state);
+
     m_ackDelayTimer.start();
 
     if (m_extEnabled)
@@ -771,11 +806,17 @@ void CFM::relayingRFWaitStateDuplex(bool validSignal)
 
     DEBUG1("State to RELAYING_RF");
     m_state = FS_RELAYING_RF;
+    serial.writeFMStatus(m_state);
+
+    m_rssiAccum = 0U;
+    m_rssiCount = 0U;
+
     m_ackDelayTimer.stop();
   } else {
     if (m_ackDelayTimer.isRunning() && m_ackDelayTimer.hasExpired()) {
       DEBUG1("State to HANG");
       m_state = FS_HANG;
+      serial.writeFMStatus(m_state);
 
       if (m_ackMinTimer.isRunning()) {
         if (m_ackMinTimer.hasExpired()) {
@@ -809,11 +850,15 @@ void CFM::relayingRFWaitStateSimplex(bool validSignal)
 
     DEBUG1("State to RELAYING_RF");
     m_state = FS_RELAYING_RF;
+    serial.writeFMStatus(m_state);
+
     m_ackDelayTimer.stop();
   } else {
     if (m_ackDelayTimer.isRunning() && m_ackDelayTimer.hasExpired()) {
       DEBUG1("State to LISTENING");
       m_state = FS_LISTENING;
+      serial.writeFMStatus(m_state);
+
       m_ackDelayTimer.stop();
       m_timeoutTimer.stop();
     }
@@ -826,6 +871,8 @@ void CFM::kerchunkExtStateDuplex(bool validSignal)
     if (m_kerchunkTimer.hasExpired()) {
       DEBUG1("State to RELAYING_EXT");
       m_state = FS_RELAYING_EXT;
+      serial.writeFMStatus(m_state);
+
       m_kerchunkTimer.stop();
       if (m_callsignAtStart && m_callsignAtLatch) {
         sendCallsign();
@@ -835,11 +882,12 @@ void CFM::kerchunkExtStateDuplex(bool validSignal)
   } else {
     DEBUG1("State to LISTENING");
     m_state = FS_LISTENING;
+    serial.writeFMStatus(m_state);
+
     m_kerchunkTimer.stop();
     m_timeoutTimer.stop();
     m_ackMinTimer.stop();
     m_callsignTimer.stop();
-    m_statusTimer.stop();
     m_needReverse = true;
   }
 }
@@ -850,6 +898,8 @@ void CFM::relayingExtStateDuplex(bool validSignal)
     if (m_timeoutTimer.isRunning() && m_timeoutTimer.hasExpired()) {
       DEBUG1("State to TIMEOUT_EXT");
       m_state = FS_TIMEOUT_EXT;
+      serial.writeFMStatus(m_state);
+
       m_ackMinTimer.stop();
       m_timeoutTimer.stop();
       m_timeoutTone.start();
@@ -857,6 +907,7 @@ void CFM::relayingExtStateDuplex(bool validSignal)
   } else {
     DEBUG1("State to RELAYING_WAIT_EXT");
     m_state = FS_RELAYING_WAIT_EXT;
+    serial.writeFMStatus(m_state);
     m_ackDelayTimer.start();
   }
 
@@ -872,12 +923,14 @@ void CFM::relayingExtStateSimplex(bool validSignal)
     if (m_timeoutTimer.isRunning() && m_timeoutTimer.hasExpired()) {
       DEBUG1("State to TIMEOUT_EXT");
       m_state = FS_TIMEOUT_EXT;
+      serial.writeFMStatus(m_state);
 
       m_timeoutTimer.stop();
     }
   } else {
     DEBUG1("State to RELAYING_WAIT_EXT");
     m_state = FS_RELAYING_WAIT_EXT;
+    serial.writeFMStatus(m_state);
     m_ackDelayTimer.start();
   }
 }
@@ -887,11 +940,13 @@ void CFM::relayingExtWaitStateDuplex(bool validSignal)
   if (validSignal) {
     DEBUG1("State to RELAYING_EXT");
     m_state = FS_RELAYING_EXT;
+    serial.writeFMStatus(m_state);
     m_ackDelayTimer.stop();
   } else {
     if (m_ackDelayTimer.isRunning() && m_ackDelayTimer.hasExpired()) {
       DEBUG1("State to HANG");
       m_state = FS_HANG;
+      serial.writeFMStatus(m_state);
 
       if (m_ackMinTimer.isRunning()) {
         if (m_ackMinTimer.hasExpired()) {
@@ -922,11 +977,14 @@ void CFM::relayingExtWaitStateSimplex(bool validSignal)
   if (validSignal) {
     DEBUG1("State to RELAYING_EXT");
     m_state = FS_RELAYING_EXT;
+    serial.writeFMStatus(m_state);
     m_ackDelayTimer.stop();
   } else {
     if (m_ackDelayTimer.isRunning() && m_ackDelayTimer.hasExpired()) {
       DEBUG1("State to LISTENING");
       m_state = FS_LISTENING;
+      serial.writeFMStatus(m_state);
+
       m_ackDelayTimer.stop();
       m_timeoutTimer.stop();
       m_needReverse = true;
@@ -942,6 +1000,11 @@ void CFM::hangStateDuplex(bool validRFSignal, bool validExtSignal)
 
     DEBUG1("State to RELAYING_RF");
     m_state = FS_RELAYING_RF;
+    serial.writeFMStatus(m_state);
+
+    m_rssiAccum = 0U;
+    m_rssiCount = 0U;
+
     DEBUG1("Stop ack");
     m_rfAck.stop();
     m_extAck.stop();
@@ -949,6 +1012,8 @@ void CFM::hangStateDuplex(bool validRFSignal, bool validExtSignal)
   } else if (validExtSignal) {
     DEBUG1("State to RELAYING_EXT");
     m_state = FS_RELAYING_EXT;
+    serial.writeFMStatus(m_state);
+
     DEBUG1("Stop ack");
     m_rfAck.stop();
     m_extAck.stop();
@@ -957,8 +1022,9 @@ void CFM::hangStateDuplex(bool validRFSignal, bool validExtSignal)
     if (m_hangTimer.isRunning() && m_hangTimer.hasExpired()) {
       DEBUG1("State to LISTENING");
       m_state = FS_LISTENING;
+      serial.writeFMStatus(m_state);
+
       m_hangTimer.stop();
-      m_statusTimer.stop();
 
       if (m_callsignAtEnd)
         sendCallsign();
@@ -982,6 +1048,7 @@ void CFM::timeoutRFStateDuplex(bool validSignal)
 
     DEBUG1("State to TIMEOUT_WAIT_RF");
     m_state = FS_TIMEOUT_WAIT_RF;
+    serial.writeFMStatus(m_state);
 
     if (m_callsignAtEnd)
         sendCallsign();
@@ -1003,6 +1070,7 @@ void CFM::timeoutRFStateSimplex(bool validSignal)
 
     DEBUG1("State to TIMEOUT_WAIT_RF");
     m_state = FS_TIMEOUT_WAIT_RF;
+    serial.writeFMStatus(m_state);
 
     m_ackDelayTimer.start();
   }
@@ -1016,11 +1084,14 @@ void CFM::timeoutRFWaitStateDuplex(bool validSignal)
 
     DEBUG1("State to TIMEOUT_RF");
     m_state = FS_TIMEOUT_RF;
+    serial.writeFMStatus(m_state);
     m_ackDelayTimer.stop();
   } else {
     if (m_ackDelayTimer.isRunning() && m_ackDelayTimer.hasExpired()) {
       DEBUG1("State to HANG");
       m_state = FS_HANG;
+      serial.writeFMStatus(m_state);
+
       m_timeoutTone.stop();
       DEBUG1("Send RF ack");
       m_rfAck.start();
@@ -1045,11 +1116,14 @@ void CFM::timeoutRFWaitStateSimplex(bool validSignal)
 
     DEBUG1("State to TIMEOUT_RF");
     m_state = FS_TIMEOUT_RF;
+    serial.writeFMStatus(m_state);
     m_ackDelayTimer.stop();
   } else {
     if (m_ackDelayTimer.isRunning() && m_ackDelayTimer.hasExpired()) {
       DEBUG1("State to LISTENING");
       m_state = FS_LISTENING;
+      serial.writeFMStatus(m_state);
+
       m_ackDelayTimer.stop();
       m_timeoutTimer.stop();
     }
@@ -1061,6 +1135,7 @@ void CFM::timeoutExtStateDuplex(bool validSignal)
   if (!validSignal) {
     DEBUG1("State to TIMEOUT_WAIT_EXT");
     m_state = FS_TIMEOUT_WAIT_EXT;
+    serial.writeFMStatus(m_state);
     m_ackDelayTimer.start();
   }
 
@@ -1075,6 +1150,7 @@ void CFM::timeoutExtStateSimplex(bool validSignal)
   if (!validSignal) {
     DEBUG1("State to TIMEOUT_WAIT_EXT");
     m_state = FS_TIMEOUT_WAIT_EXT;
+    serial.writeFMStatus(m_state);
     m_ackDelayTimer.start();
   }
 }
@@ -1084,11 +1160,14 @@ void CFM::timeoutExtWaitStateDuplex(bool validSignal)
   if (validSignal) {
     DEBUG1("State to TIMEOUT_EXT");
     m_state = FS_TIMEOUT_EXT;
+    serial.writeFMStatus(m_state);
     m_ackDelayTimer.stop();
   } else {
     if (m_ackDelayTimer.isRunning() && m_ackDelayTimer.hasExpired()) {
       DEBUG1("State to HANG");
       m_state = FS_HANG;
+      serial.writeFMStatus(m_state);
+
       m_timeoutTone.stop();
       DEBUG1("Send Ext ack");
       m_extAck.start();
@@ -1110,11 +1189,14 @@ void CFM::timeoutExtWaitStateSimplex(bool validSignal)
   if (validSignal) {
     DEBUG1("State to TIMEOUT_EXT");
     m_state = FS_TIMEOUT_EXT;
+    serial.writeFMStatus(m_state);
     m_ackDelayTimer.stop();
   } else {
     if (m_ackDelayTimer.isRunning() && m_ackDelayTimer.hasExpired()) {
       DEBUG1("State to LISTENING");
       m_state = FS_LISTENING;
+      serial.writeFMStatus(m_state);
+
       m_ackDelayTimer.stop();
       m_timeoutTimer.stop();
       m_needReverse = true;
@@ -1131,7 +1213,6 @@ void CFM::linkStateMachine(bool validRFSignal, bool validExtSignal)
     if (!m_extSignal) {
       DEBUG1("State to RELAYING_RF");
       m_state = FS_RELAYING_RF;
-      m_statusTimer.start();
       serial.writeFMStatus(m_state);
     }
 
@@ -1142,7 +1223,6 @@ void CFM::linkStateMachine(bool validRFSignal, bool validExtSignal)
     if (!m_rfSignal) {
       DEBUG1("State to RELAYING_EXT");
       m_state = FS_RELAYING_EXT;
-      m_statusTimer.start();
       serial.writeFMStatus(m_state);
     }
 
@@ -1158,7 +1238,7 @@ void CFM::linkStateMachine(bool validRFSignal, bool validExtSignal)
     if (!m_extSignal) {
       DEBUG1("State to LISTENING");
       m_state = FS_LISTENING;
-      m_statusTimer.stop();
+      serial.writeFMStatus(m_state);
     }
 
     m_rfSignal = false;
@@ -1171,7 +1251,7 @@ void CFM::linkStateMachine(bool validRFSignal, bool validExtSignal)
     if (!m_rfSignal) {
       DEBUG1("State to LISTENING");
       m_state = FS_LISTENING;
-      m_statusTimer.stop();
+      serial.writeFMStatus(m_state);
     }
 
     m_needReverse = true;

FM.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2020,2021 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020,2021,2023 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
@@ -35,27 +35,12 @@
 #include "FMUpSampler.h"
 #include "FMNoiseSquelch.h"
 
-enum FM_STATE {
-  FS_LISTENING,
-  FS_KERCHUNK_RF,
-  FS_RELAYING_RF,
-  FS_RELAYING_WAIT_RF,
-  FS_TIMEOUT_RF,
-  FS_TIMEOUT_WAIT_RF,
-  FS_KERCHUNK_EXT,
-  FS_RELAYING_EXT,
-  FS_RELAYING_WAIT_EXT,
-  FS_TIMEOUT_EXT,
-  FS_TIMEOUT_WAIT_EXT,
-  FS_HANG
-};
-
 
 class CFM {
 public:
   CFM();
 
-  void samples(bool cos, q15_t* samples, uint8_t length);
+  void samples(bool cos, q15_t* samples, const uint16_t* rssi, uint8_t length);
 
   void process();
 
@@ -78,7 +63,7 @@ private:
   CFMCTCSSTX           m_ctcssTX;
   CFMNoiseSquelch      m_squelch;
   CFMTimeout           m_timeoutTone;
-  FM_STATE             m_state;
+  uint8_t              m_state;
   bool                 m_callsignAtStart;
   bool                 m_callsignAtEnd;
   bool                 m_callsignAtLatch;
@@ -89,7 +74,6 @@ private:
   CFMTimer             m_ackMinTimer;
   CFMTimer             m_ackDelayTimer;
   CFMTimer             m_hangTimer;
-  CFMTimer             m_statusTimer;
   CFMTimer             m_reverseTimer;
   bool                 m_needReverse;
   CFMDirectFormI       m_filterStage1;
@@ -110,10 +94,12 @@ private:
   CFMUpSampler         m_inputExtRB;
   bool                 m_rfSignal;
   bool                 m_extSignal;
+  uint32_t             m_rssiAccum;
+  uint16_t             m_rssiCount;
 
   void stateMachine(bool validRFSignal, bool validExtSignal);
 
-  void repeaterSamples(bool cos, q15_t* samples, uint8_t length);
+  void repeaterSamples(bool cos, q15_t* samples, const uint16_t* rssi, uint8_t length);
   void linkSamples(bool cos, q15_t* samples, uint8_t length);
 
   void duplexStateMachine(bool validRFSignal, bool validExtSignal);

Globals.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018,2020,2021,2024 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020,2021 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
@@ -49,7 +49,6 @@ enum MMDVM_STATE {
   STATE_NXDN      = 5,
   STATE_POCSAG    = 6,
   STATE_M17       = 7,
-  STATE_DPMR      = 8,
   STATE_FM        = 10,
   STATE_AX25      = 11,
 
@@ -80,8 +79,6 @@ enum MMDVM_STATE {
 #include "DMRDMOTX.h"
 #include "DStarRX.h"
 #include "DStarTX.h"
-#include "DPMRRX.h"
-#include "DPMRTX.h"
 #include "DMRRX.h"
 #include "DMRTX.h"
 #include "YSFRX.h"
@@ -133,7 +130,6 @@ extern bool m_p25Enable;
 extern bool m_nxdnEnable;
 extern bool m_pocsagEnable;
 extern bool m_m17Enable;
-extern bool m_dpmrEnable;
 extern bool m_fmEnable;
 extern bool m_ax25Enable;
 
@@ -195,13 +191,6 @@ extern CM17TX m17TX;
 extern CCalM17 calM17;
 #endif
 
-#if defined(MODE_DPMR)
-extern CDPMRRX dpmrRX;
-extern CDPMRTX dpmrTX;
-
-extern CCalNXDN calNXDN;
-#endif
-
 #if defined(MODE_FM)
 extern CFM    fm;
 extern CCalFM calFM;

IO.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018,2020,2021,2024 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020,2021,2023 by Jonathan Naylor G4KLX
  *   Copyright (C) 2015 by Jim Mclaughlin KI6ZUM
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *
@@ -44,13 +44,12 @@ static q15_t RRC_0_5_FILTER[] = {-147, -88, 72, 220, 223, 46, -197, -285, -79, 3
 const uint16_t RRC_0_5_FILTER_LEN = 42U;
 #endif
 
-#if defined(MODE_NXDN) && defined(USE_NXDN_BOXCAR)
+#if defined(MODE_NXDN)
+#if defined(USE_NXDN_BOXCAR)
 // One symbol boxcar filter
 static q15_t   BOXCAR10_FILTER[] = {6000, 6000, 6000, 6000, 6000, 6000, 6000, 6000, 6000, 6000};
 const uint16_t BOXCAR10_FILTER_LEN = 10U;
-#endif
-
-#if defined(MODE_DPMR) || (defined(MODE_NXDN) && !defined(USE_NXDN_BOXCAR))
+#else
 // Generated using rcosdesign(0.2, 8, 10, 'sqrt') in MATLAB
 static q15_t NXDN_0_2_FILTER[] = {284, 198, 73, -78, -240, -393, -517, -590, -599, -533, -391, -181, 79, 364, 643, 880, 1041, 1097, 1026, 819,
                                   483, 39, -477, -1016, -1516, -1915, -2150, -2164, -1914, -1375, -545, 557, 1886, 3376, 4946, 6502, 7946, 9184,
@@ -63,6 +62,7 @@ static q15_t NXDN_ISINC_FILTER[] = {790, -1085, -1073, -553, 747, 2341, 3156, 21
                                    12354, 4441, -3102, -7536, -7834, -4915, -893, 2152, 3156, 2341, 747, -553, -1073, -1085, 790};
 const uint16_t NXDN_ISINC_FILTER_LEN = 32U;
 #endif
+#endif
 
 #if defined(MODE_DSTAR)
 // Generated using gaussfir(0.5, 4, 5) in MATLAB
@@ -103,16 +103,17 @@ m_rrc02State2(),
 m_boxcar5Filter(),
 m_boxcar5State(),
 #endif
-#if defined(MODE_NXDN) && defined(USE_NXDN_BOXCAR)
+#if defined(MODE_NXDN)
+#if defined(USE_NXDN_BOXCAR)
 m_boxcar10Filter(),
 m_boxcar10State(),
-#endif
-#if defined(MODE_DPMR) || (defined(MODE_NXDN) && !defined(USE_NXDN_BOXCAR))
+#else
 m_nxdnFilter(),
 m_nxdnISincFilter(),
 m_nxdnState(),
 m_nxdnISincState(),
 #endif
+#endif
 #if defined(MODE_M17)
 m_rrc05Filter(),
 m_rrc05State(),
@@ -126,7 +127,6 @@ m_ysfTXLevel(128 * 128),
 m_p25TXLevel(128 * 128),
 m_nxdnTXLevel(128 * 128),
 m_m17TXLevel(128 * 128),
-m_dpmrTXLevel(128 * 128),
 m_pocsagTXLevel(128 * 128),
 m_fmTXLevel(128 * 128),
 m_ax25TXLevel(128 * 128),
@@ -177,14 +177,13 @@ m_lockout(false)
   m_boxcar5Filter.pCoeffs = BOXCAR5_FILTER;
 #endif
 
-#if defined(MODE_NXDN) && defined(USE_NXDN_BOXCAR)
+#if defined(MODE_NXDN)
+#if defined(USE_NXDN_BOXCAR)
   ::memset(m_boxcar10State, 0x00U, 40U * sizeof(q15_t));
   m_boxcar10Filter.numTaps = BOXCAR10_FILTER_LEN;
   m_boxcar10Filter.pState  = m_boxcar10State;
   m_boxcar10Filter.pCoeffs = BOXCAR10_FILTER;
-#endif
-
-#if defined(MODE_DPMR) || (defined(MODE_NXDN) && !defined(USE_NXDN_BOXCAR))
+#else
   ::memset(m_nxdnState,      0x00U, 110U * sizeof(q15_t));
   ::memset(m_nxdnISincState, 0x00U, 60U * sizeof(q15_t));
 
@@ -196,6 +195,7 @@ m_lockout(false)
   m_nxdnISincFilter.pState  = m_nxdnISincState;
   m_nxdnISincFilter.pCoeffs = NXDN_ISINC_FILTER;
 #endif
+#endif
 
 #if defined(MODE_M17)
   ::memset(m_rrc05State, 0x00U, 70U * sizeof(q15_t));
@@ -236,9 +236,6 @@ void CIO::selfTest()
 #if !defined(USE_ALTERNATE_FM_LEDS)
     setFMInt(ledValue);
 #endif
-#if !defined(USE_ALTERNATE_DPMR_LEDS)
-    setDPMRInt(ledValue);
-#endif
 #endif
     delayInt(250);
   }
@@ -259,9 +256,6 @@ void CIO::selfTest()
 #endif
 #if !defined(USE_ALTERNATE_FM_LEDS)
   setFMInt(false);
-#endif
-#if !defined(USE_ALTERNATE_DPMR_LEDS)
-  setDPMRInt(false);
 #endif
   setDStarInt(true);
 
@@ -292,19 +286,9 @@ void CIO::selfTest()
 #if !defined(USE_ALTERNATE_FM_LEDS)
   delayInt(250);
   setFMInt(true);
-#endif
-
-#if !defined(USE_ALTERNATE_DPMR_LEDS)
-  delayInt(250);
-  setDPMRInt(true);
 
   delayInt(250);
-  setDPMRInt(false);
-#endif
-
-#if !defined(USE_ALTERNATE_FM_LEDS)
-  delayInt(250);
-  setFMInt(true);
+  setFMInt(false);
 #endif
 
 #if !defined(USE_ALTERNATE_POCSAG_LEDS)
@@ -354,7 +338,7 @@ void CIO::process()
   if (m_started) {
     // Two seconds timeout
     if (m_watchdog >= 48000U) {
-      if (m_modemState == STATE_DSTAR || m_modemState == STATE_DMR || m_modemState == STATE_YSF || m_modemState == STATE_P25 || m_modemState == STATE_NXDN || m_modemState == STATE_M17 || m_modemState == STATE_DPMR || m_modemState == STATE_POCSAG) {
+      if (m_modemState == STATE_DSTAR || m_modemState == STATE_DMR || m_modemState == STATE_YSF || m_modemState == STATE_P25 || m_modemState == STATE_NXDN || m_modemState == STATE_M17 || m_modemState == STATE_POCSAG) {
 #if defined(MODE_DMR)
         if (m_modemState == STATE_DMR && m_tx)
           dmrTX.setStart(false);
@@ -518,29 +502,13 @@ void CIO::process()
       }
 #endif
 
-#if defined(MODE_DPMR)
-      if (m_dpmrEnable) {
-        q15_t DPMRValsTmp[RX_BLOCK_SIZE];
-#if defined(USE_DCBLOCKER)
-        ::arm_fir_fast_q15(&m_nxdnFilter, dcSamples, DPMRValsTmp, RX_BLOCK_SIZE);
-#else
-        ::arm_fir_fast_q15(&m_nxdnFilter, samples, DPMRValsTmp, RX_BLOCK_SIZE);
-#endif
-
-        q15_t DPMRVals[RX_BLOCK_SIZE];
-        ::arm_fir_fast_q15(&m_nxdnISincFilter, DPMRValsTmp, DPMRVals, RX_BLOCK_SIZE);
-
-        dpmrRX.samples(DPMRVals, rssi, RX_BLOCK_SIZE);
-      }
-#endif
-
 #if defined(MODE_FM)
       if (m_fmEnable) {
         bool cos = getCOSInt();
 #if defined(USE_DCBLOCKER)
-        fm.samples(cos, dcSamples, RX_BLOCK_SIZE);
+        fm.samples(cos, dcSamples, rssi, RX_BLOCK_SIZE);
 #else
-        fm.samples(cos, samples, RX_BLOCK_SIZE);
+        fm.samples(cos, samples, rssi, RX_BLOCK_SIZE);
 #endif
       }
 #endif
@@ -548,9 +516,9 @@ void CIO::process()
 #if defined(MODE_FM) && defined(MODE_AX25)
       if (m_ax25Enable) {
 #if defined(USE_DCBLOCKER)
-        ax25RX.samples(dcSamples, RX_BLOCK_SIZE);
+        ax25RX.samples(dcSamples, rssi, RX_BLOCK_SIZE);
 #else
-        ax25RX.samples(samples, RX_BLOCK_SIZE);
+        ax25RX.samples(samples, rssi, RX_BLOCK_SIZE);
 #endif
       }
 #endif
@@ -655,40 +623,22 @@ void CIO::process()
     }
 #endif
 
-#if defined(MODE_DPMR)
-    else if (m_modemState == STATE_DPMR) {
-      if (m_dpmrEnable) {
-        q15_t DPMRValsTmp[RX_BLOCK_SIZE];
-#if defined(USE_DCBLOCKER)
-        ::arm_fir_fast_q15(&m_nxdnFilter, dcSamples, DPMRValsTmp, RX_BLOCK_SIZE);
-#else
-        ::arm_fir_fast_q15(&m_nxdnFilter, samples, DPMRValsTmp, RX_BLOCK_SIZE);
-#endif
-
-        q15_t DPMRVals[RX_BLOCK_SIZE];
-        ::arm_fir_fast_q15(&m_nxdnISincFilter, DPMRValsTmp, DPMRVals, RX_BLOCK_SIZE);
-
-        dpmrRX.samples(DPMRVals, rssi, RX_BLOCK_SIZE);
-      }
-    }
-#endif
-
 #if defined(MODE_FM)
     else if (m_modemState == STATE_FM) {
       bool cos = getCOSInt();
 #if defined(USE_DCBLOCKER)
-      fm.samples(cos, dcSamples, RX_BLOCK_SIZE);
+      fm.samples(cos, dcSamples, rssi, RX_BLOCK_SIZE);
 
 #if defined(MODE_AX25)
       if (m_ax25Enable)
-        ax25RX.samples(dcSamples, RX_BLOCK_SIZE);
+        ax25RX.samples(dcSamples, rssi, RX_BLOCK_SIZE);
 #endif
 #else
-      fm.samples(cos, samples, RX_BLOCK_SIZE);
+      fm.samples(cos, samples, rssi, RX_BLOCK_SIZE);
 
 #if defined(MODE_AX25)
       if (m_ax25Enable)
-        ax25RX.samples(samples, RX_BLOCK_SIZE);
+        ax25RX.samples(samples, rssi, RX_BLOCK_SIZE);
 #endif
 #endif
     }
@@ -744,9 +694,6 @@ void CIO::write(MMDVM_STATE mode, q15_t* samples, uint16_t length, const uint8_t
     case STATE_M17:
       txLevel = m_m17TXLevel;
       break;
-    case STATE_DPMR:
-      txLevel = m_dpmrTXLevel;
-      break;
     case STATE_POCSAG:
       txLevel = m_pocsagTXLevel;
       break;
@@ -808,7 +755,6 @@ void CIO::setMode(MMDVM_STATE state)
     case STATE_P25:    setP25Int(false);    break;
     case STATE_NXDN:   setNXDNInt(false);   break;
     case STATE_M17:    setM17Int(false);    break;
-    case STATE_DPMR:   setDPMRInt(false);   break;
     case STATE_POCSAG: setPOCSAGInt(false); break;
     case STATE_FM:     setFMInt(false);     break;
     default: break;
@@ -821,7 +767,6 @@ void CIO::setMode(MMDVM_STATE state)
     case STATE_P25:    setP25Int(true);    break;
     case STATE_NXDN:   setNXDNInt(true);   break;
     case STATE_M17:    setM17Int(true);    break;
-    case STATE_DPMR:   setDPMRInt(true);   break;
     case STATE_POCSAG: setPOCSAGInt(true); break;
     case STATE_FM:     setFMInt(true);     break;
     default: break;
@@ -831,7 +776,7 @@ void CIO::setMode(MMDVM_STATE state)
   m_modemState = state;
 }
 
-void CIO::setParameters(bool rxInvert, bool txInvert, bool pttInvert, uint8_t rxLevel, uint8_t cwIdTXLevel, uint8_t dstarTXLevel, uint8_t dmrTXLevel, uint8_t ysfTXLevel, uint8_t p25TXLevel, uint8_t nxdnTXLevel, uint8_t m17TXLevel, uint8_t dpmrTXLevel, uint8_t pocsagTXLevel, uint8_t fmTXLevel, uint8_t ax25TXLevel, int16_t txDCOffset, int16_t rxDCOffset, bool useCOSAsLockout)
+void CIO::setParameters(bool rxInvert, bool txInvert, bool pttInvert, uint8_t rxLevel, uint8_t cwIdTXLevel, uint8_t dstarTXLevel, uint8_t dmrTXLevel, uint8_t ysfTXLevel, uint8_t p25TXLevel, uint8_t nxdnTXLevel, uint8_t m17TXLevel, uint8_t pocsagTXLevel, uint8_t fmTXLevel, uint8_t ax25TXLevel, int16_t txDCOffset, int16_t rxDCOffset, bool useCOSAsLockout)
 {
   m_pttInvert = pttInvert;
 
@@ -843,7 +788,6 @@ void CIO::setParameters(bool rxInvert, bool txInvert, bool pttInvert, uint8_t rx
   m_p25TXLevel    = q15_t(p25TXLevel * 128);
   m_nxdnTXLevel   = q15_t(nxdnTXLevel * 128);
   m_m17TXLevel    = q15_t(m17TXLevel * 128);
-  m_dpmrTXLevel   = q15_t(dpmrTXLevel * 128);
   m_pocsagTXLevel = q15_t(pocsagTXLevel * 128);
   m_fmTXLevel     = q15_t(fmTXLevel * 128);
   m_ax25TXLevel   = q15_t(ax25TXLevel * 128);
@@ -863,7 +807,6 @@ void CIO::setParameters(bool rxInvert, bool txInvert, bool pttInvert, uint8_t rx
     m_p25TXLevel    = -m_p25TXLevel;
     m_nxdnTXLevel   = -m_nxdnTXLevel;
     m_m17TXLevel    = -m_m17TXLevel;
-    m_dpmrTXLevel   = -m_dpmrTXLevel;
     m_pocsagTXLevel = -m_pocsagTXLevel;
   }
 }

IO.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018,2020,2021,2024 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020,2021 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
@@ -46,7 +46,7 @@ public:
   
   void interrupt();
 
-  void setParameters(bool rxInvert, bool txInvert, bool pttInvert, uint8_t rxLevel, uint8_t cwIdTXLevel, uint8_t dstarTXLevel, uint8_t dmrTXLevel, uint8_t ysfTXLevel, uint8_t p25TXLevel, uint8_t nxdnTXLevel, uint8_t m17TXLevel, uint8_t dpmrLevel, uint8_t pocsagTXLevel, uint8_t fmTXLevel, uint8_t ax25TXLevel, int16_t txDCOffset, int16_t rxDCOffset, bool useCOSAsLockout);
+  void setParameters(bool rxInvert, bool txInvert, bool pttInvert, uint8_t rxLevel, uint8_t cwIdTXLevel, uint8_t dstarTXLevel, uint8_t dmrTXLevel, uint8_t ysfTXLevel, uint8_t p25TXLevel, uint8_t nxdnTXLevel, uint8_t m17TXLevel, uint8_t pocsagTXLevel, uint8_t fmTXLevel, uint8_t ax25TXLevel, int16_t txDCOffset, int16_t rxDCOffset, bool useCOSAsLockout);
 
   void getOverflow(bool& adcOverflow, bool& dacOverflow);
 
@@ -96,17 +96,17 @@ private:
   q15_t                m_boxcar5State[30U];        // NoTaps + BlockSize - 1,  6 + 20 - 1 plus some spare
 #endif
 
-#if defined(MODE_NXDN) && defined(USE_NXDN_BOXCAR)
+#if defined(MODE_NXDN)
+#if defined(USE_NXDN_BOXCAR)
   arm_fir_instance_q15 m_boxcar10Filter;
   q15_t                m_boxcar10State[40U];      // NoTaps + BlockSize - 1, 10 + 20 - 1 plus some spare
-#endif
-
-#if defined(MODE_DPMR) || (defined(MODE_NXDN) && !defined(USE_NXDN_BOXCAR))
+#else
   arm_fir_instance_q15 m_nxdnFilter;
   arm_fir_instance_q15 m_nxdnISincFilter;
   q15_t                m_nxdnState[110U];         // NoTaps + BlockSize - 1, 82 + 20 - 1 plus some spare
   q15_t                m_nxdnISincState[60U];     // NoTaps + BlockSize - 1, 32 + 20 - 1 plus some spare
 #endif
+#endif
 
 #if defined(MODE_M17)
   arm_fir_instance_q15 m_rrc05Filter;
@@ -122,7 +122,6 @@ private:
   q15_t                m_p25TXLevel;
   q15_t                m_nxdnTXLevel;
   q15_t                m_m17TXLevel;
-  q15_t                m_dpmrTXLevel;
   q15_t                m_pocsagTXLevel;
   q15_t                m_fmTXLevel;
   q15_t                m_ax25TXLevel;
@@ -161,7 +160,6 @@ private:
   void setNXDNInt(bool on);
   void setPOCSAGInt(bool on);
   void setM17Int(bool on);
-  void setDPMRInt(bool on);
   void setFMInt(bool on);
   
   void delayInt(unsigned int dly);

IOSTM.cpp

@@ -1,7 +1,7 @@
 /*
  *   Copyright (C) 2016 by Jim McLaughlin KI6ZUM
  *   Copyright (C) 2016,2017,2018 by Andy Uribe CA6JAU
- *   Copyright (C) 2017,2018,2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2017,2018,2020,2023 by Jonathan Naylor G4KLX
  *   Copyright (C) 2019,2020 by BG5HHP
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -365,10 +365,16 @@ void CIO::interrupt()
 #endif
    }
 
-   // trigger next ADC1
+   // Trigger next ADC1
    ADC_ClearFlag(ADC1, ADC_FLAG_EOC);
    ADC_SoftwareStartConv(ADC1);
 
+#if defined(SEND_RSSI_DATA)
+   // Trigger next ADC2
+   ADC_ClearFlag(ADC2, ADC_FLAG_EOC);
+   ADC_SoftwareStartConv(ADC2);
+#endif
+
    m_rxBuffer.put(sample);
    m_rssiBuffer.put(rawRSSI);
 

M17TX.cpp

@@ -160,7 +160,7 @@ void CM17TX::writeByte(uint8_t c)
 
 void CM17TX::writeSilence()
 {
-  q15_t inBuffer[4U] = {0x00U, 0x00U, 0x00U, 0x00U};
+  q15_t inBuffer[4U] = {0, 0, 0, 0};
   q15_t outBuffer[M17_RADIO_SYMBOL_LENGTH * 4U];
 
   ::arm_fir_interpolate_q15(&m_modFilter, inBuffer, outBuffer, 4U);

MMDVM.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018,2020,2021,2024 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020,2021 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Mathis Schmieder DB9MAT
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *
@@ -32,7 +32,6 @@ bool m_ysfEnable    = true;
 bool m_p25Enable    = true;
 bool m_nxdnEnable   = true;
 bool m_m17Enable    = true;
-bool m_dpmrEnable   = true;
 bool m_pocsagEnable = true;
 bool m_fmEnable     = true;
 bool m_ax25Enable   = true;
@@ -87,11 +86,6 @@ CM17TX m17TX;
 CCalM17 calM17;
 #endif
 
-#if defined(MODE_NXDN)
-CDPMRRX dpmrRX;
-CDPMRTX dpmrTX;
-#endif
-
 #if defined(MODE_POCSAG)
 CPOCSAGTX  pocsagTX;
 CCalPOCSAG calPOCSAG;
@@ -160,11 +154,6 @@ void loop()
     m17TX.process();
 #endif
 
-#if defined(MODE_DPMR)
-  if (m_dpmrEnable && m_modemState == STATE_DPMR)
-    dpmrTX.process();
-#endif
-
 #if defined(MODE_POCSAG)
   if (m_pocsagEnable && (m_modemState == STATE_POCSAG || pocsagTX.busy()))
     pocsagTX.process();

MMDVM.ino

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018,2020,2021,2024 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020,2021 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -29,7 +29,6 @@ bool m_ysfEnable    = true;
 bool m_p25Enable    = true;
 bool m_nxdnEnable   = true;
 bool m_m17Enable    = true;
-bool m_dpmrEnable   = true;
 bool m_pocsagEnable = true;
 bool m_fmEnable     = true;
 bool m_ax25Enable   = true;
@@ -84,11 +83,6 @@ CM17TX m17TX;
 CCalM17 calM17;
 #endif
 
-#if defined(MODE_NXDN)
-CDPMRRX dpmrRX;
-CDPMRTX dpmrTX;
-#endif
-
 #if defined(MODE_POCSAG)
 CPOCSAGTX  pocsagTX;
 CCalPOCSAG calPOCSAG;
@@ -157,11 +151,6 @@ void loop()
     m17TX.process();
 #endif
 
-#if defined(MODE_DPMR)
-  if (m_dpmrEnable && m_modemState == STATE_DPMR)
-    dpmrTX.process();
-#endif
-
 #if defined(MODE_POCSAG)
   if (m_pocsagEnable && (m_modemState == STATE_POCSAG || pocsagTX.busy()))
     pocsagTX.process();

NXDNTX.cpp

@@ -175,7 +175,7 @@ void CNXDNTX::writeByte(uint8_t c)
 
 void CNXDNTX::writeSilence()
 {
-  q15_t inBuffer[4U] = {0x00U, 0x00U, 0x00U, 0x00U};
+  q15_t inBuffer[4U] = {0, 0, 0, 0};
   q15_t intBuffer[NXDN_RADIO_SYMBOL_LENGTH * 4U];
   q15_t outBuffer[NXDN_RADIO_SYMBOL_LENGTH * 4U];
 

P25TX.cpp

@@ -173,7 +173,7 @@ void CP25TX::writeByte(uint8_t c)
 
 void CP25TX::writeSilence()
 {
-  q15_t inBuffer[4U] = {0x00U, 0x00U, 0x00U, 0x00U};
+  q15_t inBuffer[4U] = {0, 0, 0, 0};
   q15_t intBuffer[P25_RADIO_SYMBOL_LENGTH * 4U];
   q15_t outBuffer[P25_RADIO_SYMBOL_LENGTH * 4U];
 

SerialPort.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2013,2015-2021,2024 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2013,2015-2021,2023 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -60,11 +60,6 @@ const uint8_t MMDVM_P25_HDR      = 0x30U;
 const uint8_t MMDVM_P25_LDU      = 0x31U;
 const uint8_t MMDVM_P25_LOST     = 0x32U;
 
-const uint8_t MMDVM_DPMR_HEADER  = 0x35U;
-const uint8_t MMDVM_DPMR_DATA    = 0x36U;
-const uint8_t MMDVM_DPMR_LOST    = 0x37U;
-const uint8_t MMDVM_DPMR_EOT     = 0x38U;
-
 const uint8_t MMDVM_NXDN_DATA    = 0x40U;
 const uint8_t MMDVM_NXDN_LOST    = 0x41U;
 
@@ -77,6 +72,7 @@ const uint8_t MMDVM_M17_EOT        = 0x49U;
 const uint8_t MMDVM_POCSAG_DATA  = 0x50U;
 
 const uint8_t MMDVM_AX25_DATA    = 0x55U;
+const uint8_t MMDVM_AX25_DATA_EX = 0x56U;
 
 const uint8_t MMDVM_FM_PARAMS1   = 0x60U;
 const uint8_t MMDVM_FM_PARAMS2   = 0x61U;
@@ -85,6 +81,7 @@ const uint8_t MMDVM_FM_PARAMS4   = 0x63U;
 const uint8_t MMDVM_FM_DATA      = 0x65U;
 const uint8_t MMDVM_FM_STATUS    = 0x66U;
 const uint8_t MMDVM_FM_EOT       = 0x67U;
+const uint8_t MMDVM_FM_RSSI      = 0x68U;
 
 const uint8_t MMDVM_ACK          = 0x70U;
 const uint8_t MMDVM_NAK          = 0x7FU;
@@ -145,10 +142,8 @@ m_buffer(),
 m_ptr(0U),
 m_len(0U),
 m_debug(false),
-m_serialData(),
 m_lastSerialAvail(0),
-m_lastSerialAvailCount(0U),
-m_i2CData()
+m_lastSerialAvailCount(0U)
 {
 }
 
@@ -305,15 +300,7 @@ void CSerialPort::getStatus()
   reply[15U] = 0U;
 #endif
 
-#if defined(MODE_DPMR)
-  if (m_dpmrEnable)
-    reply[16U] = dpmrTX.getSpace();
-  else
-    reply[16U] = 0U;
-#else
-  reply[16U] = 0U;
-#endif
-
+  reply[16U] = 0x00U;
   reply[17U] = 0x00U;
   reply[18U] = 0x00U;
   reply[19U] = 0x00U;
@@ -354,9 +341,6 @@ void CSerialPort::getVersion()
 #if defined(MODE_FM)
   reply[4U] |= 0x40U;
 #endif
-#if defined(MODE_DPMR)
-  reply[4U] |= 0x80U;
-#endif
 
   reply[5U] = 0x00U;
 #if defined(MODE_POCSAG)
@@ -419,9 +403,6 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint16_t length)
 #if defined(MODE_M17)
   bool m17Enable    = (data[1U] & 0x40U) == 0x40U;
 #endif
-#if defined(MODE_DPMR)
-  bool dpmrEnable   = (data[1U] & 0x80U) == 0x80U;
-#endif
 #if defined(MODE_POCSAG)
   bool pocsagEnable = (data[2U] & 0x01U) == 0x01U;
 #endif
@@ -435,13 +416,9 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint16_t length)
 
   MMDVM_STATE modemState = MMDVM_STATE(data[4U]);
 
-  if (modemState != STATE_IDLE && modemState != STATE_DSTAR && modemState != STATE_DMR && modemState != STATE_YSF &&
-      modemState != STATE_P25 && modemState != STATE_NXDN && modemState != STATE_M17 && modemState != STATE_POCSAG &&
-      modemState != STATE_FM && modemState != STATE_DPMR && modemState != STATE_DSTARCAL && modemState != STATE_DMRCAL &&
-      modemState != STATE_RSSICAL && modemState != STATE_LFCAL && modemState != STATE_DMRCAL1K && modemState != STATE_P25CAL1K &&
-      modemState != STATE_DMRDMO1K && modemState != STATE_NXDNCAL1K && modemState != STATE_M17CAL && modemState != STATE_POCSAGCAL &&
-      modemState != STATE_FMCAL10K && modemState != STATE_FMCAL12K && modemState != STATE_FMCAL15K && modemState != STATE_FMCAL20K &&
-      modemState != STATE_FMCAL25K && modemState != STATE_FMCAL30K)
+  if (modemState != STATE_IDLE && modemState != STATE_DSTAR && modemState != STATE_DMR && modemState != STATE_YSF && modemState != STATE_P25 && modemState != STATE_NXDN && modemState != STATE_M17 && modemState != STATE_POCSAG && modemState != STATE_FM &&
+      modemState != STATE_DSTARCAL && modemState != STATE_DMRCAL && modemState != STATE_RSSICAL && modemState != STATE_LFCAL && modemState != STATE_DMRCAL1K && modemState != STATE_P25CAL1K && modemState != STATE_DMRDMO1K && modemState != STATE_NXDNCAL1K && modemState != STATE_M17CAL && modemState != STATE_POCSAGCAL &&
+      modemState != STATE_FMCAL10K && modemState != STATE_FMCAL12K && modemState != STATE_FMCAL15K && modemState != STATE_FMCAL20K && modemState != STATE_FMCAL25K && modemState != STATE_FMCAL30K)
     return 4U;
 
 #if defined(MODE_DSTAR)
@@ -492,14 +469,6 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint16_t length)
     return 4U;
 #endif
 
-#if defined(MODE_DPMR)
-  if (modemState == STATE_DPMR && !dpmrEnable)
-    return 4U;
-#else
-  if (modemState == STATE_DPMR)
-    return 4U;
-#endif
-
 #if defined(MODE_POCSAG)
   if (modemState == STATE_POCSAG && !pocsagEnable)
     return 4U;
@@ -531,7 +500,6 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint16_t length)
   uint8_t pocsagTXLevel = data[15U];
   uint8_t fmTXLevel     = data[16U];
   uint8_t ax25TXLevel   = data[17U];
-  uint8_t dpmrTXLevel   = data[18U];
 
 #if defined(MODE_YSF)
   uint8_t ysfTXHang     = data[20U];
@@ -545,9 +513,6 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint16_t length)
 #if defined(MODE_M17)
   uint8_t m17TXHang     = data[23U];
 #endif
-#if defined(MODE_DPMR)
-  uint8_t dpmrTXHang    = data[24U];
-#endif
 
 #if defined(MODE_DMR)
   uint8_t colorCode = data[26U];
@@ -605,11 +570,6 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint16_t length)
   m17TX.setTXDelay(txDelay);
   m17TX.setParams(m17TXHang);
 #endif
-#if defined(MODE_DPMR)
-  m_dpmrEnable   = dpmrEnable;
-  dpmrTX.setTXDelay(txDelay);
-  dpmrTX.setParams(dpmrTXHang);
-#endif
 #if defined(MODE_POCSAG)
   m_pocsagEnable = pocsagEnable;
   pocsagTX.setTXDelay(txDelay);
@@ -623,7 +583,7 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint16_t length)
   m_fmEnable     = fmEnable;
 #endif
 
-  io.setParameters(rxInvert, txInvert, pttInvert, rxLevel, cwIdTXLevel, dstarTXLevel, dmrTXLevel, ysfTXLevel, p25TXLevel, nxdnTXLevel, m17TXLevel, dpmrTXLevel, pocsagTXLevel, fmTXLevel, ax25TXLevel, txDCOffset, rxDCOffset, useCOSAsLockout);
+  io.setParameters(rxInvert, txInvert, pttInvert, rxLevel, cwIdTXLevel, dstarTXLevel, dmrTXLevel, ysfTXLevel, p25TXLevel, nxdnTXLevel, m17TXLevel, pocsagTXLevel, fmTXLevel, ax25TXLevel, txDCOffset, rxDCOffset, useCOSAsLockout);
 
   io.start();
 
@@ -737,13 +697,9 @@ uint8_t CSerialPort::setMode(const uint8_t* data, uint16_t length)
   if (modemState == m_modemState)
     return 0U;
 
-  if (modemState != STATE_IDLE && modemState != STATE_DSTAR && modemState != STATE_DMR && modemState != STATE_YSF &&
-      modemState != STATE_P25 && modemState != STATE_NXDN && modemState != STATE_M17 && modemState != STATE_DPMR &&
-      modemState != STATE_POCSAG && modemState != STATE_FM && modemState != STATE_DSTARCAL && modemState != STATE_DMRCAL &&
-      modemState != STATE_RSSICAL && modemState != STATE_LFCAL && modemState != STATE_DMRCAL1K && modemState != STATE_P25CAL1K &&
-      modemState != STATE_DMRDMO1K && modemState != STATE_NXDNCAL1K && modemState != STATE_M17CAL && modemState != STATE_POCSAGCAL &&
-      modemState != STATE_FMCAL10K  && modemState != STATE_FMCAL12K && modemState != STATE_FMCAL15K && modemState != STATE_FMCAL20K &&
-      modemState != STATE_FMCAL25K && modemState != STATE_FMCAL30K)
+  if (modemState != STATE_IDLE && modemState != STATE_DSTAR && modemState != STATE_DMR && modemState != STATE_YSF && modemState != STATE_P25 && modemState != STATE_NXDN && modemState != STATE_M17 && modemState != STATE_POCSAG && modemState != STATE_FM &&
+      modemState != STATE_DSTARCAL && modemState != STATE_DMRCAL && modemState != STATE_RSSICAL && modemState != STATE_LFCAL && modemState != STATE_DMRCAL1K && modemState != STATE_P25CAL1K && modemState != STATE_DMRDMO1K && modemState != STATE_NXDNCAL1K && modemState != STATE_M17CAL && modemState != STATE_POCSAGCAL &&
+      modemState != STATE_FMCAL10K  && modemState != STATE_FMCAL12K && modemState != STATE_FMCAL15K && modemState != STATE_FMCAL20K && modemState != STATE_FMCAL25K && modemState != STATE_FMCAL30K)
     return 4U;
 
 #if defined(MODE_DSTAR)
@@ -794,14 +750,6 @@ uint8_t CSerialPort::setMode(const uint8_t* data, uint16_t length)
     return 4U;
 #endif
 
-#if defined(MODE_DPMR)
-  if (modemState == STATE_DPMR && !m_dpmrEnable)
-    return 4U;
-#else
-  if (modemState == STATE_DPMR)
-    return 4U;
-#endif
-
 #if defined(MODE_POCSAG)
   if (modemState == STATE_POCSAG && !m_pocsagEnable)
     return 4U;
@@ -844,9 +792,6 @@ void CSerialPort::setMode(MMDVM_STATE modemState)
     case STATE_M17:
       DEBUG1("Mode set to M17");
       break;
-    case STATE_DPMR:
-      DEBUG1("Mode set to dPMR");
-      break;
     case STATE_POCSAG:
       DEBUG1("Mode set to POCSAG");
       break;
@@ -936,11 +881,6 @@ void CSerialPort::setMode(MMDVM_STATE modemState)
     m17RX.reset();
 #endif
 
-#if defined(MODE_DPMR)
-  if (modemState != STATE_DPMR)
-    dpmrRX.reset();
-#endif
-
 #if defined(MODE_FM)
   if (modemState != STATE_FM)
     fm.reset();
@@ -1018,20 +958,6 @@ void CSerialPort::process()
   }
 
 #if defined(SERIAL_REPEATER)
-  // Write any outgoing serial data
-  uint16_t serialSpace = m_serialData.getData();
-  if (serialSpace > 0U) {
-    int avail = availableForWriteInt(3U);
-    if (avail < serialSpace)
-      serialSpace = avail;
-
-    for (uint16_t i = 0U; i < serialSpace; i++) {
-      uint8_t c = 0U;
-      m_serialData.get(c);
-      writeInt(3U, &c, 1U);
-    }
-  }
-
   // Read any incoming serial data, and send out in batches
   int serialAvail = availableForReadInt(3U);
   if ((serialAvail > 0 && serialAvail == m_lastSerialAvail && m_lastSerialAvailCount >= MAX_SERIAL_COUNT) || (serialAvail >= MAX_SERIAL_DATA)) {
@@ -1049,22 +975,6 @@ void CSerialPort::process()
     m_lastSerialAvailCount = 0U;
   }
 #endif
-
-#if defined(I2C_REPEATER)
-  // Write any outgoing serial data
-  uint16_t i2CSpace = m_i2CData.getData();
-  if (i2CSpace > 0U) {
-    int avail = availableForWriteInt(10U);
-    if (avail < i2CSpace)
-      i2CSpace = avail;
-
-    for (uint16_t i = 0U; i < i2CSpace; i++) {
-      uint8_t c = 0U;
-      m_i2CData.get(c);
-      writeInt(10U, &c, 1U);
-    }
-  }
-#endif
 }
 
 void CSerialPort::processMessage(uint8_t type, const uint8_t* buffer, uint16_t length)
@@ -1421,50 +1331,6 @@ void CSerialPort::processMessage(uint8_t type, const uint8_t* buffer, uint16_t l
       break;
 #endif
 
-#if defined(MODE_DPMR)
-    case MMDVM_DPMR_HEADER:
-      if (m_dpmrEnable) {
-        if (m_modemState == STATE_IDLE || m_modemState == STATE_DPMR)
-          err = dpmrTX.writeHeader(buffer, length);
-      }
-      if (err == 0U) {
-        if (m_modemState == STATE_IDLE)
-          setMode(STATE_DPMR);
-      } else {
-        DEBUG2("Received invalid dPMR header", err);
-        sendNAK(type, err);
-      }
-      break;
-
-    case MMDVM_DPMR_DATA:
-      if (m_dpmrEnable) {
-        if (m_modemState == STATE_IDLE || m_modemState == STATE_DPMR)
-          err = dpmrTX.writeData(buffer, length);
-      }
-      if (err == 0U) {
-        if (m_modemState == STATE_IDLE)
-          setMode(STATE_DPMR);
-      } else {
-        DEBUG2("Received invalid dPMR data", err);
-        sendNAK(type, err);
-      }
-      break;
-
-    case MMDVM_DPMR_EOT:
-      if (m_dpmrEnable) {
-        if (m_modemState == STATE_IDLE || m_modemState == STATE_DPMR)
-          err = dpmrTX.writeEOT(buffer, length);
-      }
-      if (err == 0U) {
-        if (m_modemState == STATE_IDLE)
-          setMode(STATE_DPMR);
-      } else {
-        DEBUG2("Received invalid dPMR EOT", err);
-        sendNAK(type, err);
-      }
-      break;
-#endif
-
 #if defined(MODE_POCSAG)
     case MMDVM_POCSAG_DATA:
       if (m_pocsagEnable) {
@@ -1516,18 +1382,14 @@ void CSerialPort::processMessage(uint8_t type, const uint8_t* buffer, uint16_t l
       break;
 
 #if defined(SERIAL_REPEATER)
-    case MMDVM_SERIAL_DATA: {
-      for (uint16_t i = 0U; i < length; i++)
-        m_serialData.put(buffer[i]);
-      }
+    case MMDVM_SERIAL_DATA:
+      writeInt(3U, buffer, length);
       break;
 #endif
 
 #if defined(I2C_REPEATER)
-    case MMDVM_I2C_DATA: {
-      for (uint16_t i = 0U; i < length; i++)
-        m_i2CData.put(buffer[i]);
-      }
+    case MMDVM_I2C_DATA:
+      writeInt(10U, buffer, length);
       break;
 #endif
 
@@ -1895,88 +1757,6 @@ void CSerialPort::writeM17Lost()
 }
 #endif
 
-#if defined(MODE_DPMR)
-void CSerialPort::writeDPMRHeader(const uint8_t* data, uint8_t length)
-{
-  if (m_modemState != STATE_DPMR && m_modemState != STATE_IDLE)
-    return;
-
-  if (!m_dpmrEnable)
-    return;
-
-  uint8_t reply[130U];
-
-  reply[0U] = MMDVM_FRAME_START;
-  reply[1U] = 0U;
-  reply[2U] = MMDVM_DPMR_HEADER;
-
-  uint8_t count = 3U;
-  for (uint8_t i = 0U; i < length; i++, count++)
-    reply[count] = data[i];
-
-  reply[1U] = count;
-
-  writeInt(1U, reply, count);
-}
-
-void CSerialPort::writeDPMRData(const uint8_t* data, uint8_t length)
-{
-  if (m_modemState != STATE_DPMR && m_modemState != STATE_IDLE)
-    return;
-
-  if (!m_dpmrEnable)
-    return;
-
-  uint8_t reply[130U];
-
-  reply[0U] = MMDVM_FRAME_START;
-  reply[1U] = 0U;
-  reply[2U] = MMDVM_DPMR_DATA;
-
-  uint8_t count = 3U;
-  for (uint8_t i = 0U; i < length; i++, count++)
-    reply[count] = data[i];
-
-  reply[1U] = count;
-
-  writeInt(1U, reply, count);
-}
-
-void CSerialPort::writeDPMREOT()
-{
-  if (m_modemState != STATE_DPMR && m_modemState != STATE_IDLE)
-    return;
-
-  if (!m_dpmrEnable)
-    return;
-
-  uint8_t reply[3U];
-
-  reply[0U] = MMDVM_FRAME_START;
-  reply[1U] = 3U;
-  reply[2U] = MMDVM_DPMR_EOT;
-
-  writeInt(1U, reply, 3);
-}
-
-void CSerialPort::writeDPMRLost()
-{
-  if (m_modemState != STATE_DPMR && m_modemState != STATE_IDLE)
-    return;
-
-  if (!m_dpmrEnable)
-    return;
-
-  uint8_t reply[3U];
-
-  reply[0U] = MMDVM_FRAME_START;
-  reply[1U] = 3U;
-  reply[2U] = MMDVM_DPMR_LOST;
-
-  writeInt(1U, reply, 3);
-}
-#endif
-
 #if defined(MODE_FM)
 void CSerialPort::writeFMData(const uint8_t* data, uint16_t length)
 {
@@ -2028,6 +1808,25 @@ void CSerialPort::writeFMStatus(uint8_t status)
   writeInt(1U, reply, 4U);
 }
 
+void CSerialPort::writeFMRSSI(uint16_t rssi)
+{
+  if (m_modemState != STATE_FM && m_modemState != STATE_IDLE)
+    return;
+
+  if (!m_fmEnable)
+    return;
+
+  uint8_t reply[10U];
+
+  reply[0U] = MMDVM_FRAME_START;
+  reply[1U] = 5U;
+  reply[2U] = MMDVM_FM_RSSI;
+  reply[3U] = (rssi >> 8) & 0xFFU;
+  reply[4U] = (rssi >> 0) & 0xFFU;
+
+  writeInt(1U, reply, 5U);
+}
+
 void CSerialPort::writeFMEOT()
 {
   if (m_modemState != STATE_FM && m_modemState != STATE_IDLE)
@@ -2078,6 +1877,44 @@ void CSerialPort::writeAX25Data(const uint8_t* data, uint16_t length)
     writeInt(1U, reply, length + 3U);
   }
 }
+
+void CSerialPort::writeAX25DataEx(uint16_t rssi, const uint8_t* data, uint16_t length)
+{
+  if (m_modemState != STATE_FM && m_modemState != STATE_IDLE)
+    return;
+
+  if (!m_ax25Enable)
+    return;
+
+  uint8_t reply[512U];
+
+  reply[0U] = MMDVM_FRAME_START;
+
+  if (length > 250U) {
+    reply[1U] = 0U;
+    reply[2U] = (length + 6U) - 255U;
+    reply[3U] = MMDVM_AX25_DATA_EX;
+
+    reply[4U] = (rssi >> 8) & 0xFFU;
+    reply[5U] = (rssi >> 0) & 0xFFU;
+  
+    for (uint16_t i = 0U; i < length; i++)
+      reply[i + 6U] = data[i];
+
+    writeInt(1U, reply, length + 6U);
+  } else {
+    reply[1U] = length + 5U;
+    reply[2U] = MMDVM_AX25_DATA_EX;
+
+    reply[3U] = (rssi >> 8) & 0xFFU;
+    reply[4U] = (rssi >> 0) & 0xFFU;
+  
+    for (uint16_t i = 0U; i < length; i++)
+      reply[i + 5U] = data[i];
+
+    writeInt(1U, reply, length + 5U);
+  }
+}
 #endif
 
 #if defined(SERIAL_REPEATER)

SerialPort.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018,2020,2021,2024 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020,2021,2023 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
@@ -71,20 +71,15 @@ public:
   void writeM17EOT();
 #endif
 
-#if defined(MODE_DPMR)
-  void writeDPMRHeader(const uint8_t* header, uint8_t length);
-  void writeDPMRData(const uint8_t* data, uint8_t length);
-  void writeDPMRLost();
-  void writeDPMREOT();
-#endif
-
 #if defined(MODE_AX25)
   void writeAX25Data(const uint8_t* data, uint16_t length);
+  void writeAX25DataEx(uint16_t rssi, const uint8_t* data, uint16_t length);
 #endif
 
 #if defined(MODE_FM)
   void writeFMData(const uint8_t* data, uint16_t length);
   void writeFMStatus(uint8_t status);
+  void writeFMRSSI(uint16_t rssi);
   void writeFMEOT();
 #endif
 
@@ -111,10 +106,8 @@ private:
   uint16_t  m_ptr;
   uint16_t  m_len;
   bool      m_debug;
-  CRingBuffer<uint8_t> m_serialData;
   int       m_lastSerialAvail;
   uint16_t  m_lastSerialAvailCount;
-  CRingBuffer<uint8_t> m_i2CData;
 
   void    sendACK(uint8_t type);
   void    sendNAK(uint8_t type, uint8_t err);

Version.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2020,2021,2022,2024 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020,2021,2022,2023 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
@@ -19,7 +19,7 @@
 #if !defined(VERSION_H)
 #define  VERSION_H
 
-#define VERSION "20241003"
+#define VERSION "20230802"
 
 #endif
 

YSFTX.cpp

@@ -166,7 +166,7 @@ void CYSFTX::writeByte(uint8_t c)
 
 void CYSFTX::writeSilence()
 {
-  q15_t inBuffer[4U] = {0x00U, 0x00U, 0x00U, 0x00U};
+  q15_t inBuffer[4U] = {0, 0, 0, 0};
   q15_t outBuffer[YSF_RADIO_SYMBOL_LENGTH * 4U];
 
   ::arm_fir_interpolate_q15(&m_modFilter, inBuffer, outBuffer, 4U);