.gitignore

@@ -1,5 +1,3 @@
-.pio
-.vscode
 *.o
 obj/
 bin/

FM.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2020,2021,2023,2025 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020,2021,2025 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,19 +28,6 @@ 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(),
@@ -61,6 +48,7 @@ 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
@@ -80,24 +68,23 @@ 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, const uint16_t* rssi, uint8_t length)
+void CFM::samples(bool cos, q15_t* samples, uint8_t length)
 {
   if (m_linkMode)
     linkSamples(cos, samples, length);
   else
-    repeaterSamples(cos, samples, rssi, length);
+    repeaterSamples(cos, samples, length);
 }
 
-void CFM::repeaterSamples(bool cos, q15_t* samples, const uint16_t* rssi, uint8_t length)
+void CFM::repeaterSamples(bool cos, q15_t* samples, uint8_t length)
 {
   if (m_cosInvert)
     cos = !cos;
@@ -106,11 +93,6 @@ void CFM::repeaterSamples(bool cos, q15_t* samples, const uint16_t* rssi, uint8_
 
   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);
 
@@ -395,6 +377,7 @@ void CFM::reset()
   m_ackMinTimer.stop();
   m_ackDelayTimer.stop();
   m_hangTimer.stop();
+  m_statusTimer.stop();
   m_reverseTimer.stop();
 
   m_ctcssRX.reset();
@@ -600,7 +583,13 @@ 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)
@@ -609,19 +598,12 @@ 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();
     }
@@ -636,21 +618,20 @@ 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();
     }
@@ -662,6 +643,9 @@ void CFM::listeningStateDuplex(bool validRFSignal, bool validExtSignal)
 
       m_callsignTimer.start();
       m_reverseTimer.stop();
+
+      m_statusTimer.start();
+      serial.writeFMStatus(m_state);
     }
   }
 }
@@ -671,22 +655,26 @@ 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);
   }
 }
 
@@ -696,11 +684,6 @@ 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();
@@ -713,12 +696,11 @@ 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();
@@ -728,21 +710,9 @@ 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();
@@ -756,8 +726,6 @@ 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)
@@ -776,7 +744,6 @@ 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();
 
@@ -789,8 +756,6 @@ 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)
@@ -806,17 +771,11 @@ 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()) {
@@ -850,15 +809,11 @@ 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();
     }
@@ -871,8 +826,6 @@ 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();
@@ -882,12 +835,11 @@ 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;
   }
 }
@@ -898,8 +850,6 @@ 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();
@@ -907,7 +857,6 @@ 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();
   }
 
@@ -923,14 +872,12 @@ 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();
   }
 }
@@ -940,13 +887,11 @@ 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()) {
@@ -977,14 +922,11 @@ 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;
@@ -1000,11 +942,6 @@ 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();
@@ -1012,8 +949,6 @@ 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();
@@ -1022,9 +957,8 @@ 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();
@@ -1048,7 +982,6 @@ 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();
@@ -1070,7 +1003,6 @@ void CFM::timeoutRFStateSimplex(bool validSignal)
 
     DEBUG1("State to TIMEOUT_WAIT_RF");
     m_state = FS_TIMEOUT_WAIT_RF;
-    serial.writeFMStatus(m_state);
 
     m_ackDelayTimer.start();
   }
@@ -1084,14 +1016,11 @@ 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();
@@ -1116,14 +1045,11 @@ 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();
     }
@@ -1135,7 +1061,6 @@ 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();
   }
 
@@ -1150,7 +1075,6 @@ 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();
   }
 }
@@ -1160,14 +1084,11 @@ 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();
@@ -1189,14 +1110,11 @@ 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;
@@ -1213,6 +1131,7 @@ 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);
     }
 
@@ -1223,6 +1142,7 @@ 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);
     }
 
@@ -1238,7 +1158,7 @@ void CFM::linkStateMachine(bool validRFSignal, bool validExtSignal)
     if (!m_extSignal) {
       DEBUG1("State to LISTENING");
       m_state = FS_LISTENING;
-      serial.writeFMStatus(m_state);
+      m_statusTimer.stop();
     }
 
     m_rfSignal = false;
@@ -1251,7 +1171,7 @@ void CFM::linkStateMachine(bool validRFSignal, bool validExtSignal)
     if (!m_rfSignal) {
       DEBUG1("State to LISTENING");
       m_state = FS_LISTENING;
-      serial.writeFMStatus(m_state);
+      m_statusTimer.stop();
     }
 
     m_needReverse = true;

FM.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2020,2021,2023,2025 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020,2021,2025 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,12 +35,27 @@
 #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, const uint16_t* rssi, uint8_t length);
+  void samples(bool cos, q15_t* samples, uint8_t length);
 
   void process();
 
@@ -63,7 +78,7 @@ private:
   CFMCTCSSTX           m_ctcssTX;
   CFMNoiseSquelch      m_squelch;
   CFMTimeout           m_timeoutTone;
-  uint8_t              m_state;
+  FM_STATE             m_state;
   bool                 m_callsignAtStart;
   bool                 m_callsignAtEnd;
   bool                 m_callsignAtLatch;
@@ -74,6 +89,7 @@ private:
   CFMTimer             m_ackMinTimer;
   CFMTimer             m_ackDelayTimer;
   CFMTimer             m_hangTimer;
+  CFMTimer             m_statusTimer;
   CFMTimer             m_reverseTimer;
   bool                 m_needReverse;
   CFMDirectFormI       m_filterStage1;
@@ -94,12 +110,10 @@ 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, const uint16_t* rssi, uint8_t length);
+  void repeaterSamples(bool cos, q15_t* samples, uint8_t length);
   void linkSamples(bool cos, q15_t* samples, uint8_t length);
 
   void duplexStateMachine(bool validRFSignal, bool validExtSignal);

IO.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018,2020,2021,2023,2025 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020,2021,2025 by Jonathan Naylor G4KLX
  *   Copyright (C) 2015 by Jim Mclaughlin KI6ZUM
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *
@@ -457,9 +457,9 @@ void CIO::process()
       if (m_fmEnable) {
         bool cos = getCOSInt();
 #if defined(USE_DCBLOCKER)
-        fm.samples(cos, dcSamples, rssi, RX_BLOCK_SIZE);
+        fm.samples(cos, dcSamples, RX_BLOCK_SIZE);
 #else
-        fm.samples(cos, samples, rssi, RX_BLOCK_SIZE);
+        fm.samples(cos, samples, RX_BLOCK_SIZE);
 #endif
       }
 #endif

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,2023,2025 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2017,2018,2020,2025 by Jonathan Naylor G4KLX
  *   Copyright (C) 2019,2020 by BG5HHP
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -349,16 +349,10 @@ 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);
 

NXDNTX.cpp

@@ -175,7 +175,7 @@ void CNXDNTX::writeByte(uint8_t c)
 
 void CNXDNTX::writeSilence()
 {
-  q15_t inBuffer[4U] = {0, 0, 0, 0};
+  q15_t inBuffer[4U] = {0x00U, 0x00U, 0x00U, 0x00U};
   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] = {0, 0, 0, 0};
+  q15_t inBuffer[4U] = {0x00U, 0x00U, 0x00U, 0x00U};
   q15_t intBuffer[P25_RADIO_SYMBOL_LENGTH * 4U];
   q15_t outBuffer[P25_RADIO_SYMBOL_LENGTH * 4U];
 

RingBuffer.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2020,2026 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2020 by Geoffrey Merck F4FXL - KC3FRA
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -50,7 +50,7 @@ public:
   
   uint16_t getData() const;
 
-  bool put(const TDATATYPE& item) volatile;
+  bool put(TDATATYPE item) volatile;
 
   bool get(TDATATYPE& item) volatile;
 

RingBuffer.impl.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2020,2026 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2020 by Geoffrey Merck F4FXL - KC3FRA
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -56,7 +56,7 @@ template <typename TDATATYPE> uint16_t CRingBuffer<TDATATYPE>::getData() const
     return m_length - m_tail + m_head;
 }
 
-template <typename TDATATYPE> bool CRingBuffer<TDATATYPE>::put(const TDATATYPE& item) volatile
+template <typename TDATATYPE> bool CRingBuffer<TDATATYPE>::put(TDATATYPE item) volatile
 {
   if (m_full) {
     m_overflow = true;

SerialPort.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2013,2015-2021,2023,2025 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2013,2015-2021,2025 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -72,7 +72,6 @@ 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;
@@ -133,8 +132,10 @@ m_buffer(),
 m_ptr(0U),
 m_len(0U),
 m_debug(false),
+m_serialData(),
 m_lastSerialAvail(0),
-m_lastSerialAvailCount(0U)
+m_lastSerialAvailCount(0U),
+m_i2CData()
 {
 }
 
@@ -870,6 +871,20 @@ 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)) {
@@ -887,6 +902,22 @@ 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)
@@ -1233,14 +1264,18 @@ void CSerialPort::processMessage(uint8_t type, const uint8_t* buffer, uint16_t l
       break;
 
 #if defined(SERIAL_REPEATER)
-    case MMDVM_SERIAL_DATA:
+    case MMDVM_SERIAL_DATA: {
-      writeInt(3U, buffer, length);
+      for (uint16_t i = 0U; i < length; i++)
+        m_serialData.put(buffer[i]);
+      }
       break;
 #endif
 
 #if defined(I2C_REPEATER)
-    case MMDVM_I2C_DATA:
+    case MMDVM_I2C_DATA: {
-      writeInt(10U, buffer, length);
+      for (uint16_t i = 0U; i < length; i++)
+        m_i2CData.put(buffer[i]);
+      }
       break;
 #endif
 
@@ -1577,25 +1612,6 @@ 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)

SerialPort.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018,2020,2021,2023,2025 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020,2021,2025 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
@@ -67,7 +67,6 @@ public:
 #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
 
@@ -94,8 +93,10 @@ 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,2023,2025,2026 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020,2021,2022,2025 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,6 +19,7 @@
 #if !defined(VERSION_H)
 #define  VERSION_H
 
-#define VERSION "20260218"
+#define VERSION "20240113"
 
 #endif
+

YSFTX.cpp

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