Clean up the ring buffer.

Debian Trixie ships with arm-none-eabi-g++ v14.2.1 which defaults to c++17, this forces compilation with c++11

.gitignore

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

.gitmodules

@@ -4,6 +4,3 @@
 [submodule "STM32F7XX_Lib"]
 	path = STM32F7XX_Lib
 	url = https://github.com/juribeparada/STM32F7XX_Lib.git
-[submodule "STM32F10X_Lib"]
-	path = STM32F10X_Lib
-	url = https://github.com/shawnchain/STM32F10X_Lib.git

CWIdTX.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2017,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -125,7 +125,7 @@ void CCWIdTX::process()
   }
 }
 
-uint8_t CCWIdTX::write(const uint8_t* data, uint8_t length)
+uint8_t CCWIdTX::write(const uint8_t* data, uint16_t length)
 {
   ::memset(m_poBuffer, 0x00U, 1000U * sizeof(uint8_t));
 

CWIdTX.h

@@ -1,6 +1,6 @@
 /*
  *   Copyright (C) 2009-2015 by Jonathan Naylor G4KLX
- *   Copyright (C) 2016 by Colin Durbridge G4EML
+ *   Copyright (C) 2016,2020 by Colin Durbridge G4EML
  *
  *   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,7 +28,7 @@ public:
 
   void process();
 
-  uint8_t write(const uint8_t* data, uint8_t length);
+  uint8_t write(const uint8_t* data, uint16_t length);
 
   void reset();
 

CalDMR.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2015 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2015,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -18,6 +18,9 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_DMR)
+
 #include "Globals.h"
 #include "CalDMR.h"
 
@@ -208,7 +211,7 @@ void CCalDMR::dmrdmo1k()
   }
 }
 
-uint8_t CCalDMR::write(const uint8_t* data, uint8_t length)
+uint8_t CCalDMR::write(const uint8_t* data, uint16_t length)
 {
   if (length != 1U)
     return 4U;
@@ -221,3 +224,5 @@ uint8_t CCalDMR::write(const uint8_t* data, uint8_t length)
   return 0U;
 }
 
+#endif
+

CalDMR.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2015 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2015,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -17,10 +17,13 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_DMR)
+
 #if !defined(CALDMR_H)
 #define  CALDMR_H
 
-#include "Config.h"
 #include "DMRDefines.h"
 
 enum DMRCAL1K {
@@ -41,7 +44,7 @@ public:
   void createData1k(uint8_t n);
   void createDataDMO1k(uint8_t n);
 
-  uint8_t write(const uint8_t* data, uint8_t length);
+  uint8_t write(const uint8_t* data, uint16_t length);
 
 private:
   bool      m_transmit;
@@ -53,3 +56,5 @@ private:
 
 #endif
 
+#endif
+

CalDStarRX.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2016,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
@@ -17,6 +17,9 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_DSTAR)
+
 #include "Globals.h"
 #include "CalDStarRX.h"
 #include "Utils.h"
@@ -24,7 +27,7 @@
 const unsigned int BUFFER_LENGTH = 200U;
 
 const uint32_t PLLMAX = 0x10000U;
-const uint32_t PLLINC = PLLMAX / DSTAR_RADIO_BIT_LENGTH;
+const uint32_t PLLINC = PLLMAX / DSTAR_RADIO_SYMBOL_LENGTH;
 const uint32_t INC    = PLLINC / 32U;
 
 // D-Star bit order version of 0x55 0x2D 0x16
@@ -126,3 +129,5 @@ void CCalDStarRX::process(q15_t value)
   }
 }
 
+#endif
+

CalDStarRX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,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
@@ -16,10 +16,13 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_DSTAR)
+
 #if !defined(CALDSTARRX_H)
 #define  CALDSTARRX_H
 
-#include "Config.h"
 #include "DStarDefines.h"
 
 class CCalDStarRX {
@@ -40,3 +43,5 @@ private:
 
 #endif
 
+#endif
+

CalDStarTX.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2016,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
@@ -17,6 +17,9 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_DSTAR)
+
 #include "Globals.h"
 #include "CalDStarTX.h"
 
@@ -162,7 +165,7 @@ void CCalDStarTX::process()
   m_count = (m_count + 1U) % (30U * 21U);
 }
 
-uint8_t CCalDStarTX::write(const uint8_t* data, uint8_t length)
+uint8_t CCalDStarTX::write(const uint8_t* data, uint16_t length)
 {
   if (length != 1U)
     return 4U;
@@ -181,3 +184,5 @@ uint8_t CCalDStarTX::write(const uint8_t* data, uint8_t length)
   return 0U;
 }
 
+#endif
+

CalDStarTX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,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
@@ -16,17 +16,20 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_DSTAR)
+
 #if !defined(CALDSTARTX_H)
 #define  CALDSTARTX_H
 
-#include "Config.h"
 #include "DStarDefines.h"
 
 class CCalDStarTX {
 public:
   CCalDStarTX();
 
-  uint8_t write(const uint8_t* data, uint8_t length);
+  uint8_t write(const uint8_t* data, uint16_t length);
 
   void process();
 
@@ -37,3 +40,5 @@ private:
 
 #endif
 
+#endif
+

CalFM.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2015 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2015,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *   Copyright (C) 2020 by Phil Taylor M0VSE
  *
@@ -19,6 +19,9 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_FM)
+
 #include "Globals.h"
 #include "CalFM.h"
 
@@ -116,7 +119,7 @@ void CCalFM::process()
 }
 
 
-uint8_t CCalFM::write(const uint8_t* data, uint8_t length)
+uint8_t CCalFM::write(const uint8_t* data, uint16_t length)
 {
   if (length != 1U)
     return 4U;
@@ -125,3 +128,6 @@ uint8_t CCalFM::write(const uint8_t* data, uint8_t length)
 
   return 0U;
 }
+
+#endif
+

CalFM.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2015 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2015,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *   Copyright (C) 2020 by Phil Taylor M0VSE
  *
@@ -18,11 +18,13 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_FM)
+
 #if !defined(CALFM_H)
 #define  CALFM_H
 
-#include "Config.h"
-
 class CCalFM {
 public:
   CCalFM();
@@ -35,7 +37,7 @@ public:
   void fm25kcal();
   void fm30kcal();
 
-  uint8_t write(const uint8_t* data, uint8_t length);
+  uint8_t write(const uint8_t* data, uint16_t length);
 
 private:
   uint16_t  m_frequency;
@@ -49,3 +51,5 @@ private:
 
 #endif
 
+#endif
+

CalNXDN.cpp

@@ -1,5 +1,6 @@
 /*
  *   Copyright (C) 2018 by Andy Uribe CA6JAU
+ *   Copyright (C) 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
@@ -17,6 +18,9 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_NXDN)
+
 #include "Globals.h"
 #include "CalNXDN.h"
 
@@ -79,7 +83,7 @@ void CCalNXDN::process()
   }
 }
 
-uint8_t CCalNXDN::write(const uint8_t* data, uint8_t length)
+uint8_t CCalNXDN::write(const uint8_t* data, uint16_t length)
 {
   if (length != 1U)
     return 4U;
@@ -92,3 +96,5 @@ uint8_t CCalNXDN::write(const uint8_t* data, uint8_t length)
   return 0U;
 }
 
+#endif
+

CalNXDN.h

@@ -1,5 +1,6 @@
 /*
  *   Copyright (C) 2018 by Andy Uribe CA6JAU
+ *   Copyright (C) 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
@@ -16,11 +17,13 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_NXDN)
+
 #if !defined(CALNXDN_H)
 #define  CALNXDN_H
 
-#include "Config.h"
-
 enum NXDNCAL1K {
   NXDNCAL1K_IDLE,
   NXDNCAL1K_TX
@@ -32,7 +35,7 @@ public:
 
   void process();
 
-  uint8_t write(const uint8_t* data, uint8_t length);
+  uint8_t write(const uint8_t* data, uint16_t length);
 
 private:
   bool      m_transmit;
@@ -42,3 +45,5 @@ private:
 
 #endif
 
+#endif
+

CalP25.cpp

@@ -1,5 +1,6 @@
 /*
  *   Copyright (C) 2018 by Andy Uribe CA6JAU
+ *   Copyright (C) 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
@@ -17,6 +18,9 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_P25)
+
 #include "Globals.h"
 #include "CalP25.h"
 
@@ -82,7 +86,7 @@ void CCalP25::process()
   }
 }
 
-uint8_t CCalP25::write(const uint8_t* data, uint8_t length)
+uint8_t CCalP25::write(const uint8_t* data, uint16_t length)
 {
   if (length != 1U)
     return 4U;
@@ -95,3 +99,5 @@ uint8_t CCalP25::write(const uint8_t* data, uint8_t length)
   return 0U;
 }
 
+#endif
+

CalP25.h

@@ -1,5 +1,6 @@
 /*
  *   Copyright (C) 2018 by Andy Uribe CA6JAU
+ *   Copyright (C) 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
@@ -16,10 +17,13 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_P25)
+
 #if !defined(CALP25_H)
 #define  CALP25_H
 
-#include "Config.h"
 #include "P25Defines.h"
 
 enum P25CAL1K {
@@ -34,7 +38,7 @@ public:
 
   void process();
 
-  uint8_t write(const uint8_t* data, uint8_t length);
+  uint8_t write(const uint8_t* data, uint16_t length);
 
 private:
   bool      m_transmit;
@@ -43,3 +47,5 @@ private:
 
 #endif
 
+#endif
+

CalPOCSAG.cpp

@@ -1,5 +1,6 @@
 /*
  *   Copyright (C) 2019 by Florian Wolters DF2ET
+ *   Copyright (C) 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
@@ -17,10 +18,12 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_POCSAG)
+
 #include "Globals.h"
 #include "CalPOCSAG.h"
 
-
 CCalPOCSAG::CCalPOCSAG() :
 m_state(POCSAGCAL_IDLE)
 {
@@ -38,7 +41,7 @@ void CCalPOCSAG::process()
   pocsagTX.writeByte(0xAAU);
 }
 
-uint8_t CCalPOCSAG::write(const uint8_t* data, uint8_t length)
+uint8_t CCalPOCSAG::write(const uint8_t* data, uint16_t length)
 {
   if (length != 1U)
     return 4U;
@@ -47,3 +50,6 @@ uint8_t CCalPOCSAG::write(const uint8_t* data, uint8_t length)
 
   return 0U;
 }
+
+#endif
+

CalPOCSAG.h

@@ -1,5 +1,6 @@
 /*
  *   Copyright (C) 2019 by Florian Wolters DF2ET
+ *   Copyright (C) 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
@@ -16,11 +17,13 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_POCSAG)
+
 #if !defined(CALPOCSAG_H)
 #define  CALPOCSAG_H
 
-#include "Config.h"
-
 enum POCSAGCAL {
   POCSAGCAL_IDLE,
   POCSAGCAL_TX
@@ -32,10 +35,13 @@ public:
 
   void process();
 
-  uint8_t write(const uint8_t* data, uint8_t length);
+  uint8_t write(const uint8_t* data, uint16_t length);
 
 private:
   POCSAGCAL m_state;
 };
 
 #endif
+
+#endif
+

Config.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018,2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020,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,31 @@
 #if !defined(CONFIG_H)
 #define  CONFIG_H
 
+// Allow for the selection of which modes to compile into the firmware. This is particularly useful for processors
+// which have limited code space and processing power.
+
+// Enable D-Star support.
+#define MODE_DSTAR
+
+// Enable DMR support.
+#define MODE_DMR
+
+// Enable System Fusion support.
+#define MODE_YSF
+
+// Enable P25 phase 1 support.
+#define MODE_P25
+
+// Enable NXDN support, the boxcar filter sometimes improves the performance of NXDN receive on some systems.
+#define MODE_NXDN
+#define USE_NXDN_BOXCAR
+
+// Enable POCSAG support.
+#define MODE_POCSAG
+
+// Enable FM support.
+#define MODE_FM
+
 // Allow for the use of high quality external clock oscillators
 // The number is the frequency of the oscillator in Hertz.
 //
@@ -35,27 +60,20 @@
 // For 19.2 MHz
 // #define EXTERNAL_OSC 19200000
 
-// Use a higher baudrate for host communication. Required for FM network !
-#define SERIAL_SPEED 115200 //suitable for most older boards (Arduino, Due STM32F1_POG etc). External FM will NOT work with this !
-// #define SERIAL_SPEED 230400 // Only works on newer board M4, M7, Teensy. External FM might work with this
-// #define SERIAL_SPEED 460800 // Only works on newer board M4, M7, Teensy. External FM should work with this
-
-// Allow the use of the COS line to lockout the modem
-// #define USE_COS_AS_LOCKOUT
+// Select a baud rate for host communication. The faster speeds are needed for external FM to work.
+// #define SERIAL_SPEED 115200 // Suitable for most older boards (Arduino Due, etc). External FM will NOT work with this!
+// #define SERIAL_SPEED 230400 // Only works on newer boards like fast M4, M7, Teensy 3.x. External FM might work with this
+#define SERIAL_SPEED 460800	// Only works on newer boards like fast M4, M7, Teensy 3.x. External FM should work with this
+//#define SERIAL_SPEED 500000  // Used with newer boards and Armbian on AllWinner SOCs (H2, H3) that do not support 460800
 
 // Use pins to output the current mode via LEDs
-// #define MODE_LEDS
+#define MODE_LEDS
 
 // For the original Arduino Due pin layout
 // #define ARDUINO_DUE_PAPA
 
-#if defined(STM32F1)
-// For the SQ6POG board
-#define STM32F1_POG
-#else
 // For the ZUM V1.0 and V1.0.1 boards pin layout
-#define ARDUINO_DUE_ZUM_V10
-#endif
+// #define ARDUINO_DUE_ZUM_V10
 
 // For the SP8NTH board
 // #define ARDUINO_DUE_NTH
@@ -71,10 +89,16 @@
 // #define VK6MST_TEENSY_PI3_SHIELD_I2C
 
 // Pass RSSI information to the host
-// #define SEND_RSSI_DATA
+#define SEND_RSSI_DATA
 
 // Use the modem as a serial repeater for Nextion displays
-// #define SERIAL_REPEATER
+#define SERIAL_REPEATER
+
+// Set the baud rate of the modem serial repeater for Nextion displays
+#define SERIAL_REPEATER_BAUD_RATE 9600
+
+// Use the modem as an I2C repeater for OLED displays
+// #define I2C_REPEATER
 
 // To reduce CPU load, you can remove the DC blocker by commenting out the next line
 #define USE_DCBLOCKER
@@ -87,9 +111,10 @@
 // #define USE_ALTERNATE_NXDN_LEDS
 
 // Use the D-Star and DMR LEDs for POCSAG
-// #define USE_ALTERNATE_POCSAG_LEDS
+#define USE_ALTERNATE_POCSAG_LEDS
 
 // Use the D-Star and YSF LEDs for FM
 #define USE_ALTERNATE_FM_LEDS
 
 #endif
+

DMRDMORX.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2017,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
@@ -17,6 +17,9 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_DMR)
+
 #include "Globals.h"
 #include "DMRDMORX.h"
 #include "DMRSlotType.h"
@@ -423,3 +426,6 @@ void CDMRDMORX::writeRSSIData(uint8_t* frame)
   serial.writeDMRData(true, frame, DMR_FRAME_LENGTH_BYTES + 1U);
 #endif
 }
+
+#endif
+

DMRDMORX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,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
@@ -16,10 +16,13 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_DMR)
+
 #if !defined(DMRDMORX_H)
 #define  DMRDMORX_H
 
-#include "Config.h"
 #include "DMRDefines.h"
 
 const uint16_t DMO_BUFFER_LENGTH_SAMPLES = 1440U;   // 60ms at 24 kHz
@@ -67,3 +70,6 @@ private:
 };
 
 #endif
+
+#endif
+

DMRDMOTX.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2017,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *   Copyright (C) 2017 by Andy Uribe CA6JAU
  *
@@ -19,6 +19,9 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_DMR)
+
 #include "Globals.h"
 #include "DMRSlotType.h"
 
@@ -104,7 +107,7 @@ void CDMRDMOTX::process()
   }
 }
 
-uint8_t CDMRDMOTX::writeData(const uint8_t* data, uint8_t length)
+uint8_t CDMRDMOTX::writeData(const uint8_t* data, uint16_t length)
 {
   if (length != (DMR_FRAME_LENGTH_BYTES + 1U))
     return 4U;
@@ -161,3 +164,5 @@ void CDMRDMOTX::setTXDelay(uint8_t delay)
     m_txDelay = 1200U;
 }
 
+#endif
+

DMRDMOTX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -17,10 +17,13 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_DMR)
+
 #if !defined(DMRDMOTX_H)
 #define  DMRDMOTX_H
 
-#include "Config.h"
 #include "DMRDefines.h"
 
 #include "RingBuffer.h"
@@ -29,7 +32,7 @@ class CDMRDMOTX {
 public:
   CDMRDMOTX();
 
-  uint8_t writeData(const uint8_t* data, uint8_t length);
+  uint8_t writeData(const uint8_t* data, uint16_t length);
 
   void process();
 
@@ -51,3 +54,5 @@ private:
 
 #endif
 
+#endif
+

DMRIdleRX.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2017,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
@@ -17,6 +17,9 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_DMR)
+
 #include "Globals.h"
 #include "DMRIdleRX.h"
 #include "DMRSlotType.h"
@@ -209,3 +212,6 @@ void CDMRIdleRX::setColorCode(uint8_t colorCode)
 {
   m_colorCode = colorCode;
 }
+
+#endif
+

DMRIdleRX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2020 by Jonathan Naylor G4KLX
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -16,10 +16,13 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_DMR)
+
 #if !defined(DMRIDLERX_H)
 #define  DMRIDLERX_H
 
-#include "Config.h"
 #include "DMRDefines.h"
 
 class CDMRIdleRX {
@@ -49,3 +52,5 @@ private:
 
 #endif
 
+#endif
+

DMRRX.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,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
@@ -17,6 +17,9 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_DMR)
+
 #include "Globals.h"
 #include "DMRRX.h"
 
@@ -68,3 +71,5 @@ void CDMRRX::reset()
   m_slot2RX.reset();
 }
 
+#endif
+

DMRRX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,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
@@ -16,10 +16,13 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_DMR)
+
 #if !defined(DMRRX_H)
 #define  DMRRX_H
 
-#include "Config.h"
 #include "DMRSlotRX.h"
 
 class CDMRRX {
@@ -40,3 +43,5 @@ private:
 
 #endif
 
+#endif
+

DMRSlotRX.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2017,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
@@ -17,6 +17,9 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_DMR)
+
 #include "Globals.h"
 #include "DMRSlotRX.h"
 #include "DMRSlotType.h"
@@ -400,3 +403,6 @@ void CDMRSlotRX::writeRSSIData(uint8_t* frame)
   serial.writeDMRData(m_slot, frame, DMR_FRAME_LENGTH_BYTES + 1U);
 #endif
 }
+
+#endif
+

DMRSlotRX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,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
@@ -16,10 +16,13 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_DMR)
+
 #if !defined(DMRSLOTRX_H)
 #define  DMRSLOTRX_H
 
-#include "Config.h"
 #include "DMRDefines.h"
 
 enum DMRRX_STATE {
@@ -70,3 +73,6 @@ private:
 };
 
 #endif
+
+#endif
+

DMRSlotType.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2020 by Jonathan Naylor G4KLX
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -17,6 +17,9 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_DMR)
+
 #include "Globals.h"
 #include "DMRSlotType.h"
 
@@ -285,3 +288,5 @@ void CDMRSlotType::encode(uint8_t colorCode, uint8_t dataType, uint8_t* frame) c
   frame[20U] = (frame[20U] & 0x03U) | ((slotType[1U] << 6) & 0xC0U) | ((slotType[2U] >> 2) & 0x3CU);
 }
 
+#endif
+

DMRSlotType.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2020 by Jonathan Naylor G4KLX
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -16,6 +16,10 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_DMR)
+
 #if !defined(DMRSLOTTYPE_H)
 #define  DMRSLOTTYPE_H
 
@@ -35,3 +39,5 @@ private:
 
 #endif
 
+#endif
+

DMRTX.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2017,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *   Copyright (C) 2017 by Andy Uribe CA6JAU
  *
@@ -19,6 +19,9 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_DMR)
+
 #include "Globals.h"
 #include "DMRSlotType.h"
 
@@ -144,7 +147,7 @@ void CDMRTX::process()
   }
 }
 
-uint8_t CDMRTX::writeData1(const uint8_t* data, uint8_t length)
+uint8_t CDMRTX::writeData1(const uint8_t* data, uint16_t length)
 {
   if (length != (DMR_FRAME_LENGTH_BYTES + 1U))
     return 4U;
@@ -168,7 +171,7 @@ uint8_t CDMRTX::writeData1(const uint8_t* data, uint8_t length)
   return 0U;
 }
 
-uint8_t CDMRTX::writeData2(const uint8_t* data, uint8_t length)
+uint8_t CDMRTX::writeData2(const uint8_t* data, uint16_t length)
 {
   if (length != (DMR_FRAME_LENGTH_BYTES + 1U))
     return 4U;
@@ -192,7 +195,7 @@ uint8_t CDMRTX::writeData2(const uint8_t* data, uint8_t length)
   return 0U;
 }
 
-uint8_t CDMRTX::writeShortLC(const uint8_t* data, uint8_t length)
+uint8_t CDMRTX::writeShortLC(const uint8_t* data, uint16_t length)
 {
   if (length != 9U)
     return 4U;
@@ -208,7 +211,7 @@ uint8_t CDMRTX::writeShortLC(const uint8_t* data, uint8_t length)
   return 0U;
 }
 
-uint8_t CDMRTX::writeAbort(const uint8_t* data, uint8_t length)
+uint8_t CDMRTX::writeAbort(const uint8_t* data, uint16_t length)
 {
   if (length != 1U)
     return 4U;
@@ -414,3 +417,6 @@ uint32_t CDMRTX::getFrameCount()
 {
   return m_frameCount;
 }
+
+#endif
+

DMRTX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -17,10 +17,13 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_DMR)
+
 #if !defined(DMRTX_H)
 #define  DMRTX_H
 
-#include "Config.h"
 #include "DMRDefines.h"
 
 #include "RingBuffer.h"
@@ -38,11 +41,11 @@ class CDMRTX {
 public:
   CDMRTX();
 
-  uint8_t writeData1(const uint8_t* data, uint8_t length);
-  uint8_t writeData2(const uint8_t* data, uint8_t length);
+  uint8_t writeData1(const uint8_t* data, uint16_t length);
+  uint8_t writeData2(const uint8_t* data, uint16_t length);
 
-  uint8_t writeShortLC(const uint8_t* data, uint8_t length);
-  uint8_t writeAbort(const uint8_t* data, uint8_t length);
+  uint8_t writeShortLC(const uint8_t* data, uint16_t length);
+  uint8_t writeAbort(const uint8_t* data, uint16_t length);
 
   void setStart(bool start);
   void setCal(bool start);
@@ -83,3 +86,5 @@ private:
 
 #endif
 
+#endif
+

DStarDefines.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2015 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2015,2017,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
@@ -19,30 +19,50 @@
 #if !defined(DSTARDEFINES_H)
 #define  DSTARDEFINES_H
 
-const unsigned int DSTAR_RADIO_BIT_LENGTH = 5U;      // At 24 kHz sample rate
+const unsigned int DSTAR_RADIO_SYMBOL_LENGTH = 5U;      // At 24 kHz sample rate
 
-const unsigned int DSTAR_HEADER_LENGTH_BYTES = 41U;
-const unsigned int DSTAR_HEADER_LENGTH_BITS  = DSTAR_HEADER_LENGTH_BYTES * 8U;
+const unsigned int DSTAR_HEADER_LENGTH_BYTES   = 41U;
 
-const unsigned int DSTAR_FEC_SECTION_LENGTH_BYTES = 83U;
-const unsigned int DSTAR_FEC_SECTION_LENGTH_BITS  = 660U;
+const unsigned int DSTAR_FEC_SECTION_LENGTH_BYTES   = 83U;
+const unsigned int DSTAR_FEC_SECTION_LENGTH_SYMBOLS = 660U;
+const unsigned int DSTAR_FEC_SECTION_LENGTH_SAMPLES = DSTAR_FEC_SECTION_LENGTH_SYMBOLS * DSTAR_RADIO_SYMBOL_LENGTH;
 
-const unsigned int DSTAR_DATA_LENGTH_BYTES = 12U;
-const unsigned int DSTAR_DATA_LENGTH_BITS  = DSTAR_DATA_LENGTH_BYTES * 8U;
+const unsigned int DSTAR_DATA_LENGTH_BYTES   = 12U;
+const unsigned int DSTAR_DATA_LENGTH_SYMBOLS = DSTAR_DATA_LENGTH_BYTES * 8U;
+const unsigned int DSTAR_DATA_LENGTH_SAMPLES = DSTAR_DATA_LENGTH_SYMBOLS * DSTAR_RADIO_SYMBOL_LENGTH;
 
-const uint8_t      DSTAR_EOT_BYTES[] = {0x55, 0x55, 0x55, 0x55, 0xC8, 0x7A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-const unsigned int DSTAR_EOT_LENGTH_BYTES = 6U;
-const unsigned int DSTAR_EOT_LENGTH_BITS  = DSTAR_EOT_LENGTH_BYTES * 8U;
+const unsigned int DSTAR_END_SYNC_LENGTH_BYTES = 6U;
+const unsigned int DSTAR_END_SYNC_LENGTH_BITS  = DSTAR_END_SYNC_LENGTH_BYTES * 8U;
 
-const uint8_t      DSTAR_DATA_SYNC_LENGTH_BYTES = 3U;
-const uint8_t      DSTAR_DATA_SYNC_LENGTH_BITS  = DSTAR_DATA_SYNC_LENGTH_BYTES * 8U;
+const unsigned int DSTAR_FRAME_SYNC_LENGTH_BYTES   = 3U;
+const unsigned int DSTAR_FRAME_SYNC_LENGTH_SYMBOLS = DSTAR_FRAME_SYNC_LENGTH_BYTES * 8U;
+const unsigned int DSTAR_FRAME_SYNC_LENGTH_SAMPLES = DSTAR_FRAME_SYNC_LENGTH_SYMBOLS * DSTAR_RADIO_SYMBOL_LENGTH;
 
-const uint8_t      DSTAR_DATA_SYNC_BYTES[] = {0x9E, 0x8D, 0x32, 0x88, 0x26, 0x1A, 0x3F, 0x61, 0xE8, 0x55, 0x2D, 0x16};
+const unsigned int DSTAR_DATA_SYNC_LENGTH_BYTES   = 3U;
+const unsigned int DSTAR_DATA_SYNC_LENGTH_SYMBOLS = DSTAR_DATA_SYNC_LENGTH_BYTES * 8U;
+const unsigned int DSTAR_DATA_SYNC_LENGTH_SAMPLES = DSTAR_DATA_SYNC_LENGTH_SYMBOLS * DSTAR_RADIO_SYMBOL_LENGTH;
 
-const uint8_t      DSTAR_SLOW_DATA_TYPE_TEXT   = 0x40U;
-const uint8_t      DSTAR_SLOW_DATA_TYPE_HEADER = 0x50U;
+const uint8_t DSTAR_DATA_SYNC_BYTES[] = {0x9E, 0x8D, 0x32, 0x88, 0x26, 0x1A, 0x3F, 0x61, 0xE8, 0x55, 0x2D, 0x16};
 
-const uint8_t      DSTAR_SCRAMBLER_BYTES[] = {0x70U, 0x4FU, 0x93U};
+// D-Star bit order version of 0x55 0x6E 0x0A
+const uint32_t DSTAR_FRAME_SYNC_DATA = 0x00557650U;
+const uint32_t DSTAR_FRAME_SYNC_MASK = 0x00FFFFFFU;
+const bool     DSTAR_FRAME_SYNC_SYMBOLS[] = {false, true, false, true, false, true, false, true, false, true, true, true, false, true, true, false, false, true, false, true, false, false, false, false};
+
+// D-Star bit order version of 0x55 0x2D 0x16
+const uint32_t DSTAR_DATA_SYNC_DATA = 0x00AAB468U;
+const uint32_t DSTAR_DATA_SYNC_MASK = 0x00FFFFFFU;
+const bool     DSTAR_DATA_SYNC_SYMBOLS[] = {true, false, true, false, true, false, true, false, true, false, true, true, false, true, false, false, false, true, true, false, true, false, false, false};
+
+// D-Star bit order version of 0x55 0x55 0xC8 0x7A
+const uint32_t DSTAR_END_SYNC_DATA = 0xAAAA135EU;
+const uint32_t DSTAR_END_SYNC_MASK = 0xFFFFFFFFU;
+const uint8_t  DSTAR_END_SYNC_BYTES[] = {0x55, 0x55, 0x55, 0x55, 0xC8, 0x7A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+const uint8_t  DSTAR_SLOW_DATA_TYPE_TEXT   = 0x40U;
+const uint8_t  DSTAR_SLOW_DATA_TYPE_HEADER = 0x50U;
+
+const uint8_t  DSTAR_SCRAMBLER_BYTES[] = {0x70U, 0x4FU, 0x93U};
 
 #endif
 

DStarRX.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2017,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2017 by Andy Uribe CA6JAU
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -18,31 +18,28 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_DSTAR)
+
 #include "Globals.h"
 #include "DStarRX.h"
 #include "Utils.h"
 
-const unsigned int BUFFER_LENGTH = 200U;
-
-const uint32_t PLLMAX = 0x10000U;
-const uint32_t PLLINC = PLLMAX / DSTAR_RADIO_BIT_LENGTH;
-const uint32_t INC    = PLLINC / 32U;
-
-const unsigned int MAX_SYNC_BITS = 100U * DSTAR_DATA_LENGTH_BITS;
+const unsigned int MAX_FRAMES = 150U;
 
 // D-Star bit order version of 0x55 0x55 0x6E 0x0A
-const uint32_t FRAME_SYNC_DATA = 0x00557650U;
-const uint32_t FRAME_SYNC_MASK = 0x00FFFFFFU;
+const uint64_t FRAME_SYNC_DATA = 0x0000000000557650U;
+const uint64_t FRAME_SYNC_MASK = 0x0000000000FFFFFFU;
 const uint8_t  FRAME_SYNC_ERRS = 2U;
 
 // D-Star bit order version of 0x55 0x2D 0x16
-const uint32_t DATA_SYNC_DATA = 0x00AAB468U;
-const uint32_t DATA_SYNC_MASK = 0x00FFFFFFU;
+const uint64_t DATA_SYNC_DATA = 0x0000000000AAB468U;
+const uint64_t DATA_SYNC_MASK = 0x0000000000FFFFFFU;
 const uint8_t  DATA_SYNC_ERRS = 2U;
 
 // D-Star bit order version of 0x55 0x55 0xC8 0x7A
-const uint32_t END_SYNC_DATA = 0xAAAA135EU;
-const uint32_t END_SYNC_MASK = 0xFFFFFFFFU;
+const uint64_t END_SYNC_DATA = 0x0000AAAAAAAA135EU;
+const uint64_t END_SYNC_MASK = 0x0000FFFFFFFFFFFFU;
 const uint8_t  END_SYNC_ERRS = 1U;
 
 const uint8_t BIT_MASK_TABLE0[] = {0x7FU, 0xBFU, 0xDFU, 0xEFU, 0xF7U, 0xFBU, 0xFDU, 0xFEU};
@@ -237,14 +234,24 @@ const uint16_t CCITT_TABLE[] = {
   0xf78fU, 0xe606U, 0xd49dU, 0xc514U, 0xb1abU, 0xa022U, 0x92b9U, 0x8330U,
   0x7bc7U, 0x6a4eU, 0x58d5U, 0x495cU, 0x3de3U, 0x2c6aU, 0x1ef1U, 0x0f78U};
 
+const uint16_t NOENDPTR = 9999U;
+
 CDStarRX::CDStarRX() :
-m_pll(0U),
-m_prev(false),
 m_rxState(DSRXS_NONE),
-m_patternBuffer(0x00U),
-m_rxBuffer(),
-m_rxBufferBits(0U),
-m_dataBits(0U),
+m_bitBuffer(),
+m_headerBuffer(),
+m_dataBuffer(),
+m_bitPtr(0U),
+m_headerPtr(0U),
+m_dataPtr(0U),
+m_startPtr(NOENDPTR),
+m_syncPtr(NOENDPTR),
+m_minSyncPtr(NOENDPTR),
+m_maxSyncPtr(NOENDPTR),
+m_maxFrameCorr(0),
+m_maxDataCorr(0),
+m_frameCount(0U),
+m_countdown(0U),
 m_mar(0U),
 m_pathMetric(),
 m_pathMemory0(),
@@ -259,14 +266,20 @@ m_rssiCount(0U)
 
 void CDStarRX::reset()
 {
-  m_pll           = 0U;
-  m_prev          = false;
-  m_rxState       = DSRXS_NONE;
-  m_patternBuffer = 0x00U;
-  m_rxBufferBits  = 0U;
-  m_dataBits      = 0U;
-  m_rssiAccum     = 0U;
-  m_rssiCount     = 0U;
+  m_rxState      = DSRXS_NONE;
+  m_headerPtr    = 0U;
+  m_dataPtr      = 0U;
+  m_bitPtr       = 0U;
+  m_maxFrameCorr = 0;
+  m_maxDataCorr  = 0;
+  m_startPtr     = NOENDPTR;
+  m_syncPtr      = NOENDPTR;
+  m_minSyncPtr   = NOENDPTR;
+  m_maxSyncPtr   = NOENDPTR;
+  m_frameCount   = 0U;
+  m_countdown    = 0U;
+  m_rssiAccum    = 0U;
+  m_rssiCount    = 0U;
 }
 
 void CDStarRX::samples(const q15_t* samples, const uint16_t* rssi, uint8_t length)
@@ -275,125 +288,117 @@ void CDStarRX::samples(const q15_t* samples, const uint16_t* rssi, uint8_t lengt
     m_rssiAccum += rssi[i];
     m_rssiCount++;
 
-    bool bit = samples[i] < 0;
+    q15_t sample = samples[i];
 
-    if (bit != m_prev) {
-      if (m_pll < (PLLMAX / 2U))
-        m_pll += INC;
-      else
-        m_pll -= INC;
+    m_bitBuffer[m_bitPtr] <<= 1;
+    if (sample < 0)
+      m_bitBuffer[m_bitPtr] |= 0x01U;
+
+    m_dataBuffer[m_dataPtr] = sample;
+
+    switch (m_rxState) {
+      case DSRXS_HEADER:
+        processHeader(sample);
+        break;
+      case DSRXS_DATA:
+        processData();
+        break;
+      default:
+        processNone(sample);
+        break;
     }
 
-    m_prev = bit;
+    m_dataPtr++;
+    if (m_dataPtr >= DSTAR_DATA_LENGTH_SAMPLES)
+      m_dataPtr = 0U;
 
-    m_pll += PLLINC;
-
-    if (m_pll >= PLLMAX) {
-      m_pll -= PLLMAX;
-
-      switch (m_rxState) {
-        case DSRXS_NONE:
-          processNone(bit);
-          break;
-        case DSRXS_HEADER:
-          processHeader(bit);
-          break;
-        case DSRXS_DATA:
-          processData(bit);
-          break;
-        default:
-          break;
-      }
-    }
+    m_bitPtr++;
+    if (m_bitPtr >= DSTAR_RADIO_SYMBOL_LENGTH)
+      m_bitPtr = 0U;
   }
 }
 
-void CDStarRX::processNone(bool bit)
+void CDStarRX::processNone(q15_t sample)
 {
-  m_patternBuffer <<= 1;
-  if (bit)
-    m_patternBuffer |= 0x01U;
-
   // Fuzzy matching of the frame sync sequence
-  if (countBits32((m_patternBuffer & FRAME_SYNC_MASK) ^ FRAME_SYNC_DATA) <= FRAME_SYNC_ERRS) {
-    DEBUG1("DStarRX: found frame sync in None");
+  bool ret = correlateFrameSync();
+  if (ret) {
+    m_countdown = 5U;
 
-    ::memset(m_rxBuffer, 0x00U, DSTAR_FEC_SECTION_LENGTH_BYTES);
-    m_rxBufferBits = 0U;
+    m_headerBuffer[m_headerPtr] = sample;
+    m_headerPtr++;
 
     m_rssiAccum = 0U;
     m_rssiCount = 0U;
 
     m_rxState = DSRXS_HEADER;
+
     return;
   }
 
-  // Exact matching of the data sync bit sequence
-  if (countBits32((m_patternBuffer & DATA_SYNC_MASK) ^ DATA_SYNC_DATA) == 0U) {
+  // Fuzzy matching of the data sync bit sequence
+  ret = correlateDataSync();
+  if (ret) {
     DEBUG1("DStarRX: found data sync in None");
 
     io.setDecode(true);
     io.setADCDetection(true);
 
-    // Suppress RSSI on the dummy sync message
-    m_rssiAccum = 0U;
-    m_rssiCount = 0U;
-
-    ::memcpy(m_rxBuffer, DSTAR_DATA_SYNC_BYTES, DSTAR_DATA_LENGTH_BYTES);
-    writeRSSIData(m_rxBuffer);
-
-    ::memset(m_rxBuffer, 0x00U, DSTAR_DATA_LENGTH_BYTES + 2U);
-    m_rxBufferBits = 0U;
-
-    m_dataBits  = MAX_SYNC_BITS;
-    m_rxState   = DSRXS_DATA;
-    return;
+    m_rxState = DSRXS_DATA;
   }
 }
 
-void CDStarRX::processHeader(bool bit)
+void CDStarRX::processHeader(q15_t sample)
 {
-  m_patternBuffer <<= 1;
-  if (bit)
-    m_patternBuffer |= 0x01U;
+  if (m_countdown > 0U) {
+    correlateFrameSync();
+    m_countdown--;
+  }
 
-  WRITE_BIT2(m_rxBuffer, m_rxBufferBits, bit);
-  m_rxBufferBits++;
+  m_headerBuffer[m_headerPtr] = sample;
+  m_headerPtr++;
 
   // A full FEC header
-  if (m_rxBufferBits == DSTAR_FEC_SECTION_LENGTH_BITS) {
-    // Process the scrambling, interleaving and FEC, then return if the chcksum was correct
-    unsigned char header[DSTAR_HEADER_LENGTH_BYTES];
-    bool ok = rxHeader(m_rxBuffer, header);
-    if (ok) {
+  if (m_headerPtr == (DSTAR_FEC_SECTION_LENGTH_SAMPLES + DSTAR_RADIO_SYMBOL_LENGTH)) {
+    uint8_t buffer[DSTAR_FEC_SECTION_LENGTH_BYTES];
+    samplesToBits(m_headerBuffer, DSTAR_RADIO_SYMBOL_LENGTH, DSTAR_FEC_SECTION_LENGTH_SYMBOLS, buffer, DSTAR_FEC_SECTION_LENGTH_SAMPLES);
+
+    // Process the scrambling, interleaving and FEC, then return true if the chcksum was correct
+    uint8_t header[DSTAR_HEADER_LENGTH_BYTES];
+    bool ok = rxHeader(buffer, header);
+    if (!ok) {
+      // The checksum failed, return to looking for syncs
+      m_rxState = DSRXS_NONE;
+      m_maxFrameCorr = 0;
+      m_maxDataCorr  = 0;
+    } else {
       io.setDecode(true);
       io.setADCDetection(true);
 
       writeRSSIHeader(header);
-
-      ::memset(m_rxBuffer, 0x00U, DSTAR_DATA_LENGTH_BYTES + 2U);
-      m_rxBufferBits = 0U;
-
-      m_rxState  = DSRXS_DATA;
-      m_dataBits = MAX_SYNC_BITS;
-    } else {
-      // The checksum failed, return to looking for syncs
-      m_rxState = DSRXS_NONE;
     }
   }
+
+  // Ready to start the first data section
+  if (m_headerPtr == (DSTAR_FEC_SECTION_LENGTH_SAMPLES + 2U * DSTAR_RADIO_SYMBOL_LENGTH)) {
+    m_frameCount = 0U;
+    m_dataPtr    = 0U;
+
+    m_startPtr   = 476U;
+    m_syncPtr    = 471U;
+    m_maxSyncPtr = 472U;
+    m_minSyncPtr = 470U;
+
+    DEBUG5("DStarRX: calc start/sync/max/min", m_startPtr, m_syncPtr, m_maxSyncPtr, m_minSyncPtr);
+
+    m_rxState = DSRXS_DATA;
+  }
 }
 
-void CDStarRX::processData(bool bit)
+void CDStarRX::processData()
 {
-  m_patternBuffer <<= 1;
-  if (bit)
-    m_patternBuffer |= 0x01U;
-
-  WRITE_BIT2(m_rxBuffer, m_rxBufferBits, bit);
-  m_rxBufferBits++;
-
   // Fuzzy matching of the end frame sequences
-  if (countBits32((m_patternBuffer & END_SYNC_MASK) ^ END_SYNC_DATA) <= END_SYNC_ERRS) {
+  if (countBits64((m_bitBuffer[m_bitPtr] & DSTAR_END_SYNC_MASK) ^ DSTAR_END_SYNC_DATA) <= END_SYNC_ERRS) {
     DEBUG1("DStarRX: Found end sync in Data");
 
     io.setDecode(false);
@@ -401,35 +406,24 @@ void CDStarRX::processData(bool bit)
 
     serial.writeDStarEOT();
 
+    m_maxFrameCorr = 0;
+    m_maxDataCorr  = 0;
+
     m_rxState = DSRXS_NONE;
     return;
   }
 
   // Fuzzy matching of the data sync bit sequence
-  bool syncSeen = false;
-  if (m_rxBufferBits >= (DSTAR_DATA_LENGTH_BITS - 3U)) {
-    if (countBits32((m_patternBuffer & DATA_SYNC_MASK) ^ DATA_SYNC_DATA) <= DATA_SYNC_ERRS) {
-      m_rxBufferBits = DSTAR_DATA_LENGTH_BITS;
-      m_dataBits     = MAX_SYNC_BITS;
-      syncSeen       = true;
-    }
+  if (m_minSyncPtr < m_maxSyncPtr) {
+    if (m_dataPtr >= m_minSyncPtr && m_dataPtr <= m_maxSyncPtr)
+      correlateDataSync();
+  } else {
+    if (m_dataPtr >= m_minSyncPtr || m_dataPtr <= m_maxSyncPtr)
+      correlateDataSync();
   }
 
-  // Check to see if the sync is arriving late
-  if (m_rxBufferBits == DSTAR_DATA_LENGTH_BITS && !syncSeen) {
-    for (uint8_t i = 1U; i <= 3U; i++) {
-      uint32_t syncMask = DATA_SYNC_MASK >> i;
-      uint32_t syncData = DATA_SYNC_DATA >> i;
-      if (countBits32((m_patternBuffer & syncMask) ^ syncData) <= DATA_SYNC_ERRS) {
-        m_rxBufferBits -= i;
-        break;
-      }
-    }
-  }
-
-  m_dataBits--;
-
-  if (m_dataBits == 0U) {
+  // We've not seen a data sync for too long, signal RXLOST and change to RX_NONE
+  if (m_frameCount >= MAX_FRAMES) {
     DEBUG1("DStarRX: data sync timed out, lost lock");
 
     io.setDecode(false);
@@ -437,24 +431,35 @@ void CDStarRX::processData(bool bit)
 
     serial.writeDStarLost();
 
+    m_maxFrameCorr = 0;
+    m_maxDataCorr  = 0;
+
     m_rxState = DSRXS_NONE;
     return;
   }
 
-  // Send a data frame to the host if the required number of bits have been received, or if a data sync has been seen
-  if (m_rxBufferBits == DSTAR_DATA_LENGTH_BITS) {
-    if (syncSeen) {
-      m_rxBuffer[9U]  = DSTAR_DATA_SYNC_BYTES[9U];
-      m_rxBuffer[10U] = DSTAR_DATA_SYNC_BYTES[10U];
-      m_rxBuffer[11U] = DSTAR_DATA_SYNC_BYTES[11U];
-	    writeRSSIData(m_rxBuffer);
-    } else {
-	    serial.writeDStarData(m_rxBuffer, DSTAR_DATA_LENGTH_BYTES);
-	  }
+  // Send a data frame to the host if the required number of bits have been received
+  if (m_dataPtr == m_maxSyncPtr) {
+    uint8_t buffer[DSTAR_DATA_LENGTH_BYTES + 2U];
+    samplesToBits(m_dataBuffer, m_startPtr, DSTAR_DATA_LENGTH_SYMBOLS, buffer, DSTAR_DATA_LENGTH_SAMPLES);
 
-    // Start the next frame
-    ::memset(m_rxBuffer, 0x00U, DSTAR_DATA_LENGTH_BYTES + 2U);
-    m_rxBufferBits = 0U;
+    if ((m_frameCount % 21U) == 0U) {
+      if (m_frameCount == 0U) {
+        buffer[9U]  = DSTAR_DATA_SYNC_BYTES[9U];
+        buffer[10U] = DSTAR_DATA_SYNC_BYTES[10U];
+        buffer[11U] = DSTAR_DATA_SYNC_BYTES[11U];
+        DEBUG5("DStarRX: found start/sync/max/min", m_startPtr, m_syncPtr, m_maxSyncPtr, m_minSyncPtr);
+      }
+
+      writeRSSIData(buffer);
+    } else {
+      serial.writeDStarData(buffer, DSTAR_DATA_LENGTH_BYTES);
+    }
+
+    m_frameCount++;
+
+    m_maxFrameCorr = 0;
+    m_maxDataCorr  = 0;
   }
 }
 
@@ -500,6 +505,105 @@ void CDStarRX::writeRSSIData(unsigned char* data)
   m_rssiCount = 0U;
 }
 
+bool CDStarRX::correlateFrameSync()
+{
+  if (countBits64((m_bitBuffer[m_bitPtr] & DSTAR_FRAME_SYNC_MASK) ^ DSTAR_FRAME_SYNC_DATA) <= FRAME_SYNC_ERRS) {
+    uint16_t ptr = m_dataPtr + DSTAR_DATA_LENGTH_SAMPLES - DSTAR_FRAME_SYNC_LENGTH_SAMPLES + DSTAR_RADIO_SYMBOL_LENGTH;
+    if (ptr >= DSTAR_DATA_LENGTH_SAMPLES)
+      ptr -= DSTAR_DATA_LENGTH_SAMPLES;
+
+    q31_t corr = 0;
+
+    for (uint8_t i = 0U; i < DSTAR_FRAME_SYNC_LENGTH_SYMBOLS; i++) {
+      q15_t val = m_dataBuffer[ptr];
+
+      if (DSTAR_FRAME_SYNC_SYMBOLS[i])
+        corr -= val;
+      else
+        corr += val;
+
+      ptr += DSTAR_RADIO_SYMBOL_LENGTH;
+      if (ptr >= DSTAR_DATA_LENGTH_SAMPLES)
+        ptr -= DSTAR_DATA_LENGTH_SAMPLES;
+    }
+
+    if (corr > m_maxFrameCorr) {
+      m_maxFrameCorr = corr;
+      m_headerPtr    = 0U;
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool CDStarRX::correlateDataSync()
+{
+  uint8_t maxErrs = 0U;
+  if (m_rxState == DSRXS_DATA)
+    maxErrs = DATA_SYNC_ERRS;
+
+  if (countBits64((m_bitBuffer[m_bitPtr] & DSTAR_DATA_SYNC_MASK) ^ DSTAR_DATA_SYNC_DATA) <= maxErrs) {
+    uint16_t ptr = m_dataPtr + DSTAR_DATA_LENGTH_SAMPLES - DSTAR_DATA_SYNC_LENGTH_SAMPLES + DSTAR_RADIO_SYMBOL_LENGTH;
+    if (ptr >= DSTAR_DATA_LENGTH_SAMPLES)
+      ptr -= DSTAR_DATA_LENGTH_SAMPLES;
+
+    q31_t corr = 0;
+
+    for (uint8_t i = 0U; i < DSTAR_DATA_SYNC_LENGTH_SYMBOLS; i++) {
+      q15_t val = m_dataBuffer[ptr];
+
+      if (DSTAR_DATA_SYNC_SYMBOLS[i])
+        corr -= val;
+      else
+        corr += val;
+
+      ptr += DSTAR_RADIO_SYMBOL_LENGTH;
+      if (ptr >= DSTAR_DATA_LENGTH_SAMPLES)
+        ptr -= DSTAR_DATA_LENGTH_SAMPLES;
+    }
+
+    if (corr > m_maxDataCorr) {
+      m_maxDataCorr = corr;
+      m_frameCount  = 0U;
+
+      m_syncPtr    = m_dataPtr;
+
+      m_startPtr   = m_dataPtr + DSTAR_RADIO_SYMBOL_LENGTH;
+      if (m_startPtr >= DSTAR_DATA_LENGTH_SAMPLES)
+        m_startPtr -= DSTAR_DATA_LENGTH_SAMPLES;
+
+      m_maxSyncPtr = m_syncPtr + 1U;
+      if (m_maxSyncPtr >= DSTAR_DATA_LENGTH_SAMPLES)
+        m_maxSyncPtr -= DSTAR_DATA_LENGTH_SAMPLES;
+
+      m_minSyncPtr = m_syncPtr + DSTAR_DATA_LENGTH_SAMPLES - 1U;
+      if (m_minSyncPtr >= DSTAR_DATA_LENGTH_SAMPLES)
+        m_minSyncPtr -= DSTAR_DATA_LENGTH_SAMPLES;
+
+      return true;
+    }
+  }
+
+  return false;
+}
+
+void CDStarRX::samplesToBits(const q15_t* inBuffer, uint16_t start, uint16_t count, uint8_t* outBuffer, uint16_t limit)
+{
+  for (uint16_t i = 0U; i < count; i++) {
+    q15_t sample = inBuffer[start];
+
+    if (sample < 0)
+      WRITE_BIT2(outBuffer, i, true);
+    else
+      WRITE_BIT2(outBuffer, i, false);
+
+    start += DSTAR_RADIO_SYMBOL_LENGTH;
+    if (start >= limit)
+      start -= limit;
+  }
+}
+
 bool CDStarRX::rxHeader(uint8_t* in, uint8_t* out)
 {
   int i;
@@ -715,3 +819,6 @@ bool CDStarRX::checksum(const uint8_t* header) const
 
   return crc8[0U] == header[DSTAR_HEADER_LENGTH_BYTES - 2U] && crc8[1U] == header[DSTAR_HEADER_LENGTH_BYTES - 1U];
 }
+
+#endif
+

DStarRX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,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
@@ -16,10 +16,13 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_DSTAR)
+
 #if !defined(DSTARRX_H)
 #define  DSTARRX_H
 
-#include "Config.h"
 #include "DStarDefines.h"
 
 enum DSRX_STATE {
@@ -37,13 +40,21 @@ public:
   void reset();
 
 private:
-  uint32_t     m_pll;
-  bool         m_prev;
   DSRX_STATE   m_rxState;
-  uint32_t     m_patternBuffer;
-  uint8_t      m_rxBuffer[100U];
-  unsigned int m_rxBufferBits;
-  unsigned int m_dataBits;
+  uint64_t     m_bitBuffer[DSTAR_RADIO_SYMBOL_LENGTH];
+  q15_t        m_headerBuffer[DSTAR_FEC_SECTION_LENGTH_SAMPLES + 2U * DSTAR_RADIO_SYMBOL_LENGTH];
+  q15_t        m_dataBuffer[DSTAR_DATA_LENGTH_SAMPLES];
+  uint16_t     m_bitPtr;
+  uint16_t     m_headerPtr;
+  uint16_t     m_dataPtr;
+  uint16_t     m_startPtr;
+  uint16_t     m_syncPtr;
+  uint16_t     m_minSyncPtr;
+  uint16_t     m_maxSyncPtr;
+  q31_t        m_maxFrameCorr;
+  q31_t        m_maxDataCorr;
+  uint16_t     m_frameCount;
+  uint8_t      m_countdown;
   unsigned int m_mar;
   int          m_pathMetric[4U];
   unsigned int m_pathMemory0[42U];
@@ -54,9 +65,12 @@ private:
   uint32_t     m_rssiAccum;
   uint16_t     m_rssiCount;
   
-  void    processNone(bool bit);
-  void    processHeader(bool bit);
-  void    processData(bool bit);
+  void    processNone(q15_t sample);
+  void    processHeader(q15_t sample);
+  void    processData();
+  bool    correlateFrameSync();
+  bool    correlateDataSync();
+  void    samplesToBits(const q15_t* inBuffer, uint16_t start, uint16_t count, uint8_t* outBuffer, uint16_t limit);
   void    writeRSSIHeader(unsigned char* header);
   void    writeRSSIData(unsigned char* data);
   bool    rxHeader(uint8_t* in, uint8_t* out);
@@ -68,3 +82,5 @@ private:
 
 #endif
 
+#endif
+

DStarTX.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2017,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2017 by Andy Uribe CA6JAU
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -18,6 +18,9 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_DSTAR)
+
 #include "Globals.h"
 #include "DStarTX.h"
 
@@ -198,7 +201,7 @@ m_txDelay(60U)       // 100ms
 {
   ::memset(m_modState, 0x00U, 20U * sizeof(q15_t));
 
-  m_modFilter.L           = DSTAR_RADIO_BIT_LENGTH;
+  m_modFilter.L           = DSTAR_RADIO_SYMBOL_LENGTH;
   m_modFilter.phaseLength = GAUSSIAN_0_35_FILTER_PHASE_LEN;
   m_modFilter.pCoeffs     = GAUSSIAN_0_35_FILTER;
   m_modFilter.pState      = m_modState;
@@ -216,8 +219,8 @@ void CDStarTX::process()
       for (uint16_t i = 0U; i < m_txDelay; i++)
         m_poBuffer[m_poLen++] = BIT_SYNC;
     } else {
-      uint8_t dummy;
       // Pop the type byte off
+      uint8_t dummy;
       m_buffer.get(dummy);
 
       uint8_t header[DSTAR_HEADER_LENGTH_BYTES];
@@ -255,8 +258,8 @@ void CDStarTX::process()
     m_buffer.get(dummy);
 
     for (uint8_t j = 0U; j < 3U; j++) {
-      for (uint8_t i = 0U; i < DSTAR_EOT_LENGTH_BYTES; i++)
-        m_poBuffer[m_poLen++] = DSTAR_EOT_BYTES[i];
+      for (uint8_t i = 0U; i < DSTAR_END_SYNC_LENGTH_BYTES; i++)
+        m_poBuffer[m_poLen++] = DSTAR_END_SYNC_BYTES[i];
     }
      
     m_poPtr = 0U;
@@ -265,11 +268,11 @@ void CDStarTX::process()
   if (m_poLen > 0U) {
     uint16_t space = io.getSpace();
     
-    while (space > (8U * DSTAR_RADIO_BIT_LENGTH)) {
+    while (space > (8U * DSTAR_RADIO_SYMBOL_LENGTH)) {
       uint8_t c = m_poBuffer[m_poPtr++];
       writeByte(c);
 
-      space -= 8U * DSTAR_RADIO_BIT_LENGTH;
+      space -= 8U * DSTAR_RADIO_SYMBOL_LENGTH;
       
       if (m_poPtr >= m_poLen) {
         m_poPtr = 0U;
@@ -280,7 +283,7 @@ void CDStarTX::process()
   }
 }
 
-uint8_t CDStarTX::writeHeader(const uint8_t* header, uint8_t length)
+uint8_t CDStarTX::writeHeader(const uint8_t* header, uint16_t length)
 {
   if (length != DSTAR_HEADER_LENGTH_BYTES)
     return 4U;
@@ -299,7 +302,7 @@ uint8_t CDStarTX::writeHeader(const uint8_t* header, uint8_t length)
   return 0U;
 }
 
-uint8_t CDStarTX::writeData(const uint8_t* data, uint8_t length)
+uint8_t CDStarTX::writeData(const uint8_t* data, uint16_t length)
 {
   if (length != DSTAR_DATA_LENGTH_BYTES)
     return 4U;
@@ -415,7 +418,7 @@ void CDStarTX::txHeader(const uint8_t* in, uint8_t* out) const
 void CDStarTX::writeByte(uint8_t c)
 {
   q15_t inBuffer[8U];
-  q15_t outBuffer[DSTAR_RADIO_BIT_LENGTH * 8U];
+  q15_t outBuffer[DSTAR_RADIO_SYMBOL_LENGTH * 8U];
 
   uint8_t mask = 0x01U;
 
@@ -430,7 +433,7 @@ void CDStarTX::writeByte(uint8_t c)
 
   ::arm_fir_interpolate_q15(&m_modFilter, inBuffer, outBuffer, 8U);
   
-  io.write(STATE_DSTAR, outBuffer, DSTAR_RADIO_BIT_LENGTH * 8U);
+  io.write(STATE_DSTAR, outBuffer, DSTAR_RADIO_SYMBOL_LENGTH * 8U);
 }
 
 void CDStarTX::setTXDelay(uint8_t delay)
@@ -446,3 +449,5 @@ uint8_t CDStarTX::getSpace() const
   return m_buffer.getSpace() / (DSTAR_DATA_LENGTH_BYTES + 1U);
 }
 
+#endif
+

DStarTX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,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
@@ -16,19 +16,21 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_DSTAR)
+
 #if !defined(DSTARTX_H)
 #define  DSTARTX_H
 
-#include "Config.h"
-
 #include "RingBuffer.h"
 
 class CDStarTX {
 public:
   CDStarTX();
 
-  uint8_t writeHeader(const uint8_t* header, uint8_t length);
-  uint8_t writeData(const uint8_t* data, uint8_t length);
+  uint8_t writeHeader(const uint8_t* header, uint16_t length);
+  uint8_t writeData(const uint8_t* data, uint16_t length);
   uint8_t writeEOT();
 
   void process();
@@ -52,3 +54,5 @@ private:
 
 #endif
 
+#endif
+

Debug.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,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
@@ -27,6 +27,7 @@
 #define  DEBUG3(a,b,c)      serial.writeDebug((a),(b),(c))
 #define  DEBUG4(a,b,c,d)    serial.writeDebug((a),(b),(c),(d))
 #define  DEBUG5(a,b,c,d,e)  serial.writeDebug((a),(b),(c),(d),(e))
+#define  DEBUG_DUMP(a,b)    serial.writeDebugDump((a),(b))
 
 #endif
 

FM.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020,2021,2023,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
@@ -16,11 +16,13 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_FM)
+
 #if !defined(FM_H)
 #define  FM_H
 
-#include "Config.h"
-
 #include "FMBlanking.h"
 #include "FMCTCSSRX.h"
 #include "FMCTCSSTX.h"
@@ -29,30 +31,16 @@
 #include "FMTimer.h"
 #include "RingBuffer.h"
 #include "FMDirectForm1.h"
-#include "FMDownsampler.h"
+#include "FMDownSampler.h"
 #include "FMUpSampler.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
-};
+#include "FMNoiseSquelch.h"
 
 
 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();
 
@@ -60,12 +48,12 @@ public:
 
   uint8_t setCallsign(const char* callsign, uint8_t speed, uint16_t frequency, uint8_t time, uint8_t holdoff, uint8_t highLevel, uint8_t lowLevel, bool callsignAtStart, bool callsignAtEnd, bool callsignAtLatch);
   uint8_t setAck(const char* rfAck, uint8_t speed, uint16_t frequency, uint8_t minTime, uint16_t delay, uint8_t level);
-  uint8_t setMisc(uint16_t timeout, uint8_t timeoutLevel, uint8_t ctcssFrequency, uint8_t ctcssHighThreshold, uint8_t ctcssLowThreshold, uint8_t ctcssLevel, uint8_t kerchunkTime, bool kerchunkTX, uint8_t hangTime, bool useCOS, bool cosInvert, uint8_t rfAudioBoost, uint8_t maxDev, uint8_t rxLevel);
+  uint8_t setMisc(uint16_t timeout, uint8_t timeoutLevel, uint8_t ctcssFrequency, uint8_t ctcssHighThreshold, uint8_t ctcssLowThreshold, uint8_t ctcssLevel, uint8_t kerchunkTime, uint8_t hangTime, uint8_t accessMode, bool linkMode, bool cosInvert, bool noiseSquelch, uint8_t squelchHighThreshold, uint8_t squelchLowThreshold, uint8_t rfAudioBoost, uint8_t maxDev, uint8_t rxLevel);
   uint8_t setExt(const char* ack, uint8_t audioBoost, uint8_t speed, uint16_t frequency, uint8_t level);
 
   uint8_t getSpace() const;
 
-  uint8_t writeData(const uint8_t* data, uint8_t length);
+  uint8_t writeData(const uint8_t* data, uint16_t length);
 
 private:
   CFMKeyer             m_callsign;
@@ -73,8 +61,9 @@ private:
   CFMKeyer             m_extAck;
   CFMCTCSSRX           m_ctcssRX;
   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;
@@ -82,39 +71,63 @@ private:
   CFMTimer             m_timeoutTimer;
   CFMTimer             m_holdoffTimer;
   CFMTimer             m_kerchunkTimer;
-  bool                 m_kerchunkTX;
   CFMTimer             m_ackMinTimer;
   CFMTimer             m_ackDelayTimer;
   CFMTimer             m_hangTimer;
-  CFMTimer             m_statusTimer;
+  CFMTimer             m_reverseTimer;
+  bool                 m_needReverse;
   CFMDirectFormI       m_filterStage1;
   CFMDirectFormI       m_filterStage2;
   CFMDirectFormI       m_filterStage3;
   CFMBlanking          m_blanking;
-  bool                 m_useCOS;
+  uint8_t              m_accessMode;
+  bool                 m_linkMode;
   bool                 m_cosInvert;
+  bool                 m_noiseSquelch;
   q15_t                m_rfAudioBoost;
   q15_t                m_extAudioBoost;
-  CFMDownsampler       m_downsampler;
+  CFMDownSampler       m_downSampler;
   bool                 m_extEnabled;
   q15_t                m_rxLevel;
   CRingBuffer<q15_t>   m_inputRFRB;
   CRingBuffer<q15_t>   m_outputRFRB;
   CFMUpSampler         m_inputExtRB;
+  bool                 m_rfSignal;
+  bool                 m_extSignal;
+  uint32_t             m_rssiAccum;
+  uint16_t             m_rssiCount;
 
   void stateMachine(bool validRFSignal, bool validExtSignal);
-  void listeningState(bool validRFSignal, bool validExtSignal);
-  void kerchunkRFState(bool validSignal);
-  void relayingRFState(bool validSignal);
-  void relayingRFWaitState(bool validSignal);
-  void timeoutRFState(bool validSignal);
-  void timeoutRFWaitState(bool validSignal);
-  void kerchunkExtState(bool validSignal);
-  void relayingExtState(bool validSignal);
-  void relayingExtWaitState(bool validSignal);
-  void timeoutExtState(bool validSignal);
-  void timeoutExtWaitState(bool validSignal);
-  void hangState(bool validRFSignal, bool validExtSignal);
+
+  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);
+  void listeningStateDuplex(bool validRFSignal, bool validExtSignal);
+  void kerchunkRFStateDuplex(bool validSignal);
+  void relayingRFStateDuplex(bool validSignal);
+  void relayingRFWaitStateDuplex(bool validSignal);
+  void timeoutRFStateDuplex(bool validSignal);
+  void timeoutRFWaitStateDuplex(bool validSignal);
+  void kerchunkExtStateDuplex(bool validSignal);
+  void relayingExtStateDuplex(bool validSignal);
+  void relayingExtWaitStateDuplex(bool validSignal);
+  void timeoutExtStateDuplex(bool validSignal);
+  void timeoutExtWaitStateDuplex(bool validSignal);
+  void hangStateDuplex(bool validRFSignal, bool validExtSignal);
+
+  void simplexStateMachine(bool validRFSignal, bool validExtSignal);
+  void listeningStateSimplex(bool validRFSignal, bool validExtSignal);
+  void relayingRFStateSimplex(bool validSignal);
+  void relayingRFWaitStateSimplex(bool validSignal);
+  void timeoutRFStateSimplex(bool validSignal);
+  void timeoutRFWaitStateSimplex(bool validSignal);
+  void relayingExtStateSimplex(bool validSignal);
+  void relayingExtWaitStateSimplex(bool validSignal);
+  void timeoutExtStateSimplex(bool validSignal);
+  void timeoutExtWaitStateSimplex(bool validSignal);
+
+  void linkStateMachine(bool validRFSignal, bool validExtSignal);
 
   void clock(uint8_t length);
 
@@ -126,3 +139,6 @@ private:
 };
 
 #endif
+
+#endif
+

FMBlanking.cpp

@@ -17,6 +17,9 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_FM)
+
 #include "Globals.h"
 #include "FMBlanking.h"
 
@@ -80,3 +83,6 @@ q15_t CFMBlanking::process(q15_t sample)
 
   return sample;
 }
+
+#endif
+

FMBlanking.h

@@ -16,11 +16,13 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_FM)
+
 #if !defined(FMBlanking_H)
 #define  FMBlanking_H
 
-#include "Config.h"
-
 class CFMBlanking {
 public:
   CFMBlanking();
@@ -39,3 +41,6 @@ private:
 };
 
 #endif
+
+#endif
+

FMCTCSSRX.cpp

@@ -17,6 +17,9 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_FM)
+
 #include "Globals.h"
 #include "FMCTCSSRX.h"
 
@@ -87,7 +90,7 @@ m_lowThreshold(0),
 m_count(0U),
 m_q0(0),
 m_q1(0),
-m_result(CTS_NONE)
+m_state(false)
 {
 }
 
@@ -111,13 +114,11 @@ uint8_t CFMCTCSSRX::setParams(uint8_t frequency, uint8_t highThreshold, uint8_t
   return 0U;
 }
 
-uint8_t CFMCTCSSRX::process(q15_t sample)
+bool CFMCTCSSRX::process(q15_t sample)
 {
   //get more dynamic into the decoder by multiplying the sample by 1.5
   q31_t sample31 = q31_t(sample) +  (q31_t(sample) >> 1);
 
-  m_result &= ~CTS_READY;
-
   q31_t q2 = m_q1;
   m_q1 = m_q0;
 
@@ -149,33 +150,32 @@ uint8_t CFMCTCSSRX::process(q15_t sample)
     // value = m_q0 * m_q0 + m_q1 * m_q1 - m_q0 * m_q1 * m_coeffDivTwo * 2
     q31_t value = t2 + t4 - t9;
 
-    bool previousCTCSSValid = CTCSS_VALID(m_result);
+    bool previousState = m_state;
 
     q31_t threshold = m_highThreshold;
-    if (previousCTCSSValid)
+    if (previousState)
       threshold = m_lowThreshold;
 
-    m_result |= CTS_READY;
-    if (value >= threshold)
-      m_result |= CTS_VALID;
-    else
-      m_result &= ~CTS_VALID;
+    m_state = value >= threshold;
 
-    if (previousCTCSSValid != CTCSS_VALID(m_result))
-      DEBUG4("CTCSS Value / Threshold / Valid", value, threshold, CTCSS_VALID(m_result));
+    if (previousState != m_state)
+      DEBUG4("CTCSS Value / Threshold / Valid", value, threshold, m_state);
 
     m_count = 0U;
     m_q0 = 0;
     m_q1 = 0;
   }
 
-  return m_result;
+  return m_state;
 }
 
 void CFMCTCSSRX::reset()
 {
   m_q0 = 0;
   m_q1 = 0;
-  m_result = CTS_NONE;
-  m_count  = 0U;
+  m_state = false;
+  m_count = 0U;
 }
+
+#endif
+

FMCTCSSRX.h

@@ -16,19 +16,12 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#if !defined(FMCTCSSRX_H)
-#define  FMCTCSSRX_H
-
 #include "Config.h"
 
-const uint8_t CTS_NONE  = 0U;
-const uint8_t CTS_READY = 1U;
-const uint8_t CTS_VALID = 2U;
+#if defined(MODE_FM)
 
-#define CTCSS_READY(a) ((a & CTS_READY) != 0)
-#define CTCSS_NOT_READY(a) ((a & CTS_READY) == 0)
-#define CTCSS_VALID(a) ((a & CTS_VALID) != 0)
-#define CTCSS_NOT_VALID(a) ((a & CTS_VALID) == 0)
+#if !defined(FMCTCSSRX_H)
+#define  FMCTCSSRX_H
 
 class CFMCTCSSRX {
 public:
@@ -36,7 +29,7 @@ public:
 
   uint8_t setParams(uint8_t frequency, uint8_t highThreshold, uint8_t lowThreshold);
   
-  uint8_t process(q15_t sample);
+  bool process(q15_t sample);
 
   void reset();
 
@@ -47,7 +40,10 @@ private:
   uint16_t m_count;
   q31_t    m_q0;
   q31_t    m_q1;
-  uint8_t  m_result;
+  bool     m_state;
 };
 
 #endif
+
+#endif
+

FMCTCSSTX.cpp

@@ -17,6 +17,9 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_FM)
+
 #include "Globals.h"
 #include "FMCTCSSTX.h"
 
@@ -115,11 +118,17 @@ uint8_t CFMCTCSSTX::setParams(uint8_t frequency, uint8_t level)
   return 0U;
 }
 
-q15_t CFMCTCSSTX::getAudio()
+q15_t CFMCTCSSTX::getAudio(bool reverse)
 {
   q15_t sample = m_values[m_n++];
-  if(m_n >= m_length)
+  if (m_n >= m_length)
     m_n = 0U;
   
-  return sample;
+  if (reverse)
+    return -sample;
+  else
+    return sample;
 }
+
+#endif
+

FMCTCSSTX.h

@@ -16,18 +16,20 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_FM)
+
 #if !defined(FMCTCSSTX_H)
 #define  FMCTCSSTX_H
 
-#include "Config.h"
-
 class CFMCTCSSTX {
 public:
   CFMCTCSSTX();
 
   uint8_t setParams(uint8_t frequency, uint8_t level);
 
-  q15_t getAudio();
+  q15_t getAudio(bool reverse);
 
 private:
   q15_t*   m_values;
@@ -36,3 +38,6 @@ private:
 };
 
 #endif
+
+#endif
+

FMDirectForm1.h

@@ -29,6 +29,10 @@ THE SOFTWARE.
 
 // based on https://raw.githubusercontent.com/berndporr/iir_fixed_point/master/DirectFormI.h
 
+#include "Config.h"
+
+#if defined(MODE_FM)
+
 #include <cstdint>
 
 #ifndef DIRECTFORMI_H_
@@ -38,8 +42,7 @@ class CFMDirectFormI
 public:
 
 	// convenience function which takes the a0 argument but ignores it!
-	CFMDirectFormI(const q31_t b0, const q31_t b1, const q31_t b2,
-			const q31_t, const q31_t a1, const q31_t a2)
+	CFMDirectFormI(const q31_t b0, const q31_t b1, const q31_t b2, const q31_t, const q31_t a1, const q31_t a2)
 	{
 		// FIR coefficients
 		c_b0 = b0;
@@ -53,21 +56,21 @@ public:
 
 	CFMDirectFormI(const CFMDirectFormI &my)
 	{
-	// delay line
+		// delay line
 		m_x2 = my.m_x2; // x[n-2]
 		m_y2 = my.m_y2; // y[n-2]
 		m_x1 = my.m_x1; // x[n-1]
 		m_y1 = my.m_y1; // y[n-1]
 
-	// coefficients
+		// coefficients
 		c_b0 = my.c_b0;
 		c_b1 = my.c_b1;
 		c_b2 = my.c_b2; // FIR
 		c_a1 = my.c_a1;
 		c_a2 = my.c_a2; // IIR
-    }
+	}
 
-	void reset ()
+	void reset()
 	{
 		m_x1 = 0;
 		m_x2 = 0;
@@ -79,11 +82,7 @@ public:
 	inline q15_t filter(const q15_t in)
 	{
 		// calculate the output
-		register q31_t out_upscaled = c_b0 * in
-									+ c_b1 * m_x1
-									+ c_b2 * m_x2
-									- c_a1 * m_y1
-									- c_a2 * m_y2;
+		q31_t out_upscaled = c_b0 * in + c_b1 * m_x1 + c_b2 * m_x2 - c_a1 * m_y1 - c_a2 * m_y2;
 
 		q15_t out = __SSAT(out_upscaled >> 15, 15);
 
@@ -108,4 +107,7 @@ private:
 	q31_t c_a1,c_a2; // IIR
 };
 
-#endif /* DIRECTFORMI_H */
+#endif /* DIRECTFORMI_H */
+
+#endif
+

FMDownSampler.cpp

@@ -18,9 +18,12 @@
  */
 
 #include "Config.h"
-#include "FMDownsampler.h"
 
-CFMDownsampler::CFMDownsampler(uint16_t length) :
+#if defined(MODE_FM)
+
+#include "FMDownSampler.h"
+
+CFMDownSampler::CFMDownSampler(uint16_t length) :
 m_ringBuffer(length),
 m_samplePack(0U),
 m_samplePackPointer(NULL),
@@ -29,7 +32,7 @@ m_sampleIndex(0U)
   m_samplePackPointer = (uint8_t*)&m_samplePack;
 }
 
-void CFMDownsampler::addSample(q15_t sample)
+void CFMDownSampler::addSample(q15_t sample)
 {
   uint32_t usample = uint32_t(int32_t(sample) + 2048);
   //only take one of three samples
@@ -54,21 +57,24 @@ void CFMDownsampler::addSample(q15_t sample)
   }
 
   m_sampleIndex++;
-  if(m_sampleIndex >= 6U)//did we pack two samples ?
+  if (m_sampleIndex >= 6U)//did we pack two samples ?
       m_sampleIndex = 0U;  
 }
 
-bool CFMDownsampler::getPackedData(TSamplePairPack& data)
+bool CFMDownSampler::getPackedData(TSamplePairPack& data)
 {
   return m_ringBuffer.get(data);
 }
 
-uint16_t CFMDownsampler::getData()
+uint16_t CFMDownSampler::getData()
 {
   return m_ringBuffer.getData();
 }
 
-void CFMDownsampler::reset()
+void CFMDownSampler::reset()
 {
   m_sampleIndex = 0U;
-}
+}
+
+#endif
+

FMDownSampler.h

@@ -17,19 +17,26 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_FM)
+
 #if !defined(FMDOWNSAMPLER_H)
 #define FMDOWNSAMPLER_H
 
-#include "Config.h"
 #include "RingBuffer.h"
 #include "FMSamplePairPack.h"
 
-class CFMDownsampler {
+class CFMDownSampler {
 public:
-  CFMDownsampler(uint16_t length);
+  CFMDownSampler(uint16_t length);
+
   void addSample(q15_t sample);
+
   bool getPackedData(TSamplePairPack& data);
+
   uint16_t getData();
+
   void reset();
 
 private:
@@ -40,3 +47,6 @@ private:
 };
 
 #endif
+
+#endif
+

FMKeyer.cpp

@@ -17,6 +17,9 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_FM)
+
 #include "Globals.h"
 #include "FMKeyer.h"
 
@@ -214,3 +217,6 @@ bool CFMKeyer::isRunning() const
 {
   return m_poPos > 0U || m_dotPos > 0U || m_audioPos > 0U;
 }
+
+#endif
+

FMKeyer.h

@@ -16,11 +16,13 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_FM)
+
 #if !defined(FMKeyer_H)
 #define  FMKeyer_H
 
-#include "Config.h"
-
 class CFMKeyer {
 public:
   CFMKeyer();
@@ -52,3 +54,6 @@ private:
 };
 
 #endif
+
+#endif
+

FMNoiseSquelch.cpp

@@ -0,0 +1,133 @@
+/*
+ *   Copyright (C) 2020 by Jonathan Naylor G4KLX
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "Config.h"
+
+#if defined(MODE_FM)
+
+#include "Globals.h"
+#include "FMNoiseSquelch.h"
+
+// 4500Hz centre frequency
+const q31_t COEFF_DIV_TWO = 821806413;
+
+// 400Hz bandwidth
+const uint16_t N = 24000U / 400U;
+
+CFMNoiseSquelch::CFMNoiseSquelch() :
+m_highThreshold(0),
+m_lowThreshold(0),
+m_count(0U),
+m_q0(0),
+m_q1(0),
+m_state(false),
+m_validCount(0U)
+{
+
+}
+
+void CFMNoiseSquelch::setParams(uint8_t highThreshold, uint8_t lowThreshold)
+{
+  m_highThreshold = q31_t(highThreshold);
+  m_lowThreshold  = q31_t(lowThreshold);
+}
+
+bool CFMNoiseSquelch::process(q15_t sample)
+{
+  //get more dynamic into the decoder by multiplying the sample by 64
+  q31_t sample31 = q31_t(sample) << 6; //+  (q31_t(sample) >> 1);
+
+  q31_t q2 = m_q1;
+  m_q1 = m_q0;
+
+  // Q31 multiplication, t3 = m_coeffDivTwo * 2 * m_q1
+  q63_t t1 = COEFF_DIV_TWO * m_q1;
+  q31_t t2 = __SSAT((t1 >> 31), 31);
+  q31_t t3 = t2 * 2;
+
+  // m_q0 = m_coeffDivTwo * m_q1 * 2 - q2 + sample
+  m_q0 = t3 - q2 + sample31;
+
+  m_count++;
+  if (m_count == N) {
+    // Q31 multiplication, t2 = m_q0 * m_q0
+    q63_t t1 = q63_t(m_q0) * q63_t(m_q0);
+    q31_t t2 = __SSAT((t1 >> 31), 31);
+
+    // Q31 multiplication, t4 = m_q0 * m_q0
+    q63_t t3 = q63_t(m_q1) * q63_t(m_q1);
+    q31_t t4 = __SSAT((t3 >> 31), 31);
+
+    // Q31 multiplication, t9 = m_q0 * m_q1 * m_coeffDivTwo * 2
+    q63_t t5 = q63_t(m_q0) * q63_t(m_q1);
+    q31_t t6 = __SSAT((t5 >> 31), 31);
+    q63_t t7 = t6 * COEFF_DIV_TWO;
+    q31_t t8 = __SSAT((t7 >> 31), 31);
+    q31_t t9  = t8 * 2;
+
+    // value = m_q0 * m_q0 + m_q1 * m_q1 - m_q0 * m_q1 * m_coeffDivTwo * 2
+    q31_t value = t2 + t4 - t9;
+
+    bool previousState = m_state;
+
+    q31_t threshold = m_highThreshold;
+    if (previousState)
+      threshold = m_lowThreshold;
+
+    if (!m_state) {
+      if (value < threshold)
+        m_validCount++;
+      else
+        m_validCount = 0U;
+    }
+
+    if (m_state) {
+      if (value >= threshold)
+        m_invalidCount++;
+      else
+        m_invalidCount = 0U;
+    }
+
+    m_state = m_validCount >= 10U && m_invalidCount < 10U;
+
+    if(previousState && !m_state)
+      m_invalidCount = 0U;
+
+    if (previousState != m_state) {
+      DEBUG4("Noise Squelch Value / Threshold / Valid", value, threshold, m_state);
+      DEBUG3("Valid Count / Invalid Count", m_validCount, m_invalidCount);
+    }
+
+    m_count = 0U;
+    m_q0 = 0;
+    m_q1 = 0;
+  }
+
+  return m_state;
+}
+
+void CFMNoiseSquelch::reset()
+{
+  m_q0 = 0;
+  m_q1 = 0;
+  m_state = false;
+  m_count = 0U;
+}
+
+#endif
+

FMNoiseSquelch.h

@@ -0,0 +1,50 @@
+/*
+ *   Copyright (C) 2020 by Jonathan Naylor G4KLX
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "Config.h"
+
+#if defined(MODE_FM)
+
+#if !defined(FMNOISESQUELCH_H)
+#define  FMNOISESQUELCH_H
+
+class CFMNoiseSquelch {
+public:
+  CFMNoiseSquelch();
+
+  void setParams(uint8_t highThreshold, uint8_t lowThreshold);
+  
+  bool process(q15_t sample);
+
+  void reset();
+
+private:
+  q31_t    m_highThreshold;
+  q31_t    m_lowThreshold;
+  uint16_t m_count;
+  q31_t    m_q0;
+  q31_t    m_q1;
+  bool     m_state;
+  uint8_t  m_validCount;
+  uint8_t  m_invalidCount;
+};
+
+#endif
+
+#endif
+

FMSamplePairPack.h

@@ -17,6 +17,10 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_FM)
+
 #if !defined(TSAMPLEPACK_H)
 #define TSAMPLEPACK_H
 
@@ -26,4 +30,7 @@ struct TSamplePairPack {
   uint8_t byte2;
 };
 
-#endif
+#endif
+
+#endif
+

FMTimeout.cpp

@@ -17,6 +17,9 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_FM)
+
 #include "Globals.h"
 #include "FMTimeout.h"
 
@@ -36,24 +39,22 @@ m_n(0U)
 
 void CFMTimeout::setParams(uint8_t level)
 {
-  m_level = q15_t(level * 128);
+  m_level = q15_t(level * 5);
 }
 
 q15_t CFMTimeout::getAudio()
 {
-  q15_t sample = 0U;
+  q15_t sample = 0;
   if (!m_running)
     return sample;
 
-  if (m_pos > 12000U) {
-    q31_t sample = BUSY_AUDIO[m_n] * m_level;
-    sample = q15_t(__SSAT((sample >> 15), 16));
+  if (m_pos >= 12000U) {
+    q31_t sample31 = BUSY_AUDIO[m_n] * m_level;
+    sample = q15_t(__SSAT((sample31 >> 15), 16));
 
     m_n++;
     if (m_n >= BUSY_AUDIO_LEN)
       m_n = 0U;
-  } else {
-    sample = 0U;
   }
 
   m_pos++;
@@ -74,3 +75,6 @@ void CFMTimeout::stop()
 {
   m_running = false;
 }
+
+#endif
+

FMTimeout.h

@@ -16,11 +16,13 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_FM)
+
 #if !defined(FMTimeout_H)
 #define  FMTimeout_H
 
-#include "Config.h"
-
 class CFMTimeout {
 public:
   CFMTimeout();
@@ -40,3 +42,6 @@ private:
 };
 
 #endif
+
+#endif
+

FMTimer.cpp

@@ -17,6 +17,9 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_FM)
+
 #include "Globals.h"
 #include "FMTimer.h"
 
@@ -68,3 +71,6 @@ bool CFMTimer::hasExpired() const
 
   return false;
 }
+
+#endif
+

FMTimer.h

@@ -16,11 +16,13 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_FM)
+
 #if !defined(FMTimer_H)
 #define  FMTimer_H
 
-#include "Config.h"
-
 class CFMTimer {
 public:
   CFMTimer();
@@ -45,3 +47,6 @@ private:
 };
 
 #endif
+
+#endif
+

FMUpSampler.cpp

@@ -17,6 +17,10 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_FM)
+
 #include "FMUpSampler.h"
 
 const uint32_t FM_UPSAMPLE_MASK = 0x00000FFFU;
@@ -94,4 +98,7 @@ uint16_t CFMUpSampler::getSpace() const
 {
   //return available space in bytes
   return m_samples.getSpace() * sizeof(TSamplePairPack);
-}
+}
+
+#endif
+

FMUpSampler.h

@@ -18,10 +18,13 @@
  */
 
 
+#include "Config.h"
+
+#if defined(MODE_FM)
+
 #if !defined(FMUPSAMPLER_H)
 #define FMUPSAMPLER_H
 
-#include "Config.h"
 #include "RingBuffer.h"
 #include "FMSamplePairPack.h"
 
@@ -45,4 +48,7 @@ private:
   bool m_running;
 };
 
-#endif
+#endif
+
+#endif
+

Globals.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018,2020 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
@@ -23,15 +23,12 @@
 #include "stm32f4xx.h"
 #elif defined(STM32F7XX)
 #include "stm32f7xx.h"
-#elif defined(STM32F105xC)
-#include "stm32f1xx.h"
-#include "STM32Utils.h"
 #else
 #include <Arduino.h>
 #undef PI //Undefine PI to get rid of annoying warning as it is also defined in arm_math.h.
 #endif
 
-#if defined(__SAM3X8E__) || defined(STM32F105xC)
+#if defined(__SAM3X8E__)
 #define  ARM_MATH_CM3
 #elif defined(STM32F7XX)
 #define  ARM_MATH_CM7
@@ -110,7 +107,7 @@ const uint16_t RX_BLOCK_SIZE = 2U;
 const uint16_t TX_RINGBUFFER_SIZE = 500U;
 const uint16_t RX_RINGBUFFER_SIZE = 600U;
 
-#if defined(STM32F105xC) || defined(__MK20DX256__)
+#if defined(__MK20DX256__)
 const uint16_t TX_BUFFER_LEN = 2000U;
 #else
 const uint16_t TX_BUFFER_LEN = 4000U;
@@ -134,9 +131,15 @@ extern bool m_dcd;
 extern CSerialPort serial;
 extern CIO io;
 
+#if defined(MODE_DSTAR)
 extern CDStarRX dstarRX;
 extern CDStarTX dstarTX;
 
+extern CCalDStarRX calDStarRX;
+extern CCalDStarTX calDStarTX;
+#endif
+
+#if defined(MODE_DMR)
 extern CDMRIdleRX dmrIdleRX;
 extern CDMRRX dmrRX;
 extern CDMRTX dmrTX;
@@ -144,28 +147,41 @@ extern CDMRTX dmrTX;
 extern CDMRDMORX dmrDMORX;
 extern CDMRDMOTX dmrDMOTX;
 
+extern CCalDMR calDMR;
+#endif
+
+#if defined(MODE_YSF)
 extern CYSFRX ysfRX;
 extern CYSFTX ysfTX;
+#endif
 
+#if defined(MODE_P25)
 extern CP25RX p25RX;
 extern CP25TX p25TX;
 
+extern CCalP25 calP25;
+#endif
+
+#if defined(MODE_NXDN)
 extern CNXDNRX nxdnRX;
 extern CNXDNTX nxdnTX;
 
-extern CPOCSAGTX pocsagTX;
+extern CCalNXDN calNXDN;
+#endif
 
-extern CFM fm;
+#if defined(MODE_POCSAG)
+extern CPOCSAGTX  pocsagTX;
+extern CCalPOCSAG calPOCSAG;
+#endif
 
-extern CCalDStarRX calDStarRX;
-extern CCalDStarTX calDStarTX;
-extern CCalDMR     calDMR;
-extern CCalFM      calFM;
-extern CCalP25     calP25;
-extern CCalNXDN    calNXDN;
-extern CCalPOCSAG  calPOCSAG;
-extern CCalRSSI    calRSSI;
+#if defined(MODE_FM)
+extern CFM    fm;
+extern CCalFM calFM;
+#endif
+
+extern CCalRSSI calRSSI;
 
 extern CCWIdTX cwIdTX;
 
 #endif
+

IO.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018,2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020,2021,2023,2025 by Jonathan Naylor G4KLX
  *   Copyright (C) 2015 by Jim Mclaughlin KI6ZUM
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *
@@ -22,16 +22,26 @@
 #include "Globals.h"
 #include "IO.h"
 
+#if defined(USE_DCBLOCKER)
 // Generated using [b, a] = butter(1, 0.001) in MATLAB
 static q31_t   DC_FILTER[] = {3367972, 0, 3367972, 0, 2140747704, 0}; // {b0, 0, b1, b2, -a1, -a2}
 const uint32_t DC_FILTER_STAGES = 1U; // One Biquad stage
+#endif
 
+#if defined(MODE_DMR) || defined(MODE_YSF)
 // Generated using rcosdesign(0.2, 8, 5, 'sqrt') in MATLAB
 static q15_t RRC_0_2_FILTER[] = {401, 104, -340, -731, -847, -553, 112, 909, 1472, 1450, 683, -675, -2144, -3040, -2706, -770, 2667, 6995,
                                  11237, 14331, 15464, 14331, 11237, 6995, 2667, -770, -2706, -3040, -2144, -675, 683, 1450, 1472, 909, 112,
                                  -553, -847, -731, -340, 104, 401, 0};
 const uint16_t RRC_0_2_FILTER_LEN = 42U;
+#endif
 
+#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;
+#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,
@@ -43,14 +53,20 @@ const uint16_t NXDN_0_2_FILTER_LEN = 82U;
 static q15_t NXDN_ISINC_FILTER[] = {790, -1085, -1073, -553, 747, 2341, 3156, 2152, -893, -4915, -7834, -7536, -3102, 4441, 12354, 17394, 17394,
                                    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
 static q15_t   GAUSSIAN_0_5_FILTER[] = {8, 104, 760, 3158, 7421, 9866, 7421, 3158, 760, 104, 8, 0};
 const uint16_t GAUSSIAN_0_5_FILTER_LEN = 12U;
+#endif
 
+#if defined(MODE_P25)
 // One symbol boxcar filter
-static q15_t   BOXCAR_FILTER[] = {12000, 12000, 12000, 12000, 12000, 0};
-const uint16_t BOXCAR_FILTER_LEN = 6U;
+static q15_t   BOXCAR5_FILTER[] = {12000, 12000, 12000, 12000, 12000, 0};
+const uint16_t BOXCAR5_FILTER_LEN = 6U;
+#endif
 
 const uint16_t DC_OFFSET = 2048U;
 
@@ -59,18 +75,37 @@ m_started(false),
 m_rxBuffer(RX_RINGBUFFER_SIZE),
 m_txBuffer(TX_RINGBUFFER_SIZE),
 m_rssiBuffer(RX_RINGBUFFER_SIZE),
+#if defined(USE_DCBLOCKER)
 m_dcFilter(),
 m_dcState(),
-m_rrcFilter(),
+#endif
+#if defined(MODE_DSTAR)
 m_gaussianFilter(),
-m_boxcarFilter(),
+m_gaussianState(),
+#endif
+#if defined(MODE_DMR)
+m_rrc02Filter1(),
+m_rrc02State1(),
+#endif
+#if defined(MODE_YSF)
+m_rrc02Filter2(),
+m_rrc02State2(),
+#endif
+#if defined(MODE_P25)
+m_boxcar5Filter(),
+m_boxcar5State(),
+#endif
+#if defined(MODE_NXDN)
+#if defined(USE_NXDN_BOXCAR)
+m_boxcar10Filter(),
+m_boxcar10State(),
+#else
 m_nxdnFilter(),
 m_nxdnISincFilter(),
-m_rrcState(),
-m_gaussianState(),
-m_boxcarState(),
 m_nxdnState(),
 m_nxdnISincState(),
+#endif
+#endif
 m_pttInvert(false),
 m_rxLevel(128 * 128),
 m_cwIdTXLevel(128 * 128),
@@ -83,6 +118,7 @@ m_pocsagTXLevel(128 * 128),
 m_fmTXLevel(128 * 128),
 m_rxDCOffset(DC_OFFSET),
 m_txDCOffset(DC_OFFSET),
+m_useCOSAsLockout(false),
 m_ledCount(0U),
 m_ledValue(true),
 m_detect(false),
@@ -91,30 +127,52 @@ m_dacOverflow(0U),
 m_watchdog(0U),
 m_lockout(false)
 {
-  ::memset(m_rrcState,      0x00U,  70U * sizeof(q15_t));
-  ::memset(m_gaussianState, 0x00U,  40U * sizeof(q15_t));
-  ::memset(m_boxcarState,   0x00U,  30U * sizeof(q15_t));
-  ::memset(m_nxdnState,     0x00U, 110U * sizeof(q15_t));
-  ::memset(m_nxdnISincState, 0x00U, 60U * sizeof(q15_t));
-  ::memset(m_dcState,       0x00U,   4U * sizeof(q31_t));
-
+#if defined(USE_DCBLOCKER)
+  ::memset(m_dcState, 0x00U, 4U * sizeof(q31_t));
   m_dcFilter.numStages = DC_FILTER_STAGES;
   m_dcFilter.pState    = m_dcState;
   m_dcFilter.pCoeffs   = DC_FILTER;
   m_dcFilter.postShift = 0;
+#endif
 
-  m_rrcFilter.numTaps = RRC_0_2_FILTER_LEN;
-  m_rrcFilter.pState  = m_rrcState;
-  m_rrcFilter.pCoeffs = RRC_0_2_FILTER;
-
+#if defined(MODE_DSTAR)
+  ::memset(m_gaussianState, 0x00U, 40U * sizeof(q15_t));
   m_gaussianFilter.numTaps = GAUSSIAN_0_5_FILTER_LEN;
   m_gaussianFilter.pState  = m_gaussianState;
   m_gaussianFilter.pCoeffs = GAUSSIAN_0_5_FILTER;
+#endif
+
+#if defined(MODE_DMR)
+  ::memset(m_rrc02State1, 0x00U, 70U * sizeof(q15_t));
+  m_rrc02Filter1.numTaps = RRC_0_2_FILTER_LEN;
+  m_rrc02Filter1.pState  = m_rrc02State1;
+  m_rrc02Filter1.pCoeffs = RRC_0_2_FILTER;
+#endif
+
+#if defined(MODE_YSF)
+  ::memset(m_rrc02State2, 0x00U, 70U * sizeof(q15_t));
+  m_rrc02Filter2.numTaps = RRC_0_2_FILTER_LEN;
+  m_rrc02Filter2.pState  = m_rrc02State2;
+  m_rrc02Filter2.pCoeffs = RRC_0_2_FILTER;
+#endif
+
+#if defined(MODE_P25)
+  ::memset(m_boxcar5State, 0x00U, 30U * sizeof(q15_t));
+  m_boxcar5Filter.numTaps = BOXCAR5_FILTER_LEN;
+  m_boxcar5Filter.pState  = m_boxcar5State;
+  m_boxcar5Filter.pCoeffs = BOXCAR5_FILTER;
+#endif
+
+#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;
+#else
+  ::memset(m_nxdnState,      0x00U, 110U * sizeof(q15_t));
+  ::memset(m_nxdnISincState, 0x00U, 60U * sizeof(q15_t));
 
-  m_boxcarFilter.numTaps = BOXCAR_FILTER_LEN;
-  m_boxcarFilter.pState  = m_boxcarState;
-  m_boxcarFilter.pCoeffs = BOXCAR_FILTER;
-  
   m_nxdnFilter.numTaps = NXDN_0_2_FILTER_LEN;
   m_nxdnFilter.pState  = m_nxdnState;
   m_nxdnFilter.pCoeffs = NXDN_0_2_FILTER;
@@ -122,6 +180,8 @@ m_lockout(false)
   m_nxdnISincFilter.numTaps = NXDN_ISINC_FILTER_LEN;
   m_nxdnISincFilter.pState  = m_nxdnISincState;
   m_nxdnISincFilter.pCoeffs = NXDN_ISINC_FILTER;
+#endif
+#endif
 
   initInt();
   
@@ -132,7 +192,7 @@ void CIO::selfTest()
 {
   bool ledValue = false;
 
-  for (uint8_t i = 0; i < 6; i++) {
+  for (uint8_t i = 0U; i < 6U; i++) {
     ledValue = !ledValue;
 
     // We exclude PTT to avoid trigger the transmitter
@@ -143,21 +203,34 @@ void CIO::selfTest()
     setDMRInt(ledValue);
     setYSFInt(ledValue);
     setP25Int(ledValue);
+#if !defined(USE_ALTERNATE_NXDN_LEDS)
     setNXDNInt(ledValue);
+#endif
+#if !defined(USE_ALTERNATE_POCSAG_LEDS)
     setPOCSAGInt(ledValue);
+#endif
+#if !defined(USE_ALTERNATE_FM_LEDS)
     setFMInt(ledValue);
+#endif
 #endif
     delayInt(250);
   }
 
 #if defined(MODE_LEDS)
-  setDStarInt(true);
+  setDStarInt(false);
   setDMRInt(false);
   setYSFInt(false);
   setP25Int(false);
+#if !defined(USE_ALTERNATE_NXDN_LEDS)
   setNXDNInt(false);
+#endif
+#if !defined(USE_ALTERNATE_POCSAG_LEDS)
   setPOCSAGInt(false);
+#endif
+#if !defined(USE_ALTERNATE_FM_LEDS)
   setFMInt(false);
+#endif
+  setDStarInt(true);
 
   delayInt(250);
   setDMRInt(true);
@@ -219,7 +292,7 @@ void CIO::start()
 
   m_started = true;
 
-  setMode();
+  setMode(STATE_IDLE);
 }
 
 void CIO::process()
@@ -229,10 +302,11 @@ void CIO::process()
     // 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_POCSAG) {
+#if defined(MODE_DMR)
         if (m_modemState == STATE_DMR && m_tx)
           dmrTX.setStart(false);
-        m_modemState = STATE_IDLE;
-        setMode();
+#endif
+        setMode(STATE_IDLE);
       }
 
       m_watchdog = 0U;
@@ -256,9 +330,8 @@ void CIO::process()
     return;
   }
 
-#if defined(USE_COS_AS_LOCKOUT)
-  m_lockout = getCOSInt();
-#endif
+  if (m_useCOSAsLockout)
+    m_lockout = getCOSInt();
 
   // Switch off the transmitter if needed
   if (m_txBuffer.getData() == 0U && m_tx) {
@@ -310,6 +383,7 @@ void CIO::process()
 #endif
 
     if (m_modemState == STATE_IDLE) {
+#if defined(MODE_DSTAR)
       if (m_dstarEnable) {
         q15_t GMSKVals[RX_BLOCK_SIZE];
 #if defined(USE_DCBLOCKER)
@@ -319,54 +393,80 @@ void CIO::process()
 #endif
         dstarRX.samples(GMSKVals, rssi, RX_BLOCK_SIZE);
       }
+#endif
 
+#if defined(MODE_P25)
       if (m_p25Enable) {
         q15_t P25Vals[RX_BLOCK_SIZE];
 #if defined(USE_DCBLOCKER)
-        ::arm_fir_fast_q15(&m_boxcarFilter, dcSamples, P25Vals, RX_BLOCK_SIZE);
+        ::arm_fir_fast_q15(&m_boxcar5Filter, dcSamples, P25Vals, RX_BLOCK_SIZE);
 #else
-        ::arm_fir_fast_q15(&m_boxcarFilter, samples, P25Vals, RX_BLOCK_SIZE);
+        ::arm_fir_fast_q15(&m_boxcar5Filter, samples, P25Vals, RX_BLOCK_SIZE);
 #endif
         p25RX.samples(P25Vals, rssi, RX_BLOCK_SIZE);
       }
+#endif
 
+#if defined(MODE_NXDN)
       if (m_nxdnEnable) {
+        q15_t NXDNVals[RX_BLOCK_SIZE];
+#if defined(USE_NXDN_BOXCAR)
+#if defined(USE_DCBLOCKER)
+        ::arm_fir_fast_q15(&m_boxcar10Filter, dcSamples, NXDNVals, RX_BLOCK_SIZE);
+#else
+        ::arm_fir_fast_q15(&m_boxcar10Filter, samples, NXDNVals, RX_BLOCK_SIZE);
+#endif
+#else
         q15_t NXDNValsTmp[RX_BLOCK_SIZE];
 #if defined(USE_DCBLOCKER)
         ::arm_fir_fast_q15(&m_nxdnFilter, dcSamples, NXDNValsTmp, RX_BLOCK_SIZE);
 #else
         ::arm_fir_fast_q15(&m_nxdnFilter, samples, NXDNValsTmp, RX_BLOCK_SIZE);
 #endif
-        q15_t NXDNVals[RX_BLOCK_SIZE];
         ::arm_fir_fast_q15(&m_nxdnISincFilter, NXDNValsTmp, NXDNVals, RX_BLOCK_SIZE);
-
+#endif
         nxdnRX.samples(NXDNVals, rssi, RX_BLOCK_SIZE);
       }
+#endif
 
-      if (m_dmrEnable || m_ysfEnable) {
-        q15_t RRCVals[RX_BLOCK_SIZE];
-        ::arm_fir_fast_q15(&m_rrcFilter, samples, RRCVals, RX_BLOCK_SIZE);
+#if defined(MODE_DMR)
+      if (m_dmrEnable) {
+        q15_t DMRVals[RX_BLOCK_SIZE];
+        ::arm_fir_fast_q15(&m_rrc02Filter1, samples, DMRVals, RX_BLOCK_SIZE);
 
-        if (m_ysfEnable)
-          ysfRX.samples(RRCVals, rssi, RX_BLOCK_SIZE);
-
-        if (m_dmrEnable) {
-          if (m_duplex)
-            dmrIdleRX.samples(RRCVals, RX_BLOCK_SIZE);
-          else
-            dmrDMORX.samples(RRCVals, rssi, RX_BLOCK_SIZE);
-        }
+        if (m_duplex)
+          dmrIdleRX.samples(DMRVals, RX_BLOCK_SIZE);
+        else
+          dmrDMORX.samples(DMRVals, rssi, RX_BLOCK_SIZE);
       }
+#endif
 
+#if defined(MODE_YSF)
+      if (m_ysfEnable) {
+        q15_t YSFVals[RX_BLOCK_SIZE];
+#if defined(USE_DCBLOCKER)
+        ::arm_fir_fast_q15(&m_rrc02Filter2, dcSamples, YSFVals, RX_BLOCK_SIZE);
+#else
+        ::arm_fir_fast_q15(&m_rrc02Filter2, samples, YSFVals, RX_BLOCK_SIZE);
+#endif
+        ysfRX.samples(YSFVals, 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
       }
-    } else if (m_modemState == STATE_DSTAR) {
+#endif
+    }
+
+#if defined(MODE_DSTAR)
+    else if (m_modemState == STATE_DSTAR) {
       if (m_dstarEnable) {
         q15_t GMSKVals[RX_BLOCK_SIZE];
 #if defined(USE_DCBLOCKER)
@@ -376,10 +476,14 @@ void CIO::process()
 #endif
         dstarRX.samples(GMSKVals, rssi, RX_BLOCK_SIZE);
       }
-    } else if (m_modemState == STATE_DMR) {
+    }
+#endif
+
+#if defined(MODE_DMR)
+    else if (m_modemState == STATE_DMR) {
       if (m_dmrEnable) {
         q15_t DMRVals[RX_BLOCK_SIZE];
-        ::arm_fir_fast_q15(&m_rrcFilter, samples, DMRVals, RX_BLOCK_SIZE);
+        ::arm_fir_fast_q15(&m_rrc02Filter1, samples, DMRVals, RX_BLOCK_SIZE);
 
         if (m_duplex) {
           // If the transmitter isn't on, use the DMR idle RX to detect the wakeup CSBKs
@@ -391,52 +495,82 @@ void CIO::process()
           dmrDMORX.samples(DMRVals, rssi, RX_BLOCK_SIZE);
         }
       }
-    } else if (m_modemState == STATE_YSF) {
+    }
+#endif
+
+#if defined(MODE_YSF)
+    else if (m_modemState == STATE_YSF) {
       if (m_ysfEnable) {
         q15_t YSFVals[RX_BLOCK_SIZE];
 #if defined(USE_DCBLOCKER)
-        ::arm_fir_fast_q15(&m_rrcFilter, dcSamples, YSFVals, RX_BLOCK_SIZE);
+        ::arm_fir_fast_q15(&m_rrc02Filter2, dcSamples, YSFVals, RX_BLOCK_SIZE);
 #else
-        ::arm_fir_fast_q15(&m_rrcFilter, samples, YSFVals, RX_BLOCK_SIZE);
+        ::arm_fir_fast_q15(&m_rrc02Filter2, samples, YSFVals, RX_BLOCK_SIZE);
 #endif
         ysfRX.samples(YSFVals, rssi, RX_BLOCK_SIZE);
       }
-    } else if (m_modemState == STATE_P25) {
+    }
+#endif
+
+#if defined(MODE_P25)
+    else if (m_modemState == STATE_P25) {
       if (m_p25Enable) {
         q15_t P25Vals[RX_BLOCK_SIZE];
 #if defined(USE_DCBLOCKER)
-        ::arm_fir_fast_q15(&m_boxcarFilter, dcSamples, P25Vals, RX_BLOCK_SIZE);
+        ::arm_fir_fast_q15(&m_boxcar5Filter, dcSamples, P25Vals, RX_BLOCK_SIZE);
 #else
-        ::arm_fir_fast_q15(&m_boxcarFilter, samples, P25Vals, RX_BLOCK_SIZE);
+        ::arm_fir_fast_q15(&m_boxcar5Filter, samples, P25Vals, RX_BLOCK_SIZE);
 #endif
         p25RX.samples(P25Vals, rssi, RX_BLOCK_SIZE);
       }
-    } else if (m_modemState == STATE_NXDN) {
+    }
+#endif
+
+#if defined(MODE_NXDN)
+    else if (m_modemState == STATE_NXDN) {
       if (m_nxdnEnable) {
+        q15_t NXDNVals[RX_BLOCK_SIZE];
+#if defined(USE_NXDN_BOXCAR)
+#if defined(USE_DCBLOCKER)
+        ::arm_fir_fast_q15(&m_boxcar10Filter, dcSamples, NXDNVals, RX_BLOCK_SIZE);
+#else
+        ::arm_fir_fast_q15(&m_boxcar10Filter, samples, NXDNVals, RX_BLOCK_SIZE);
+#endif
+#else
         q15_t NXDNValsTmp[RX_BLOCK_SIZE];
 #if defined(USE_DCBLOCKER)
         ::arm_fir_fast_q15(&m_nxdnFilter, dcSamples, NXDNValsTmp, RX_BLOCK_SIZE);
 #else
         ::arm_fir_fast_q15(&m_nxdnFilter, samples, NXDNValsTmp, RX_BLOCK_SIZE);
 #endif
-        q15_t NXDNVals[RX_BLOCK_SIZE];
         ::arm_fir_fast_q15(&m_nxdnISincFilter, NXDNValsTmp, NXDNVals, RX_BLOCK_SIZE);
-
+#endif
         nxdnRX.samples(NXDNVals, rssi, RX_BLOCK_SIZE);
       }
-    } else if (m_modemState == STATE_FM) {
+    }
+#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);
 #else
       fm.samples(cos, samples, RX_BLOCK_SIZE);
 #endif
-    } else if (m_modemState == STATE_DSTARCAL) {
+    }
+#endif
+
+#if defined(MODE_DSTAR)
+    else if (m_modemState == STATE_DSTARCAL) {
       q15_t GMSKVals[RX_BLOCK_SIZE];
       ::arm_fir_fast_q15(&m_gaussianFilter, samples, GMSKVals, RX_BLOCK_SIZE);
 
       calDStarRX.samples(GMSKVals, RX_BLOCK_SIZE);
-    } else if (m_modemState == STATE_RSSICAL) {
+    }
+#endif
+
+    else if (m_modemState == STATE_RSSICAL) {
       calRSSI.samples(rssi, RX_BLOCK_SIZE);
     }
   }
@@ -519,20 +653,39 @@ void CIO::setADCDetection(bool detect)
   m_detect = detect;
 }
 
-void CIO::setMode()
+void CIO::setMode(MMDVM_STATE state)
 {
+  if (state == m_modemState)
+    return;
+
 #if defined(MODE_LEDS)
-  setDStarInt(m_modemState == STATE_DSTAR);
-  setDMRInt(m_modemState   == STATE_DMR);
-  setYSFInt(m_modemState   == STATE_YSF);
-  setP25Int(m_modemState   == STATE_P25);
-  setNXDNInt(m_modemState  == STATE_NXDN);
-  setPOCSAGInt(m_modemState  == STATE_POCSAG);
-  setFMInt(m_modemState == STATE_FM);
+  switch (m_modemState) {
+    case STATE_DSTAR:  setDStarInt(false);  break;
+    case STATE_DMR:    setDMRInt(false);    break;
+    case STATE_YSF:    setYSFInt(false);    break;
+    case STATE_P25:    setP25Int(false);    break;
+    case STATE_NXDN:   setNXDNInt(false);   break;
+    case STATE_POCSAG: setPOCSAGInt(false); break;
+    case STATE_FM:     setFMInt(false);     break;
+    default: break;
+  }
+
+  switch (state) {
+    case STATE_DSTAR:  setDStarInt(true);  break;
+    case STATE_DMR:    setDMRInt(true);    break;
+    case STATE_YSF:    setYSFInt(true);    break;
+    case STATE_P25:    setP25Int(true);    break;
+    case STATE_NXDN:   setNXDNInt(true);   break;
+    case STATE_POCSAG: setPOCSAGInt(true); break;
+    case STATE_FM:     setFMInt(true);     break;
+    default: break;
+  }
 #endif
+
+  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 pocsagTXLevel, uint8_t fmTXLevel, int16_t txDCOffset, int16_t rxDCOffset)
+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 pocsagTXLevel, uint8_t fmTXLevel, int16_t txDCOffset, int16_t rxDCOffset, bool useCOSAsLockout)
 {
   m_pttInvert = pttInvert;
 
@@ -548,6 +701,8 @@ void CIO::setParameters(bool rxInvert, bool txInvert, bool pttInvert, uint8_t rx
 
   m_rxDCOffset   = DC_OFFSET + rxDCOffset;
   m_txDCOffset   = DC_OFFSET + txDCOffset;
+
+  m_useCOSAsLockout = useCOSAsLockout;
   
   if (rxInvert)
     m_rxLevel = -m_rxLevel;

IO.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018,2020 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
@@ -42,11 +42,11 @@ public:
 
   void setDecode(bool dcd);
   void setADCDetection(bool detect);
-  void setMode();
+  void setMode(MMDVM_STATE state);
   
   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 pocsagTXLevel, uint8_t fmTXLevel, int16_t txDCOffset, int16_t rxDCOffset);
+  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 pocsagTXLevel, uint8_t fmTXLevel, int16_t txDCOffset, int16_t rxDCOffset, bool useCOSAsLockout);
 
   void getOverflow(bool& adcOverflow, bool& dacOverflow);
 
@@ -58,6 +58,10 @@ public:
   void resetWatchdog();
   uint32_t getWatchdog();
   
+  uint8_t getCPU() const;
+
+  void getUDID(uint8_t* buffer);
+
   void selfTest();
 
 private:
@@ -67,19 +71,42 @@ private:
   CRingBuffer<TSample>  m_txBuffer;
   CRingBuffer<uint16_t> m_rssiBuffer;
 
+#if defined(USE_DCBLOCKER)
   arm_biquad_casd_df1_inst_q31 m_dcFilter;
   q31_t                        m_dcState[4];
+#endif
 
-  arm_fir_instance_q15 m_rrcFilter;
+#if defined(MODE_DSTAR)
   arm_fir_instance_q15 m_gaussianFilter;
-  arm_fir_instance_q15 m_boxcarFilter;
+  q15_t                m_gaussianState[40U];      // NoTaps + BlockSize - 1, 12 + 20 - 1 plus some spare
+#endif
+
+#if defined(MODE_DMR)
+  arm_fir_instance_q15 m_rrc02Filter1;
+  q15_t                m_rrc02State1[70U];         // NoTaps + BlockSize - 1, 42 + 20 - 1 plus some spare
+#endif
+
+#if defined(MODE_YSF)
+  arm_fir_instance_q15 m_rrc02Filter2;
+  q15_t                m_rrc02State2[70U];         // NoTaps + BlockSize - 1, 42 + 20 - 1 plus some spare
+#endif
+
+#if defined(MODE_P25)
+  arm_fir_instance_q15 m_boxcar5Filter;
+  q15_t                m_boxcar5State[30U];        // NoTaps + BlockSize - 1,  6 + 20 - 1 plus some spare
+#endif
+
+#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
+#else
   arm_fir_instance_q15 m_nxdnFilter;
   arm_fir_instance_q15 m_nxdnISincFilter;
-  q15_t                m_rrcState[70U];           // NoTaps + BlockSize - 1, 42 + 20 - 1 plus some spare
-  q15_t                m_gaussianState[40U];      // NoTaps + BlockSize - 1, 12 + 20 - 1 plus some spare
-  q15_t                m_boxcarState[30U];        // NoTaps + BlockSize - 1, 6 + 20 - 1 plus some spare
   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
 
   bool                 m_pttInvert;
   q15_t                m_rxLevel;
@@ -95,6 +122,8 @@ private:
   uint16_t             m_rxDCOffset;
   uint16_t             m_txDCOffset;
 
+  bool                 m_useCOSAsLockout;
+
   uint32_t             m_ledCount;
   bool                 m_ledValue;
 
@@ -129,3 +158,4 @@ private:
 };
 
 #endif
+

IODue.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018,2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020,2025 by Jonathan Naylor G4KLX
  *   Copyright (C) 2015 by Jim Mclaughlin KI6ZUM
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *
@@ -278,4 +278,33 @@ void CIO::delayInt(unsigned int dly)
   delay(dly);
 }
 
+uint8_t CIO::getCPU() const
+{
+  return 0U;
+}
+
+// Code taken from https://github.com/emagii/at91sam3s/blob/master/examples/eefc_uniqueid/main.c
+void CIO::getUDID(uint8_t* buffer)
+{
+  uint32_t status;
+
+  EFC1->EEFC_FCR = (0x5A << 24) | EFC_FCMD_STUI;
+  do {
+    status = EFC1->EEFC_FSR;
+  } while ( (status & EEFC_FSR_FRDY) == EEFC_FSR_FRDY );
+
+  for (uint8_t i = 0; i < 16; i+=4) {
+    buffer[i + 0] = *(uint32_t *)(IFLASH1_ADDR + i) >> 24;
+    buffer[i + 1] = *(uint32_t *)(IFLASH1_ADDR + i) >> 16;
+    buffer[i + 2] = *(uint32_t *)(IFLASH1_ADDR + i) >>  8;
+    buffer[i + 3] = *(uint32_t *)(IFLASH1_ADDR + i) >>  0;
+  }
+
+  EFC1->EEFC_FCR = (0x5A << 24) | EFC_FCMD_SPUI;
+  do {
+    status = EFC1->EEFC_FSR;
+  } while ( (status & EEFC_FSR_FRDY) != EEFC_FSR_FRDY );
+}
+
 #endif
+

IOPins.h

@@ -59,12 +59,21 @@
 #elif defined(STM32F4_DVM)
     #include "pins/pins_f4_stm32dvm_v3.h"
 
+#elif defined(STM32F7_DVM)
+    #include "pins/pins_f7_stm32dvm_v5.h"
+
 #elif defined(DRCC_DVM_NQF)
     #include "pins/pins_f4_drcc_nqf.h"
 
+#elif defined(DRCC_DVM_HHP446)
+    #include "pins/pins_f4_drcc_hhp446.h"
+
+#elif defined(STM32F4_EDA_405) || defined(STM32F4_EDA_446)
+    #include "pins/pins_f4_stm32eda.h"
+
 #else
     #error "A valid board type macro need to be defined."
 
 #endif
 
-#endif  //#ifndef _IO_PINS_H
+#endif  //#ifndef _IO_PINS_H

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,2025 by Jonathan Naylor G4KLX
  *   Copyright (C) 2019,2020 by BG5HHP
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -349,10 +349,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);
 
@@ -508,4 +514,21 @@ void CIO::delayInt(unsigned int dly)
   }
 }
 
+uint8_t CIO::getCPU() const
+{
+  return 2U;
+}
+
+void CIO::getUDID(uint8_t* buffer)
+{
+#if defined(STM32F4XX)
+  ::memcpy(buffer, (void *)0x1FFF7A10, 12U);
+#elif defined(STM32F722xx)
+  ::memcpy(buffer, (void *)0x1FF07A10, 12U);
+#elif defined(STM32F767xx)
+  ::memcpy(buffer, (void *)0x1FF0F420, 12U);
 #endif
+}
+
+#endif
+

IOSTM_CMSIS.cpp

@@ -1,507 +0,0 @@
-/*
- *   Copyright (C) 2016 by Jim McLaughlin KI6ZUM
- *   Copyright (C) 2016, 2017 by Andy Uribe CA6JAU
- *   Copyright (C) 2017,2018,2020 by Jonathan Naylor G4KLX
- *   Copyright (C) 2017 by Wojciech Krutnik N0CALL
- *
- *   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"
-#include "Globals.h"
-#include "IO.h"
-
-
-#if defined(STM32F1)
-
-#if defined(STM32F1_POG)
-/*
-Pin definitions for STM32F1 POG Board:
-
-PTT      PB12   output
-COSLED   PB5    output
-LED      PB4    output
-COS      PB13   input/PD
-
-DSTAR    PB7    output
-DMR      PB6    output
-YSF      PB8    output
-P25      PB9    output
-NXDN     PB10   output
-POCSAG   PB11   output
-FM       PB12   output
-
-RX       PB0    analog input (ADC1_8)
-RSSI     PB1    analog input (ADC2_9)
-TX       PA4    analog output (DAC_OUT1)
-
-EXT_CLK  PA15   input (AF: TIM2_CH1_ETR)
-
-USART1_TXD PA9  output (AF)
-USART1_RXD PA10  input (AF)
-
-*/
-
-#define PIN_PTT           12
-#define PORT_PTT          GPIOB
-#define BB_PTT            *((bitband_t)BITBAND_PERIPH(&PORT_PTT->ODR, PIN_PTT))
-#define PIN_COSLED        5
-#define PORT_COSLED       GPIOB
-#define BB_COSLED         *((bitband_t)BITBAND_PERIPH(&PORT_COSLED->ODR, PIN_COSLED))
-#define PIN_LED           4
-#define PORT_LED          GPIOB
-#define BB_LED            *((bitband_t)BITBAND_PERIPH(&PORT_LED->ODR, PIN_LED))
-#define PIN_COS           13
-#define PORT_COS          GPIOB
-#define BB_COS            *((bitband_t)BITBAND_PERIPH(&PORT_COS->IDR, PIN_COS))
-
-#define PIN_DSTAR         7
-#define PORT_DSTAR        GPIOB
-#define BB_DSTAR          *((bitband_t)BITBAND_PERIPH(&PORT_DSTAR->ODR, PIN_DSTAR))
-#define PIN_DMR           6
-#define PORT_DMR          GPIOB
-#define BB_DMR            *((bitband_t)BITBAND_PERIPH(&PORT_DMR->ODR, PIN_DMR))
-#define PIN_YSF           8
-#define PORT_YSF          GPIOB
-#define BB_YSF            *((bitband_t)BITBAND_PERIPH(&PORT_YSF->ODR, PIN_YSF))
-#define PIN_P25           9
-#define PORT_P25          GPIOB
-#define BB_P25            *((bitband_t)BITBAND_PERIPH(&PORT_P25->ODR, PIN_P25))
-#define PIN_NXDN          10
-#define PORT_NXDN         GPIOB
-#define BB_NXDN           *((bitband_t)BITBAND_PERIPH(&PORT_NXDN->ODR, PIN_NXDN))
-#define PIN_POCSAG        11
-#define PORT_POCSAG       GPIOB
-#define BB_POCSAG         *((bitband_t)BITBAND_PERIPH(&PORT_POCSAG->ODR, PIN_POCSAG))
-#define PIN_FM            14
-#define PORT_FM           GPIOB
-#define BB_FM             *((bitband_t)BITBAND_PERIPH(&PORT_FM->ODR, PIN_FM))
-
-#define PIN_RX            0
-#define PIN_RX_ADC_CH     8
-#define PORT_RX           GPIOB
-#define PIN_RSSI          1
-#define PIN_RSSI_ADC_CH   9
-#define PORT_RSSI         GPIOB
-#define PIN_TX            4
-#define PIN_TX_DAC_CH     1
-#define PORT_TX           GPIOA
-
-#define PIN_EXT_CLK       15
-#define SRC_EXT_CLK       15
-#define PORT_EXT_CLK      GPIOA
-
-#define PIN_USART1_TXD    9
-#define PORT_USART1_TXD   GPIOA
-#define PIN_USART1_RXD    10
-#define PORT_USART1_RXD   GPIOA
-
-#else   // defined(STM32F1_POG)
-#error "Either STM32F1_POG, or sth need to be defined"
-#endif  // defined(STM32F1_POG)
-
-const uint16_t DC_OFFSET = 2048U;
-
-// Sampling frequency
-#define SAMP_FREQ   24000
-
-extern "C" {
-  void TIM2_IRQHandler() {
-    if ((TIM2->SR & TIM_SR_UIF) == TIM_SR_UIF) {
-      TIM2->SR = ~TIM_SR_UIF;   // clear UI flag
-      io.interrupt();
-    }
-  }
-}
-
-
-void delay(uint32_t cnt)
-{
-  while(cnt--)
-    asm("nop");
-}
-
-// source: http://www.freddiechopin.info/
-void GPIOConfigPin(GPIO_TypeDef *port_ptr, uint32_t pin, uint32_t mode_cnf_value)
-{
-	volatile uint32_t *cr_ptr;
-	uint32_t cr_value;
-
-	cr_ptr = &port_ptr->CRL;  // configuration of pins [0,7] is in CRL
-
-	if (pin >= 8)			        // is pin in [8; 15]?
-	{									        // configuration of pins [8,15] is in CRH
-		cr_ptr++;               // advance to next struct element CRL -> CRH
-		pin -= 8;               // crop the pin number
-	}
-
-	cr_value = *cr_ptr;			  // localize the CRL / CRH value
-
-	cr_value &= ~(0xF << (pin * 4));	// clear the MODE and CNF fields (now that pin is an analog input)
-	cr_value |= (mode_cnf_value << (pin * 4));	        // save new MODE and CNF value for desired pin
-
-	*cr_ptr = cr_value;				// save localized value to CRL / CRL
-}
-
-#if defined(STM32F1_POG)
-void FancyLEDEffect()
-{
-  int ledCount = 10;
-
-  bitband_t foo[] = {&BB_LED, &BB_COSLED, &BB_PTT, &BB_DMR, &BB_DSTAR, &BB_YSF, &BB_P25,
-#if defined(USE_ALTERNATE_NXDN_LEDS)
-	NULL,
-#else
-	&BB_NXDN,
-#endif
-#if defined(USE_ALTERNATE_POCSAG_LEDS)
-	NULL,
-#else
-  	&BB_POCSAG,
-#endif
-#if defined(USE_ALTERNATE_FM_LEDS)
-	NULL};
-#else
-	&BB_FM};
-#endif
-
-  for(int i=0; i<ledCount; i++){
-    if(foo[i] != NULL)
-      *foo[i] = 0x01;
-  }
-  GPIOConfigPin(PORT_USART1_TXD, PIN_USART1_TXD, GPIO_CRL_MODE0_1);
-  *((bitband_t)BITBAND_PERIPH(&PORT_USART1_TXD->ODR, PIN_USART1_TXD)) = 0x00;
-  delay(SystemCoreClock/1000*100);
-  for(int i=0; i<ledCount; i++){
-    if(foo[i] != NULL)
-      *foo[i] = 0x00;
-  }
-  *((bitband_t)BITBAND_PERIPH(&PORT_USART1_TXD->ODR, PIN_USART1_TXD)) = 0x01;
-  delay(SystemCoreClock/1000*20);
-  *((bitband_t)BITBAND_PERIPH(&PORT_USART1_TXD->ODR, PIN_USART1_TXD)) = 0x00;
-  delay(SystemCoreClock/1000*10);
-  *((bitband_t)BITBAND_PERIPH(&PORT_USART1_TXD->ODR, PIN_USART1_TXD)) = 0x01;
-  
-  *foo[0] = 0x01;
-  for(int i=1; i<ledCount; i++){
-    delay(SystemCoreClock/1000*10);
-    if (foo[i-1] != NULL)
-      *foo[i-1] = 0x00;
-    if (foo[i] != NULL)
-      *foo[i] = 0x01;
-  }
-  for(int i=ledCount - 2; i>=0; i--) {
-    delay(SystemCoreClock/1000*10);
-    if (foo[i+1] != NULL)
-      *foo[i+1] = 0x00;
-    if (foo[i] != NULL)
-      *foo[i] = 0x01;
-  }
-  delay(SystemCoreClock/1000*10);
-  *foo[0] = 0x00;
-  *((bitband_t)BITBAND_PERIPH(&PORT_USART1_TXD->ODR, PIN_USART1_TXD)) = 0x00;
-  delay(SystemCoreClock/1000*10);
-  *((bitband_t)BITBAND_PERIPH(&PORT_USART1_TXD->ODR, PIN_USART1_TXD)) = 0x01;
-  GPIOConfigPin(PORT_USART1_TXD, PIN_USART1_TXD, GPIO_CRL_MODE0_1|GPIO_CRL_CNF0_1);
-  delay(SystemCoreClock/1000*50);
-}
-#endif
-
-static inline void GPIOInit()
-{
-  RCC->APB2ENR |= RCC_APB2ENR_IOPAEN | RCC_APB2ENR_IOPBEN
-                  | RCC_APB2ENR_IOPCEN | RCC_APB2ENR_IOPDEN
-                  | RCC_APB2ENR_AFIOEN;	// enable all GPIOs
-                 
-	// set all ports to input with pull-down
-	GPIOA->CRL = 0x88888888;
-	GPIOA->CRH = 0x88888888;
-	GPIOA->ODR = 0;
-	GPIOB->CRL = 0x88888888;
-	GPIOB->CRH = 0x88888888;
-	GPIOB->ODR = 0;
-	GPIOC->CRL = 0x88888888;
-	GPIOC->CRH = 0x88888888;
-	GPIOC->ODR = 0;
-	GPIOD->CRL = 0x88888888;
-	GPIOD->CRH = 0x88888888;
-	GPIOD->ODR = 0;
-  
-  // configure ports
-  GPIOConfigPin(PORT_PTT,    PIN_PTT,    GPIO_CRL_MODE0_1);
-  GPIOConfigPin(PORT_COSLED, PIN_COSLED, GPIO_CRL_MODE0_1);
-  GPIOConfigPin(PORT_LED,    PIN_LED,    GPIO_CRL_MODE0_1);
-  GPIOConfigPin(PORT_COS,    PIN_COS,    GPIO_CRL_CNF0_1);
-  
-  GPIOConfigPin(PORT_DSTAR,  PIN_DSTAR,  GPIO_CRL_MODE0_1);
-  GPIOConfigPin(PORT_DMR,    PIN_DMR,    GPIO_CRL_MODE0_1);
-  GPIOConfigPin(PORT_YSF,    PIN_YSF,    GPIO_CRL_MODE0_1);
-  GPIOConfigPin(PORT_P25,    PIN_P25,    GPIO_CRL_MODE0_1);
-#if !defined(USE_ALTERNATE_NXDN_LEDS)
-  GPIOConfigPin(PORT_NXDN,   PIN_NXDN,   GPIO_CRL_MODE0_1);
-#endif
-#if !defined(USE_ALTERNATE_POCSAG_LEDS)
-  GPIOConfigPin(PORT_POCSAG, PIN_POCSAG, GPIO_CRL_MODE0_1);
-#endif
-#if !defined(USE_ALTERNATE_FM_LEDS)
-  GPIOConfigPin(PORT_FM,     PIN_FM,     GPIO_CRL_MODE0_1);
-#endif
-
-  GPIOConfigPin(PORT_RX, PIN_RX, 0);
-#if defined(SEND_RSSI_DATA)
-  GPIOConfigPin(PORT_RSSI, PIN_RSSI, 0);
-#endif
-  GPIOConfigPin(PORT_TX, PIN_TX, 0);
-
-#if defined(EXTERNAL_OSC)
-#if defined(STM32F1_POG)
-  GPIOConfigPin(PORT_EXT_CLK, PIN_EXT_CLK, GPIO_CRL_CNF0_0);
-  AFIO->MAPR = (AFIO->MAPR & ~AFIO_MAPR_TIM2_REMAP) | AFIO_MAPR_TIM2_REMAP_0;
-#endif
-#endif
-
-  GPIOConfigPin(PORT_USART1_TXD, PIN_USART1_TXD, GPIO_CRL_MODE0_1|GPIO_CRL_CNF0_1);
-  GPIOConfigPin(PORT_USART1_RXD, PIN_USART1_RXD, GPIO_CRL_CNF0_0);
-  
-  AFIO->MAPR = (AFIO->MAPR & ~AFIO_MAPR_SWJ_CFG) | AFIO_MAPR_SWJ_CFG_1;
-}
-
-
-static inline void ADCInit()
-{
-  RCC->CFGR = (RCC->CFGR & ~RCC_CFGR_ADCPRE_Msk)
-              | RCC_CFGR_ADCPRE_DIV6; // ADC clock divided by 6 (72MHz/6 = 12MHz)
-  RCC->APB2ENR |= RCC_APB2ENR_ADC1EN;
-#if defined(SEND_RSSI_DATA)
-  RCC->APB2ENR |= RCC_APB2ENR_ADC2EN;
-#endif
-
-  // Init ADCs in dual mode (RSSI)
-#if defined(SEND_RSSI_DATA)
-  ADC1->CR1 = ADC_CR1_DUALMOD_1|ADC_CR1_DUALMOD_2;  // Regular simultaneous mode
-#endif
-
-  // Set sampling time to 7.5 cycles
-  if (PIN_RX_ADC_CH < 10) {
-    ADC1->SMPR2 = ADC_SMPR2_SMP0_0 << (3*PIN_RX_ADC_CH); 
-  } else {
-    ADC1->SMPR1 = ADC_SMPR1_SMP10_0 << (3*PIN_RX_ADC_CH);
-  }
-#if defined(SEND_RSSI_DATA)
-  if (PIN_RSSI_ADC_CH < 10) {
-    ADC2->SMPR2 = ADC_SMPR2_SMP0_0 << (3*PIN_RSSI_ADC_CH); 
-  } else {
-    ADC2->SMPR1 = ADC_SMPR1_SMP10_0 << (3*PIN_RSSI_ADC_CH);
-  }
-#endif
-
-  // Set conversion channel (single conversion)
-  ADC1->SQR3 = PIN_RX_ADC_CH;
-#if defined(SEND_RSSI_DATA)
-  ADC2->SQR3 = PIN_RSSI_ADC_CH;
-#endif
-
-  // Enable ADC
-  ADC1->CR2 |= ADC_CR2_ADON;
-
-#if defined(SEND_RSSI_DATA)
-  // Enable ADC2
-  ADC2->CR2 |= ADC_CR2_ADON;
-#endif
-
-  // Start calibration
-  delay(6*2);
-  ADC1->CR2 |= ADC_CR2_CAL;
-  while((ADC1->CR2 & ADC_CR2_CAL) == ADC_CR2_CAL)
-    ;
-#if defined(SEND_RSSI_DATA)
-  ADC2->CR2 |= ADC_CR2_CAL;
-  while((ADC2->CR2 & ADC_CR2_CAL) == ADC_CR2_CAL)
-    ;
-#endif
-  
-  // Trigger first conversion
-  ADC1->CR2 |= ADC_CR2_ADON;
-#if defined(SEND_RSSI_DATA)
-  ADC2->CR2 |= ADC_CR2_ADON;
-#endif
-}
-
-
-static inline void DACInit()
-{
-  RCC->APB1ENR |= RCC_APB1ENR_DACEN;
-
-  DAC->CR = DAC_CR_EN1;
-}
-
-
-static inline void TimerInit()
-{
-  RCC->APB1ENR |= RCC_APB1ENR_TIM2EN;
-
-#if defined(EXTERNAL_OSC)
-  // Enable external clock, prescaler /4
-  TIM2->SMCR = TIM_SMCR_ECE | TIM_SMCR_ETPS_1;
-#endif
-
-  // TIM2 output frequency
-  TIM2->PSC = 0;
-#if defined(EXTERNAL_OSC)
-  // TimerCount = ExternalOsc
-  //              /4 (external clock prescaler)
-  //              /SAMP_FREQ
-  TIM2->ARR = (uint16_t) ((EXTERNAL_OSC/(4*SAMP_FREQ)) - 1);
-#else
-  TIM2->ARR = (uint16_t) ((SystemCoreClock/(SAMP_FREQ)) - 1);
-#endif
-
-  // Enable TIse 1%-tolerance comM2 interrupt
-  TIM2->DIER = TIM_DIER_UIE;
-  NVIC_EnableIRQ(TIM2_IRQn);
-  
-  // Enable TIM2
-  TIM2->CR1 |= TIM_CR1_CEN;
-}
-
-
-void CIO::initInt()
-{
-  GPIOInit();
-  ADCInit();
-  DACInit();
-#if defined(STM32F1_POG)
-  FancyLEDEffect();
-#endif
-}
-
-void CIO::startInt()
-{
-  TimerInit();
-   
-  BB_COSLED = 0;
-  BB_LED = 1;
-}
-
-void CIO::interrupt()
-{
-  TSample sample = {DC_OFFSET, MARK_NONE};
-#if defined(SEND_RSSI_DATA)
-  uint16_t rawRSSI = 0U;
-#endif
-  bitband_t eoc = (bitband_t)BITBAND_PERIPH(&ADC1->SR, ADC_SR_EOS_Pos);
-  bitband_t adon = (bitband_t)BITBAND_PERIPH(&ADC1->CR2, ADC_CR2_ADON_Pos);
-#if defined(SEND_RSSI_DATA)
-  bitband_t rssi_adon = (bitband_t)BITBAND_PERIPH(&ADC2->CR2, ADC_CR2_ADON_Pos);
-#endif
-
-  if (*eoc) {
-    // trigger next conversion
-    *adon = 1;
-#if defined(SEND_RSSI_DATA)
-    *rssi_adon = 1;
-#endif
-    
-    m_txBuffer.get(sample);
-    DAC->DHR12R1 = sample.sample;  // Send the value to the DAC
-
-    // Read value from ADC1 and ADC2
-    sample.sample  = ADC1->DR;   // read conversion result; EOC is cleared by this read
-    m_rxBuffer.put(sample);
-#if defined(SEND_RSSI_DATA)
-    rawRSSI = ADC2->DR;
-    m_rssiBuffer.put(rawRSSI);
-#endif
-
-    m_watchdog++;
-  }
-}
-
-bool CIO::getCOSInt()
-{
-  return BB_COS;
-}
-
-void CIO::setLEDInt(bool on)
-{
-  BB_LED = !!on;
-}
-
-void CIO::setPTTInt(bool on)
-{
-  BB_PTT = !!on;
-}
-
-void CIO::setCOSInt(bool on)
-{
-  BB_COSLED = !!on;
-}
-
-void CIO::setDStarInt(bool on)
-{
-  BB_DSTAR = !!on;
-}
-
-void CIO::setDMRInt(bool on)
-{
-  BB_DMR = !!on;
-}
-
-void CIO::setYSFInt(bool on)
-{
-  BB_YSF = !!on;
-}
-
-void CIO::setP25Int(bool on)
-{
-  BB_P25 = !!on;
-}
-
-void CIO::setNXDNInt(bool on)
-{
-#if defined(USE_ALTERNATE_NXDN_LEDS)
-  BB_YSF = !!on;
-  BB_P25 = !!on;
-#else
-  BB_NXDN = !!on;
-#endif
-}
-
-void CIO::setPOCSAGInt(bool on)
-{
-#if defined(USE_ALTERNATE_POCSAG_LEDS)
-  BB_DSTAR = !!on;
-  BB_DMR   = !!on;
-#else
-  BB_POCSAG = !!on;
-#endif
-}
-
-void CIO::setFMInt(bool on)
-{
-#if defined(USE_ALTERNATE_FM_LEDS)
-  BB_DSTAR = !!on;
-  BB_YSF   = !!on;
-#else
-  BB_FM = !!on;
-#endif
-}
-
-void CIO::delayInt(unsigned int dly)
-{
-  delay(dly);
-}
-
-#endif

IOTeensy.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2016,2017,2018,2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2016,2017,2018,2020,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
@@ -262,4 +262,15 @@ void CIO::delayInt(unsigned int dly)
   delay(dly);
 }
 
+uint8_t CIO::getCPU() const
+{
+  return 1U;
+}
+
+void CIO::getUDID(uint8_t* buffer)
+{
+  ::memcpy(buffer, (void *)0x4058, 16U);
+}
+
 #endif
+

MMDVM.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018,2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020,2021,2025 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Mathis Schmieder DB9MAT
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *
@@ -18,7 +18,7 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#if defined(STM32F4XX) || defined(STM32F7XX) || defined(STM32F105xC)
+#if defined(STM32F4XX) || defined(STM32F7XX)
 
 #include "Config.h"
 #include "Globals.h"
@@ -39,37 +39,55 @@ bool m_duplex = true;
 bool m_tx  = false;
 bool m_dcd = false;
 
-CDStarRX   dstarRX;
-CDStarTX   dstarTX;
-
-CDMRIdleRX dmrIdleRX;
-CDMRRX     dmrRX;
-CDMRTX     dmrTX;
-
-CDMRDMORX  dmrDMORX;
-CDMRDMOTX  dmrDMOTX;
-
-CYSFRX     ysfRX;
-CYSFTX     ysfTX;
-
-CP25RX     p25RX;
-CP25TX     p25TX;
-
-CNXDNRX    nxdnRX;
-CNXDNTX    nxdnTX;
-
-CPOCSAGTX  pocsagTX;
-
-CFM        fm;
+#if defined(MODE_DSTAR)
+CDStarRX dstarRX;
+CDStarTX dstarTX;
 
 CCalDStarRX calDStarRX;
 CCalDStarTX calDStarTX;
-CCalDMR     calDMR;
-CCalP25     calP25;
-CCalNXDN    calNXDN;
-CCalFM      calFM;
-CCalPOCSAG  calPOCSAG;
-CCalRSSI    calRSSI;
+#endif
+
+#if defined(MODE_DMR)
+CDMRIdleRX dmrIdleRX;
+CDMRRX dmrRX;
+CDMRTX dmrTX;
+
+CDMRDMORX dmrDMORX;
+CDMRDMOTX dmrDMOTX;
+
+CCalDMR calDMR;
+#endif
+
+#if defined(MODE_YSF)
+CYSFRX ysfRX;
+CYSFTX ysfTX;
+#endif
+
+#if defined(MODE_P25)
+CP25RX p25RX;
+CP25TX p25TX;
+
+CCalP25 calP25;
+#endif
+
+#if defined(MODE_NXDN)
+CNXDNRX nxdnRX;
+CNXDNTX nxdnTX;
+
+CCalNXDN calNXDN;
+#endif
+
+#if defined(MODE_POCSAG)
+CPOCSAGTX  pocsagTX;
+CCalPOCSAG calPOCSAG;
+#endif
+
+#if defined(MODE_FM)
+CFM    fm;
+CCalFM calFM;
+#endif
+
+CCalRSSI calRSSI;
 
 CCWIdTX cwIdTX;
 
@@ -88,48 +106,74 @@ void loop()
   io.process();
 
   // The following is for transmitting
+#if defined(MODE_DSTAR)
   if (m_dstarEnable && m_modemState == STATE_DSTAR)
     dstarTX.process();
+#endif
 
+#if defined(MODE_DMR)
   if (m_dmrEnable && m_modemState == STATE_DMR) {
     if (m_duplex)
       dmrTX.process();
     else
       dmrDMOTX.process();
   }
+#endif
 
+#if defined(MODE_YSF)
   if (m_ysfEnable && m_modemState == STATE_YSF)
     ysfTX.process();
+#endif
 
+#if defined(MODE_P25)
   if (m_p25Enable && m_modemState == STATE_P25)
     p25TX.process();
+#endif
 
+#if defined(MODE_NXDN)
   if (m_nxdnEnable && m_modemState == STATE_NXDN)
     nxdnTX.process();
+#endif
 
+#if defined(MODE_POCSAG)
   if (m_pocsagEnable && (m_modemState == STATE_POCSAG || pocsagTX.busy()))
     pocsagTX.process();
+#endif
 
+#if defined(MODE_FM)
   if (m_fmEnable && m_modemState == STATE_FM)
     fm.process();
+#endif
 
+#if defined(MODE_DSTAR)
   if (m_modemState == STATE_DSTARCAL)
     calDStarTX.process();
+#endif
 
+#if defined(MODE_DMR)
   if (m_modemState == STATE_DMRCAL || m_modemState == STATE_LFCAL || m_modemState == STATE_DMRCAL1K || m_modemState == STATE_DMRDMO1K)
     calDMR.process();
+#endif
 
+#if defined(MODE_FM)
+  if (m_modemState == STATE_FMCAL10K || m_modemState == STATE_FMCAL12K || m_modemState == STATE_FMCAL15K || m_modemState == STATE_FMCAL20K || m_modemState == STATE_FMCAL25K || m_modemState == STATE_FMCAL30K)
+    calFM.process();
+#endif
+
+#if defined(MODE_P25)
   if (m_modemState == STATE_P25CAL1K)
     calP25.process();
+#endif
 
+#if defined(MODE_NXDN)
   if (m_modemState == STATE_NXDNCAL1K)
     calNXDN.process();
+#endif
 
+#if defined(MODE_POCSAG)
   if (m_modemState == STATE_POCSAGCAL)
     calPOCSAG.process();
-
-  if (m_modemState == STATE_FMCAL10K || m_modemState == STATE_FMCAL12K || m_modemState == STATE_FMCAL15K || m_modemState == STATE_FMCAL20K || m_modemState == STATE_FMCAL25K ||m_modemState == STATE_FMCAL30K)
-    calFM.process();
+#endif
 
   if (m_modemState == STATE_IDLE)
     cwIdTX.process();
@@ -144,3 +188,4 @@ int main()
 }
 
 #endif
+

MMDVM.ino

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018,2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020,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
@@ -36,37 +36,55 @@ bool m_duplex = true;
 bool m_tx  = false;
 bool m_dcd = false;
 
-CDStarRX   dstarRX;
-CDStarTX   dstarTX;
-
-CDMRIdleRX dmrIdleRX;
-CDMRRX     dmrRX;
-CDMRTX     dmrTX;
-
-CDMRDMORX  dmrDMORX;
-CDMRDMOTX  dmrDMOTX;
-
-CYSFRX     ysfRX;
-CYSFTX     ysfTX;
-
-CP25RX     p25RX;
-CP25TX     p25TX;
-
-CNXDNRX    nxdnRX;
-CNXDNTX    nxdnTX;
-
-CPOCSAGTX  pocsagTX;
-
-CFM        fm;
+#if defined(MODE_DSTAR)
+CDStarRX dstarRX;
+CDStarTX dstarTX;
 
 CCalDStarRX calDStarRX;
 CCalDStarTX calDStarTX;
-CCalDMR     calDMR;
-CCalFM      calFM;
-CCalP25     calP25;
-CCalNXDN    calNXDN;
-CCalPOCSAG  calPOCSAG;
-CCalRSSI    calRSSI;
+#endif
+
+#if defined(MODE_DMR)
+CDMRIdleRX dmrIdleRX;
+CDMRRX dmrRX;
+CDMRTX dmrTX;
+
+CDMRDMORX dmrDMORX;
+CDMRDMOTX dmrDMOTX;
+
+CCalDMR calDMR;
+#endif
+
+#if defined(MODE_YSF)
+CYSFRX ysfRX;
+CYSFTX ysfTX;
+#endif
+
+#if defined(MODE_P25)
+CP25RX p25RX;
+CP25TX p25TX;
+
+CCalP25 calP25;
+#endif
+
+#if defined(MODE_NXDN)
+CNXDNRX nxdnRX;
+CNXDNTX nxdnTX;
+
+CCalNXDN calNXDN;
+#endif
+
+#if defined(MODE_POCSAG)
+CPOCSAGTX  pocsagTX;
+CCalPOCSAG calPOCSAG;
+#endif
+
+#if defined(MODE_FM)
+CFM    fm;
+CCalFM calFM;
+#endif
+
+CCalRSSI calRSSI;
 
 CCWIdTX cwIdTX;
 
@@ -85,49 +103,76 @@ void loop()
   io.process();
 
   // The following is for transmitting
+#if defined(MODE_DSTAR)
   if (m_dstarEnable && m_modemState == STATE_DSTAR)
     dstarTX.process();
+#endif
 
+#if defined(MODE_DMR)
   if (m_dmrEnable && m_modemState == STATE_DMR) {
     if (m_duplex)
       dmrTX.process();
     else
       dmrDMOTX.process();
   }
+#endif
 
+#if defined(MODE_YSF)
   if (m_ysfEnable && m_modemState == STATE_YSF)
     ysfTX.process();
+#endif
 
+#if defined(MODE_P25)
   if (m_p25Enable && m_modemState == STATE_P25)
     p25TX.process();
+#endif
 
+#if defined(MODE_NXDN)
   if (m_nxdnEnable && m_modemState == STATE_NXDN)
     nxdnTX.process();
+#endif
 
+#if defined(MODE_POCSAG)
   if (m_pocsagEnable && (m_modemState == STATE_POCSAG || pocsagTX.busy()))
     pocsagTX.process();
+#endif
 
+#if defined(MODE_FM)
   if (m_fmEnable && m_modemState == STATE_FM)
     fm.process();
+#endif
 
+#if defined(MODE_DSTAR)
   if (m_modemState == STATE_DSTARCAL)
     calDStarTX.process();
+#endif
 
+#if defined(MODE_DMR)
   if (m_modemState == STATE_DMRCAL || m_modemState == STATE_LFCAL || m_modemState == STATE_DMRCAL1K || m_modemState == STATE_DMRDMO1K)
     calDMR.process();
+#endif
 
+#if defined(MODE_FM)
   if (m_modemState == STATE_FMCAL10K || m_modemState == STATE_FMCAL12K || m_modemState == STATE_FMCAL15K || m_modemState == STATE_FMCAL20K || m_modemState == STATE_FMCAL25K || m_modemState == STATE_FMCAL30K)
     calFM.process();
+#endif
 
+#if defined(MODE_P25)
   if (m_modemState == STATE_P25CAL1K)
     calP25.process();
+#endif
 
+#if defined(MODE_NXDN)
   if (m_modemState == STATE_NXDNCAL1K)
     calNXDN.process();
+#endif
 
+#if defined(MODE_POCSAG)
   if (m_modemState == STATE_POCSAGCAL)
     calPOCSAG.process();
+#endif
 
   if (m_modemState == STATE_IDLE)
     cwIdTX.process();
 }
+

Makefile

@@ -133,19 +133,25 @@ DEFS_PI_F722=-DUSE_HAL_DRIVER -DSTM32F722xx -DSTM32F7XX -DSTM32F722_PI -DHSE_VAL
 DEFS_F7M=-DUSE_HAL_DRIVER -DSTM32F722xx -DSTM32F7XX -DSTM32F722_F7M -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
 # MMDVM_RPT_Hat F0DEI, DB9MAT, DF2ET board:
 DEFS_RPT_HAT=-DUSE_HAL_DRIVER -DSTM32F722xx -DSTM32F7XX -DSTM32F722_RPT_HAT -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
-# STM32F4 DVM board:
+# RB STM32F4_DVM board:
 DEFS_DVM=-DUSE_STDPERIPH_DRIVER -DSTM32F4XX -DSTM32F446xx -DSTM32F4_DVM -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
+# RB STM32F7 DVM board:
+DEFS_DVM722=-DUSE_HAL_DRIVER -DSTM32F722xx -DSTM32F7XX -DSTM32F7_DVM -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
 # MMDVM_RPT_Hat BG4TGO, BG5HHP board:
 DEFS_RPT_HAT_TGO=-DUSE_STDPERIPH_DRIVER -DSTM32F4XX -DSTM32F40_41xxx -DSTM32F4_RPT_HAT_TGO -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
 # DRCC_DVM BG7NQF board:
 DEFS_DRCC_DVM=-DUSE_STDPERIPH_DRIVER -DSTM32F4XX -DSTM32F446xx -DDRCC_DVM -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
+# WA0EDA F405 MTR2K, MASTR3 board:
+DEFS_EDA_405=-DUSE_STDPERIPH_DRIVER -DSTM32F4XX -DSTM32F40_41xxx -DSTM32F4_EDA_405 -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
+# WA0EDA F446 MTR2K, MASTR3 board:
+DEFS_EDA_446=-DUSE_STDPERIPH_DRIVER -DSTM32F4XX -DSTM32F446xx -DSTM32F4_EDA_446 -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
 
 
 # Build compiler flags
 CFLAGS_F4=-c $(MCFLAGS_F4) $(INCLUDES_F4)
-CXXFLAGS_F4=-c $(MCFLAGS_F4) $(INCLUDES_F4)
+CXXFLAGS_F4=-c $(MCFLAGS_F4) $(INCLUDES_F4) -std=c++11
 CFLAGS_F7=-c $(MCFLAGS_F7) $(INCLUDES_F7)
-CXXFLAGS_F7=-c $(MCFLAGS_F7) $(INCLUDES_F7)
+CXXFLAGS_F7=-c $(MCFLAGS_F7) $(INCLUDES_F7) -std=c++11
 
 # Linker flags
 LDFLAGS_F4 =-T stm32f4xx_link.ld $(MCFLAGS_F4) --specs=nosys.specs $(INCLUDES_LIBS_F4)
@@ -155,7 +161,7 @@ LDFLAGS_F722 =-T stm32f722_link.ld $(MCFLAGS_F7) --specs=nosys.specs $(INCLUDES_
 # Common flags
 CFLAGS=-Os -ffunction-sections -fdata-sections -fno-builtin -Wno-implicit -DCUSTOM_NEW -DNO_EXCEPTIONS
 CXXFLAGS=-Os -fno-exceptions -ffunction-sections -fdata-sections -fno-builtin -fno-rtti -DCUSTOM_NEW -DNO_EXCEPTIONS
-LDFLAGS=-Os --specs=nano.specs
+LDFLAGS=-Os --specs=nano.specs -Wl,-Map=bin/mmdvm.map
 
 # Build Rules
 .PHONY: all release dis pi pi-f722 f4m nucleo f767 dvm drcc_nqf clean
@@ -218,17 +224,41 @@ f767: LDFLAGS+=$(LDFLAGS_F767)
 f767: release_f7
 
 dvm: GitVersion.h
-dvm: CFLAGS+=$(CFLAGS_F4) $(DEFS_DVM)
-dvm: CXXFLAGS+=$(CXXFLAGS_F4) $(DEFS_DVM)
+dvm: CFLAGS+=$(CFLAGS_F4) $(DEFS_DVM) -DDRCC_DVM_446
+dvm: CXXFLAGS+=$(CXXFLAGS_F4) $(DEFS_DVM) -DDRCC_DVM_446
 dvm: LDFLAGS+=$(LDFLAGS_F4)
 dvm: release_f4
 
+dvm722: GitVersion.h
+dvm722: CFLAGS+=$(CFLAGS_F7) $(DEFS_DVM722) -DDRCC_DVM_722
+dvm722: CXXFLAGS+=$(CXXFLAGS_F7) $(DEFS_DVM722) -DDRCC_DVM_722
+dvm722: LDFLAGS+=$(LDFLAGS_F722)
+dvm722: release_f7
+
 drcc_nqf: GitVersion.h
 drcc_nqf: CFLAGS+=$(CFLAGS_F4) $(DEFS_DRCC_DVM) -DDRCC_DVM_NQF
 drcc_nqf: CXXFLAGS+=$(CXXFLAGS_F4) $(DEFS_DRCC_DVM) -DDRCC_DVM_NQF
 drcc_nqf: LDFLAGS+=$(LDFLAGS_F4)
 drcc_nqf: release_f4
 
+hhp446: GitVersion.h
+hhp446: CFLAGS+=$(CFLAGS_F4) $(DEFS_DRCC_DVM) -DDRCC_DVM_HHP446
+hhp446: CXXFLAGS+=$(CXXFLAGS_F4) $(DEFS_DRCC_DVM) -DDRCC_DVM_HHP446
+hhp446: LDFLAGS+=$(LDFLAGS_F4)
+hhp446: release_f4
+
+eda405: GitVersion.h
+eda405: CFLAGS+=$(CFLAGS_F4) $(DEFS_EDA_405)
+eda405: CXXFLAGS+=$(CXXFLAGS_F4) $(DEFS_EDA_405)
+eda405: LDFLAGS+=$(LDFLAGS_F4)
+eda405: release_f4
+
+eda446: GitVersion.h
+eda446: CFLAGS+=$(CFLAGS_F4) $(DEFS_EDA_446)
+eda446: CXXFLAGS+=$(CXXFLAGS_F4) $(DEFS_EDA_446)
+eda446: LDFLAGS+=$(LDFLAGS_F4)
+eda446: release_f4
+
 release_f4: $(BINDIR)
 release_f4: $(OBJDIR_F4)
 release_f4: $(BINDIR)/$(BINHEX_F4)
@@ -338,27 +368,27 @@ endif
 deploy-pi:
 ifneq ($(wildcard /usr/local/bin/stm32flash),)
 	-/usr/local/bin/stm32flash -i 20,-21,21:-20,21 /dev/ttyAMA0
-	-/usr/local/bin/stm32ld /dev/ttyAMA0 57600 bin/$(BINBIN_F4)
-	/usr/local/bin/stm32flash -v -w bin/$(BINBIN_F4) -g 0x0 -R -c /dev/ttyAMA0
+	/usr/local/bin/stm32flash -v -w bin/$(BINBIN_F4) -g 0x0 -R /dev/ttyAMA0
 endif
 
 ifneq ($(wildcard /usr/bin/stm32flash),)
 	-/usr/bin/stm32flash -i 20,-21,21:-20,21 /dev/ttyAMA0
-	-/usr/bin/stm32ld /dev/ttyAMA0 57600 bin/$(BINBIN_F4)
-	/usr/bin/stm32flash -v -w bin/$(BINBIN_F4) -g 0x0 -R -c /dev/ttyAMA0
+	/usr/bin/stm32flash -v -w bin/$(BINBIN_F4) -g 0x0 -R /dev/ttyAMA0
 endif
 
 deploy-f4m: deploy-pi
 deploy-dvm: deploy-pi
+deploy-eda405: deploy-pi
+deploy-eda446: deploy-pi
 
 deploy-pi-f7:
 ifneq ($(wildcard /usr/local/bin/stm32flash),)
 	-/usr/local/bin/stm32flash -i 20,-21,21:-20,21 /dev/ttyAMA0
-	/usr/local/bin/stm32flash -v -w bin/$(BINBIN_F7) -g 0x0 -R -c /dev/ttyAMA0
+	/usr/local/bin/stm32flash -v -w bin/$(BINBIN_F7) -g 0x0 -R /dev/ttyAMA0
 
 else ifneq ($(wildcard /usr/bin/stm32flash),)
 	-/usr/bin/stm32flash -i 20,-21,21:-20,21 /dev/ttyAMA0
-	/usr/bin/stm32flash -v -w bin/$(BINBIN_F7) -g 0x0 -R -c /dev/ttyAMA0
+	/usr/bin/stm32flash -v -w bin/$(BINBIN_F7) -g 0x0 -R /dev/ttyAMA0
 endif
 
 deploy-f7m:   deploy-pi-f7

Makefile.CMSIS

@@ -1,165 +0,0 @@
-# The name for the project
-TARGET:=mmdvm
-
-# The CPU architecture (will be used for -mcpu)
-MCPU:=cortex-m3
-MCU:=STM32F105xC
-
-# The source files of the project
-CSRC:=
-CXXSRC:=$(wildcard *.cpp)
-
-# Include directory for the system include files and system source file
-SYSDIR:=system_stm32f1xx
-SYSSRC:=$(SYSDIR)/system_stm32f1xx.c
-
-# Other include directories
-INCDIR:=
-
-# Definitions
-CDEFS:=
-CXXDEFS:=
-
-# The name of the startup file which matches to the architecture (MCPU)
-STARTUP:=$(SYSDIR)/startup_stm32f105xc.S
-STARTUP_DEFS=
-
-# Include directory for CMSIS
-CMSISDIR:=STM32F10X_Lib/CMSIS
-
-# Libraries
-LIBDIR:=
-LIBS:=-larm_cortexM3l_math
-
-# Name of the linker script
-LDSCRIPT:=$(SYSDIR)/gcc.ld
-
-# Target objects and binaries directory
-OBJDIR:=obj
-BINDIR:=bin
-
-# Port definition for programming via bootloader (using stm32flash)
-BL_PORT:=ttyUSB0
-
-
-
-# Internal Variables
-ELF:=$(BINDIR)/$(TARGET).elf
-HEX:=$(BINDIR)/$(TARGET).hex
-DIS:=$(BINDIR)/$(TARGET).dis
-MAP:=$(BINDIR)/$(TARGET).map
-OBJ:=$(CSRC:%.c=$(OBJDIR)/%.o) $(CXXSRC:%.cpp=$(OBJDIR)/%.o)
-OBJ+=$(SYSSRC:$(SYSDIR)/%.c=$(OBJDIR)/%.o) $(STARTUP:$(SYSDIR)/%.S=$(OBJDIR)/%.o)
-
-# Replace standard build tools by arm tools
-CC:=arm-none-eabi-gcc
-CXX:=arm-none-eabi-g++
-AS:=arm-none-eabi-gcc
-LD:=arm-none-eabi-g++
-OBJCOPY:=arm-none-eabi-objcopy
-OBJDUMP:=arm-none-eabi-objdump
-SIZE:=arm-none-eabi-size
-
-# Common flags
-COMMON_FLAGS =-mthumb -mlittle-endian -mcpu=$(MCPU)
-COMMON_FLAGS+= -Wall
-COMMON_FLAGS+= -I. -I$(CMSISDIR)/Include -I$(CMSISDIR)/Device/ST/STM32F1xx/Include -I$(SYSDIR)
-COMMON_FLAGS+=  $(addprefix -I,$(INCDIR))
-COMMON_FLAGS+= -D$(MCU) -DMADEBYMAKEFILE -DSTM32F1
-COMMON_FLAGS+= -Os -flto -ffunction-sections -fdata-sections
-COMMON_FLAGS+= -g
-# Assembler flags
-ASFLAGS:=$(COMMON_FLAGS)
-# C flags
-CFLAGS:=$(COMMON_FLAGS) $(addprefix -D,$(CDEFS))
-CFLAGS+= -std=gnu11 -nostdlib
-# CXX flags
-CXXFLAGS:=$(COMMON_FLAGS) $(addprefix -D,$(CXXDEFS))
-CXXFLAGS+= -nostdlib -fno-exceptions -fno-rtti
-# LD flags
-LDFLAGS:=$(COMMON_FLAGS) -Wl,--gc-sections -Wl,-Map=$(MAP) -Wl,--no-wchar-size-warning
-LDFLAGS+= --specs=nosys.specs --specs=nano.specs
-LDFLAGS+= -L$(CMSISDIR)/Lib/GCC/ $(addprefix -L,$(LIBDIR))
-LDLIBS:=-T$(LDSCRIPT) $(LIBS)
-
-# Dependecies
-DEPENDS:=$(CSRC:%.c=$(OBJDIR)/%.d) $(CXXSRC:%.cpp=$(OBJDIR)/%.d)
-
-
-# Additional Suffixes
-.SUFFIXES: .elf .hex
-
-# Targets
-.PHONY: all
-all: GitVersion.h $(DIS) $(HEX)
-	$(SIZE) $(ELF)
-
-.PHONY: program
-program: $(HEX) $(ELF)
-	openocd -f openocd.cfg \
-					-c "program $(HEX) verify reset exit"
-	$(SIZE) $(ELF)
-
-.PHONY: program_bl
-program_bl: $(HEX) $(ELF)
-	stm32flash -w $(HEX) -v /dev/$(BL_PORT)
-	$(SIZE) $(ELF)
-
-.PHONY: run
-run: $(HEX) $(ELF)
-	openocd -f openocd.cfg \
-					-c "init" -c "reset" -c "exit"
-
-.PHONY: debug
-debug: $(ELF)
-	./debug.sh $(ELF)
-
-.PHONY: clean
-clean:
-	$(RM) $(OBJ) $(HEX) $(ELF) $(DIS) $(MAP) $(DEPENDS) GitVersion.h
-
-# implicit rules
-.elf.hex:
-	$(OBJCOPY) -O ihex $< $@
-
-$(OBJDIR)/%.o: %.c
-	$(CC) -MMD $(CFLAGS) -c $< -o $@
-
-$(OBJDIR)/%.o: %.cpp
-	$(CXX) -MMD $(CXXFLAGS) -c $< -o $@
-
-$(OBJDIR)/%.o: $(SYSDIR)/%.c
-	$(CC) $(CFLAGS) -c $< -o $@
-
-$(OBJDIR)/%.o: $(SYSDIR)/%.S
-	$(AS) $(ASFLAGS) -c $< -o $@
-
-# explicit rules
-$(OBJDIR):
-	mkdir -p $(OBJDIR)
-
-$(BINDIR):
-	mkdir -p $(BINDIR)
-
-$(ELF): $(OBJDIR) $(BINDIR) $(OBJ)
-	$(LD) $(OBJ) $(LDFLAGS) $(LDLIBS) -o $@
-
-$(DIS): $(ELF)
-	$(OBJDUMP) -S $< > $@
-
-# include dependecies
--include $(DEPENDS)
-
-# Export the current git version if the index file exists, else 000...
-GitVersion.h:
-ifdef SYSTEMROOT
-	echo #define GITVERSION "0000000" > $@
-else ifdef SystemRoot
-	echo #define GITVERSION "0000000" > $@
-else
-ifneq ("$(wildcard .git/index)","")
-	echo "#define GITVERSION \"$(shell git rev-parse --short HEAD)\"" > $@
-else
-	echo "#define GITVERSION \"0000000\"" > $@
-endif
-endif

NXDNRX.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2018 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-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
@@ -17,6 +17,9 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_NXDN)
+
 #include "Globals.h"
 #include "NXDNRX.h"
 #include "Utils.h"
@@ -403,3 +406,5 @@ void CNXDNRX::writeRSSIData(uint8_t* data)
   m_rssiCount = 0U;
 }
 
+#endif
+

NXDNRX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018 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
@@ -16,10 +16,13 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_NXDN)
+
 #if !defined(NXDNRX_H)
 #define  NXDNRX_H
 
-#include "Config.h"
 #include "NXDNDefines.h"
 
 enum NXDNRX_STATE {
@@ -67,3 +70,5 @@ private:
 
 #endif
 
+#endif
+

NXDNTX.cpp

@@ -18,6 +18,9 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_NXDN)
+
 #include "Globals.h"
 #include "NXDNTX.h"
 
@@ -123,7 +126,7 @@ void CNXDNTX::process()
   }
 }
 
-uint8_t CNXDNTX::writeData(const uint8_t* data, uint8_t length)
+uint8_t CNXDNTX::writeData(const uint8_t* data, uint16_t length)
 {
   if (length != (NXDN_FRAME_LENGTH_BYTES + 1U))
     return 4U;
@@ -172,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];
 
@@ -200,3 +203,6 @@ void CNXDNTX::setParams(uint8_t txHang)
 {
   m_txHang = txHang * 600U;
 }
+
+#endif
+

NXDNTX.h

@@ -16,18 +16,20 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_NXDN)
+
 #if !defined(NXDNTX_H)
 #define  NXDNTX_H
 
-#include "Config.h"
-
 #include "RingBuffer.h"
 
 class CNXDNTX {
 public:
   CNXDNTX();
 
-  uint8_t writeData(const uint8_t* data, uint8_t length);
+  uint8_t writeData(const uint8_t* data, uint16_t length);
 
   void process();
 
@@ -55,3 +57,6 @@ private:
 };
 
 #endif
+
+#endif
+

P25RX.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2017,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2018 by Bryan Biedenkapp <gatekeep@gmail.com>
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -18,6 +18,9 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_P25)
+
 #include "Globals.h"
 #include "P25RX.h"
 #include "Utils.h"
@@ -535,3 +538,6 @@ void CP25RX::writeRSSILdu(uint8_t* ldu)
   m_rssiAccum = 0U;
   m_rssiCount = 0U;
 }
+
+#endif
+

P25RX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2018 by Bryan Biedenkapp <gatekeep@gmail.com>
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -17,10 +17,13 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_P25)
+
 #if !defined(P25RX_H)
 #define  P25RX_H
 
-#include "Config.h"
 #include "P25Defines.h"
 
 enum P25RX_STATE {
@@ -72,3 +75,6 @@ private:
 };
 
 #endif
+
+#endif
+

P25TX.cpp

@@ -18,6 +18,9 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_P25)
+
 #include "Globals.h"
 #include "P25TX.h"
 
@@ -120,7 +123,7 @@ void CP25TX::process()
   }
 }
 
-uint8_t CP25TX::writeData(const uint8_t* data, uint8_t length)
+uint8_t CP25TX::writeData(const uint8_t* data, uint16_t length)
 {
   if (length < (P25_TERM_FRAME_LENGTH_BYTES + 1U))
     return 4U;
@@ -170,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];
 
@@ -198,3 +201,6 @@ void CP25TX::setParams(uint8_t txHang)
 {
   m_txHang = txHang * 1200U;
 }
+
+#endif
+

P25TX.h

@@ -16,18 +16,20 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_P25)
+
 #if !defined(P25TX_H)
 #define  P25TX_H
 
-#include "Config.h"
-
 #include "RingBuffer.h"
 
 class CP25TX {
 public:
   CP25TX();
 
-  uint8_t writeData(const uint8_t* data, uint8_t length);
+  uint8_t writeData(const uint8_t* data, uint16_t length);
 
   void process();
 
@@ -55,3 +57,6 @@ private:
 };
 
 #endif
+
+#endif
+

POCSAGTX.cpp

@@ -17,6 +17,9 @@
  */
 
 #include "Config.h"
+
+#if defined(MODE_POCSAG)
+
 #include "Globals.h"
 #include "POCSAGTX.h"
 
@@ -96,7 +99,7 @@ bool CPOCSAGTX::busy()
     return false;
 }
 
-uint8_t CPOCSAGTX::writeData(const uint8_t* data, uint8_t length)
+uint8_t CPOCSAGTX::writeData(const uint8_t* data, uint16_t length)
 {
   if (length != POCSAG_FRAME_LENGTH_BYTES)
     return 4U;
@@ -147,3 +150,6 @@ uint8_t CPOCSAGTX::getSpace() const
 {
   return m_buffer.getSpace() / POCSAG_FRAME_LENGTH_BYTES;
 }
+
+#endif
+

POCSAGTX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015-2019 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015-2020 by Jonathan Naylor G4KLX
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -16,18 +16,20 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include "Config.h"
+
+#if defined(MODE_POCSAG)
+
 #if !defined(POCSAGTX_H)
 #define  POCSAGTX_H
 
-#include "Config.h"
-
 #include "RingBuffer.h"
 
 class CPOCSAGTX {
 public:
   CPOCSAGTX();
 
-  uint8_t writeData(const uint8_t* data, uint8_t length);
+  uint8_t writeData(const uint8_t* data, uint16_t length);
 
   void writeByte(uint8_t c);
 
@@ -51,3 +53,5 @@ private:
 
 #endif
 
+#endif
+

README.md

@@ -1,7 +1,35 @@
-This is the source code of the MMDVM firmware that supports D-Star, DMR, System Fusion, P25, NXDN, and POCSAG modes.
+This is the source code of the MMDVM firmware that supports D-Star, DMR, System Fusion, P25, NXDN, POCSAG, and FM modes.
 
-It runs on the Arduino Due, the ST-Micro STM32F1xxx, STM32F4xxx and STM32F7xxx processors, as well as the Teensy 3.1/3.2/3.5/3.6. What these platforms have in common is the use of an ARM Cortex-M3 or M4 processor with a clock speed greater than 70 MHz, and access to at least one analogue to digital converter and one digital to analogue converter.
+It runs on the Arduino Due, the ST-Micro STM32F4xxx and STM32F7xxx processors, as well as the Teensy 3.5/3.6. What these platforms have in common is the use of an ARM Cortex-M3, M4, or M7 processors with a minimum clock speed greater of 80 MHz, and access to at least one analogue to digital converter, one digital to analogue converter, as well as a number of GPIO pins.
 
-In order to build this software for the Arduino Due, you will need to edit a file within the Arduino GUI and that is detailed in the BUILD.txt file. The STM32 support is being supplied via the Coocox IDE with ARM GCC. The Teensy support uses Teensyduino.
+In order to build this software for the Arduino Due, you will need to edit a file within the Arduino GUI and that is detailed in the BUILD.txt file. The STM32 support is supplied via the ARM GCC compiler. The Teensy support uses Teensyduino.
 
-This software is licenced under the GPL v2 and is intended for amateur and educational use only. Use of this software for commercial purposes is strictly forbidden.
+This software is licenced under the GPL v2 and is primarily intended for amateur and educational use.
+
+Portions of the ARM support code include the following copyright:
+
+   Copyright (c) 2011 - 2013 ARM LIMITED
+
+   All rights reserved.
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are met:
+   - Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+   - Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+   - Neither the name of ARM nor the names of its contributors may be used
+     to endorse or promote products derived from this software without
+     specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+   ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
+   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+   POSSIBILITY OF SUCH DAMAGE.

RingBuff.h

@@ -1,47 +0,0 @@
-/*
- * Copyright (C) 2017 Wojciech Krutnik N0CALL
- *
- * 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 3 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, see <http://www.gnu.org/licenses/>.
- *
- * FIFO ring buffer
- * source:
- * http://stackoverflow.com/questions/6822548/correct-way-of-implementing-a-uart-receive-buffer-in-a-small-arm-microcontroller
- * (modified)
- *
- */
- 
-#if !defined(RINGBUFF_H)
-#define RINGBUFF_H
-
-#define RINGBUFF_SIZE(ringBuff) (ringBuff.size)    /* serial buffer in bytes (power 2)   */
-#define RINGBUFF_MASK(ringBuff) (ringBuff.size-1U) /* buffer size mask                   */
-
-/* Buffer read / write macros                                                   */
-#define RINGBUFF_RESET(ringBuff)         (ringBuff).rdIdx = ringBuff.wrIdx = 0
-#define RINGBUFF_WRITE(ringBuff, dataIn) (ringBuff).data[RINGBUFF_MASK(ringBuff) & ringBuff.wrIdx++] = (dataIn)
-#define RINGBUFF_READ(ringBuff)          ((ringBuff).data[RINGBUFF_MASK(ringBuff) & ((ringBuff).rdIdx++)])
-#define RINGBUFF_EMPTY(ringBuff)         ((ringBuff).rdIdx == (ringBuff).wrIdx)
-#define RINGBUFF_FULL(ringBuff)          ((RINGBUFF_MASK(ringBuff) & ringFifo.rdIdx) == (RINGBUFF_MASK(ringBuff) & ringFifo.wrIdx))
-#define RINGBUFF_COUNT(ringBuff)         (RINGBUFF_MASK(ringBuff) & ((ringBuff).wrIdx - (ringBuff).rdIdx))
-
-/* Buffer type                                                                  */
-#define DECLARE_RINGBUFFER_TYPE(name, _size)                           \
-          typedef struct{                                              \
-            uint32_t size;                                             \
-            uint32_t wrIdx;                                            \
-            uint32_t rdIdx;                                            \
-            uint8_t data[_size];                                       \
-          }name##_t
-
-#endif

RingBuffer.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020,2026 by Jonathan Naylor G4KLX
  *   Copyright (C) 2020 by Geoffrey Merck F4FXL - KC3FRA
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -24,15 +24,12 @@
 #include "stm32f4xx.h"
 #elif defined(STM32F7XX)
 #include "stm32f7xx.h"
-#elif defined(STM32F105xC)
-#include "stm32f1xx.h"
-#include <cstddef>
 #else
 #include <Arduino.h>
 #undef PI
 #endif
 
-#if defined(__SAM3X8E__) || defined(STM32F105xC)
+#if defined(__SAM3X8E__)
 #define  ARM_MATH_CM3
 #elif defined(STM32F7XX)
 #define  ARM_MATH_CM7
@@ -53,7 +50,7 @@ public:
   
   uint16_t getData() const;
 
-  bool put(TDATATYPE item) volatile;
+  bool put(const TDATATYPE& item) volatile;
 
   bool get(TDATATYPE& item) volatile;
 
@@ -74,4 +71,4 @@ private:
 
 #include "RingBuffer.impl.h"
 
-#endif
+#endif

RingBuffer.impl.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020,2026 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(TDATATYPE item) volatile
+template <typename TDATATYPE> bool CRingBuffer<TDATATYPE>::put(const TDATATYPE& item) volatile
 {
   if (m_full) {
     m_overflow = true;

STM32Utils.h

@@ -1,5 +1,7 @@
 /*
- *   source: http://mightydevices.com/?p=144
+ *   Copyright (C) 2017 by Wojciech Krutnik N0CALL
+ *
+ *   Source: http://mightydevices.com/?p=144
  *
  *   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

SerialArduino.cpp

@@ -43,7 +43,7 @@ void CSerialPort::beginInt(uint8_t n, int speed)
   }
 }
 
-int CSerialPort::availableInt(uint8_t n)
+int CSerialPort::availableForReadInt(uint8_t n)
 {
   switch (n) {
     case 1U:

SerialPort.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018,2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020,2021,2023,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
@@ -36,27 +36,48 @@ public:
 
   void process();
 
+#if defined(MODE_DSTAR)
   void writeDStarHeader(const uint8_t* header, uint8_t length);
   void writeDStarData(const uint8_t* data, uint8_t length);
   void writeDStarLost();
   void writeDStarEOT();
+#endif
 
+#if defined(MODE_DMR)
   void writeDMRData(bool slot, const uint8_t* data, uint8_t length);
   void writeDMRLost(bool slot);
+#endif
 
+#if defined(MODE_YSF)
   void writeYSFData(const uint8_t* data, uint8_t length);
   void writeYSFLost();
+#endif
 
+#if defined(MODE_P25)
   void writeP25Hdr(const uint8_t* data, uint8_t length);
   void writeP25Ldu(const uint8_t* data, uint8_t length);
   void writeP25Lost();
+#endif
 
+#if defined(MODE_NXDN)
   void writeNXDNData(const uint8_t* data, uint8_t length);
   void writeNXDNLost();
+#endif
 
-  void writeFMData(const uint8_t* data, uint8_t length);
+#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
+
+#if defined(SERIAL_REPEATER)
+  void writeSerialData(const uint8_t* data, uint8_t length);
+#endif
+
+#if defined(I2C_REPEATER)
+  void writeI2CData(const uint8_t* data, uint8_t length);
+#endif
 
   void writeCalData(const uint8_t* data, uint8_t length);
   void writeRSSIData(const uint8_t* data, uint8_t length);
@@ -66,32 +87,39 @@ public:
   void writeDebug(const char* text, int16_t n1, int16_t n2);
   void writeDebug(const char* text, int16_t n1, int16_t n2, int16_t n3);
   void writeDebug(const char* text, int16_t n1, int16_t n2, int16_t n3, int16_t n4);
+  void writeDebugDump(const uint8_t* data, uint16_t length);
 
 private:
-  uint8_t   m_buffer[256U];
-  uint8_t   m_ptr;
-  uint8_t   m_len;
+  uint8_t   m_buffer[512U];
+  uint16_t  m_ptr;
+  uint16_t  m_len;
   bool      m_debug;
-  CRingBuffer<uint8_t> m_repeat;
+  int       m_lastSerialAvail;
+  uint16_t  m_lastSerialAvailCount;
 
-  void    sendACK();
-  void    sendNAK(uint8_t err);
+  void    sendACK(uint8_t type);
+  void    sendNAK(uint8_t type, uint8_t err);
   void    getStatus();
   void    getVersion();
-  uint8_t setConfig(const uint8_t* data, uint8_t length);
-  uint8_t setMode(const uint8_t* data, uint8_t length);
+  uint8_t setConfig(const uint8_t* data, uint16_t length);
+  uint8_t setMode(const uint8_t* data, uint16_t length);
   void    setMode(MMDVM_STATE modemState);
-  uint8_t setFMParams1(const uint8_t* data, uint8_t length);
-  uint8_t setFMParams2(const uint8_t* data, uint8_t length);
-  uint8_t setFMParams3(const uint8_t* data, uint8_t length);
-  uint8_t setFMParams4(const uint8_t* data, uint8_t length);
+  void    processMessage(uint8_t type, const uint8_t* data, uint16_t length);
+
+#if defined(MODE_FM)
+  uint8_t setFMParams1(const uint8_t* data, uint16_t length);
+  uint8_t setFMParams2(const uint8_t* data, uint16_t length);
+  uint8_t setFMParams3(const uint8_t* data, uint16_t length);
+  uint8_t setFMParams4(const uint8_t* data, uint16_t length);
+#endif
 
   // Hardware versions
   void    beginInt(uint8_t n, int speed);
-  int     availableInt(uint8_t n);
+  int     availableForReadInt(uint8_t n);
   int     availableForWriteInt(uint8_t n);
   uint8_t readInt(uint8_t n);
   void    writeInt(uint8_t n, const uint8_t* data, uint16_t length, bool flush = false);
 };
 
 #endif
+

SerialSTM.cpp

@@ -27,14 +27,14 @@
 Pin definitions:
 
 - Host communication:
-USART1 - TXD PA9  - RXD PA10 (MMDVM-Pi board, MMDVM-Pi F722 board, MMDVM-F4M board, STM32F722-F7M board, STM32F4-DVM board)
+USART1 - TXD PA9  - RXD PA10 (MMDVM-Pi board, MMDVM-Pi F722 board, MMDVM-F4M board, STM32F722-F7M board, STM32F4-DVM board, STM32F7-DVM board)
 USART2 - TXD PA2  - RXD PA3  (Nucleo64 F446RE board, Morpho or Arduino header, MMDVM_RPT_Hat BG4TGO/BG5HHP board)
 USART3 - TXD PC10 - RXD PC11 (Discovery board)
 USART3 - TXD PD8  - RXD PD9  (Nucleo144 F767ZI board)
 
 - Serial repeater:
 USART1 - TXD PA9  - RXD PA10 (Nucleo with Arduino header)
-UART5  - TXD PC12 - RXD PD2 (Discovery, MMDVM-Pi, MMDVM-Pi F722 board, MMDVM-F4M board, STM32F722-F7M board, STM32F4-DVM board, Nucleo64 with Morpho header and Nucleo144 F767ZI, MMDVM_RPT_Hat BG4TGO/BG5HHP board)
+UART5  - TXD PC12 - RXD PD2 (Discovery, MMDVM-Pi, MMDVM-Pi F722 board, MMDVM-F4M board, STM32F722-F7M board, STM32F4-DVM board, STM32F7-DVM board, Nucleo64 with Morpho header and Nucleo144 F767ZI, MMDVM_RPT_Hat BG4TGO/BG5HHP board)
 */
 
 #if defined(STM32F4XX) || defined(STM32F7XX)
@@ -48,7 +48,7 @@ extern "C" {
 }
 
 /* ************* USART1 ***************** */
-#if defined(STM32F4_PI) || defined(STM32F4_F4M) || defined(STM32F722_F7M) || defined(STM32F722_PI) || defined(STM32F722_RPT_HAT) || defined(STM32F4_DVM) || (defined(STM32F4_NUCLEO) && defined(STM32F4_NUCLEO_ARDUINO_HEADER)) || defined(DRCC_DVM)
+#if defined(STM32F4_PI) || defined(STM32F4_F4M) || defined(STM32F722_F7M) || defined(STM32F722_PI) || defined(STM32F722_RPT_HAT) || defined(STM32F4_DVM) || defined(STM32F7_DVM) || (defined(STM32F4_NUCLEO) && defined(STM32F4_NUCLEO_ARDUINO_HEADER)) || defined(DRCC_DVM) || defined(STM32F4_EDA_405) || defined(STM32F4_EDA_446)
 
 
 static CSTMUART m_USART1;
@@ -305,7 +305,7 @@ void CSerialPort::beginInt(uint8_t n, int speed)
       case 1U:
          #if defined(STM32F4_DISCOVERY) || defined(STM32F7_NUCLEO)
          InitUSART3(speed);
-         #elif defined(STM32F4_PI) || defined(STM32F4_F4M) || defined(STM32F722_PI) || defined(STM32F722_F7M) || defined(STM32F722_RPT_HAT) || defined(STM32F4_DVM)
+         #elif defined(STM32F4_PI) || defined(STM32F4_F4M) || defined(STM32F722_PI) || defined(STM32F722_F7M) || defined(STM32F722_RPT_HAT) || defined(STM32F4_DVM) || defined(STM32F7_DVM) || defined(STM32F4_EDA_405) || defined(STM32F4_EDA_446)
          InitUSART1(speed);
          #elif defined(STM32F4_NUCLEO) || defined(STM32F4_RPT_HAT_TGO)
          InitUSART2(speed);
@@ -327,13 +327,13 @@ void CSerialPort::beginInt(uint8_t n, int speed)
    }
 }
 
-int CSerialPort::availableInt(uint8_t n)
+int CSerialPort::availableForReadInt(uint8_t n)
 {
    switch (n) {
       case 1U:
          #if defined(STM32F4_DISCOVERY) || defined(STM32F7_NUCLEO)
-         return m_USART3.availble();//AvailUSART3();
-         #elif defined(STM32F4_PI) || defined(STM32F4_F4M) || defined(STM32F722_PI) || defined(STM32F722_F7M) || defined(STM32F722_RPT_HAT) || defined(STM32F4_DVM)
+         return m_USART3.available();//AvailUSART3();
+         #elif defined(STM32F4_PI) || defined(STM32F4_F4M) || defined(STM32F722_PI) || defined(STM32F722_F7M) || defined(STM32F722_RPT_HAT) || defined(STM32F4_DVM) || defined(STM32F7_DVM) || defined(STM32F4_EDA_405) || defined(STM32F4_EDA_446)
          return m_USART1.available();//AvailUSART1();
          #elif defined(STM32F4_NUCLEO) || defined(STM32F4_RPT_HAT_TGO)
          return m_USART2.available();//AvailUSART2();
@@ -359,7 +359,7 @@ int CSerialPort::availableForWriteInt(uint8_t n)
       case 1U:
          #if defined(STM32F4_DISCOVERY) || defined(STM32F7_NUCLEO)
          return m_USART3.availableForWrite(); //AvailForWriteUSART3();
-         #elif defined(STM32F4_PI) || defined(STM32F4_F4M) || defined(STM32F722_PI) || defined(STM32F722_F7M) || defined(STM32F722_RPT_HAT) || defined(STM32F4_DVM)
+         #elif defined(STM32F4_PI) || defined(STM32F4_F4M) || defined(STM32F722_PI) || defined(STM32F722_F7M) || defined(STM32F722_RPT_HAT) || defined(STM32F4_DVM) || defined(STM32F7_DVM) || defined(STM32F4_EDA_405) || defined(STM32F4_EDA_446)
          return m_USART1.availableForWrite(); //AvailForWriteUSART1();
          #elif defined(STM32F4_NUCLEO) || defined(STM32F4_RPT_HAT_TGO)
          return m_USART2.availableForWrite();//AvailForWriteUSART2();
@@ -385,7 +385,7 @@ uint8_t CSerialPort::readInt(uint8_t n)
       case 1U:
          #if defined(STM32F4_DISCOVERY) || defined(STM32F7_NUCLEO)
          return m_USART3.read();//ReadUSART3();
-         #elif defined(STM32F4_PI) || defined(STM32F4_F4M) || defined(STM32F722_PI) || defined(STM32F722_F7M) || defined(STM32F722_RPT_HAT) || defined(STM32F4_DVM)
+         #elif defined(STM32F4_PI) || defined(STM32F4_F4M) || defined(STM32F722_PI) || defined(STM32F722_F7M) || defined(STM32F722_RPT_HAT) || defined(STM32F4_DVM) || defined(STM32F7_DVM) || defined(STM32F4_EDA_405) || defined(STM32F4_EDA_446)
          return m_USART1.read();//ReadUSART1();
          #elif defined(STM32F4_NUCLEO) || defined(STM32F4_RPT_HAT_TGO)
          return m_USART2.read();//ReadUSART2();
@@ -413,7 +413,7 @@ void CSerialPort::writeInt(uint8_t n, const uint8_t* data, uint16_t length, bool
          m_USART3.write(data, length); //WriteUSART3(data, length);
          if (flush)
             m_USART3.flush();//TXSerialFlush3();
-         #elif defined(STM32F4_PI) || defined(STM32F4_F4M) || defined(STM32F722_PI) || defined(STM32F722_F7M) || defined(STM32F722_RPT_HAT) || defined(STM32F4_DVM)
+         #elif defined(STM32F4_PI) || defined(STM32F4_F4M) || defined(STM32F722_PI) || defined(STM32F722_F7M) || defined(STM32F722_RPT_HAT) || defined(STM32F4_DVM) || defined(STM32F7_DVM) || defined(STM32F4_EDA_405) || defined(STM32F4_EDA_446)
          m_USART1.write(data, length);//WriteUSART1(data, length);
          if (flush)
             m_USART1.flush();//TXSerialFlush1();
@@ -448,3 +448,4 @@ void CSerialPort::writeInt(uint8_t n, const uint8_t* data, uint16_t length, bool
 }
 
 #endif
+

SerialSTM_CMSIS.cpp

@@ -1,160 +0,0 @@
-/*
- *   Copyright (C) 2017 by Wojciech Krutnik N0CALL
- *
- *   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"
-#include "Globals.h"
-#include "RingBuff.h"
-
-#include "SerialPort.h"
-
-/*
-Pin definitions (configuration in IOSTM_CMSIS.c):
-
-- Host communication:
-USART1 - TXD PA9  - RXD PA10
-
-*/
-
-
-#if defined(STM32F1)
-
-// BaudRate calculator macro
-// source: STM32 HAL Library (stm32f1xx_hal_usart.h)
-#define USART_DIV(__PCLK__, __BAUD__)     (((__PCLK__)*25)/(4*(__BAUD__)))
-#define USART_DIVMANT(__PCLK__, __BAUD__) (USART_DIV((__PCLK__), (__BAUD__))/100)
-#define USART_DIVFRAQ(__PCLK__, __BAUD__) (((USART_DIV((__PCLK__), (__BAUD__)) - (USART_DIVMANT((__PCLK__), (__BAUD__)) * 100)) * 16 + 50) / 100)
-#define USART_BRR(__PCLK__, __BAUD__)     ((USART_DIVMANT((__PCLK__), (__BAUD__)) << 4)|(USART_DIVFRAQ((__PCLK__), (__BAUD__)) & 0x0F))
-
-#define USART_BUFFER_SIZE 256U
-DECLARE_RINGBUFFER_TYPE(USARTBuffer, USART_BUFFER_SIZE);
-
-/* ************* USART1 ***************** */
-static volatile USARTBuffer_t txBuffer1={.size=USART_BUFFER_SIZE};
-static volatile USARTBuffer_t rxBuffer1={.size=USART_BUFFER_SIZE};
-
-
-extern "C" {
-  bitband_t txe = (bitband_t)BITBAND_PERIPH(&USART1->SR, USART_SR_TXE_Pos);
-  bitband_t rxne = (bitband_t)BITBAND_PERIPH(&USART1->SR, USART_SR_RXNE_Pos);
-  bitband_t txeie = (bitband_t)BITBAND_PERIPH(&USART1->CR1, USART_CR1_TXEIE_Pos);
-  
-  RAMFUNC void USART1_IRQHandler()
-  {
-    /* Transmitting data */
-    if(*txe){
-      if(!(RINGBUFF_EMPTY(txBuffer1))){
-        USART1->DR = RINGBUFF_READ(txBuffer1);
-      }else{  /* Buffer empty */
-        *txeie = 0;  /* Don't send further data */
-      }
-    }
-
-    /* Receiving data */
-    if(*rxne){
-      RINGBUFF_WRITE(rxBuffer1, USART1->DR);
-    }
-  }
-}
-
-
-void USART1Init(int speed)
-{
-  RCC->APB2ENR |= RCC_APB2ENR_USART1EN;
-  
-  USART1->BRR = USART_BRR(72000000UL, speed);
-  
-  USART1->CR1 = USART_CR1_UE | USART_CR1_TE |
-                USART_CR1_RE | USART_CR1_RXNEIE;  // Enable USART and RX interrupt
-  NVIC_EnableIRQ(USART1_IRQn);
-}
-
-RAMFUNC void USART1TxData(const uint8_t* data, uint16_t length)
-{
-  NVIC_DisableIRQ(USART1_IRQn);
-  
-  /* Check remaining space in buffer */
-  if(RINGBUFF_COUNT(txBuffer1) + length > RINGBUFF_SIZE(txBuffer1)){
-    NVIC_EnableIRQ(USART1_IRQn);
-    return;
-  }
-  
-  /* Append data to buffer  */
-  while(length--){
-    RINGBUFF_WRITE(txBuffer1, *(data++));
-  }
-
-  /* Start sending data */
-  USART1->CR1 |= USART_CR1_TXEIE;
-
-  NVIC_EnableIRQ(USART1_IRQn);
-}
-
-
-/////////////////////////////////////////////////////////////////
-
-void CSerialPort::beginInt(uint8_t n, int speed)
-{
-  switch (n) {
-    case 1U:
-      USART1Init(speed);
-      break;
-  default:
-    break;
-  }
-}
-
-int CSerialPort::availableInt(uint8_t n)
-{
-  switch (n) {
-    case 1U:
-      return !RINGBUFF_EMPTY(rxBuffer1);
-    default:
-      return false;
-  }
-}
-
-uint8_t CSerialPort::readInt(uint8_t n)
-{
-  switch (n) {
-    case 1U:
-      return RINGBUFF_READ(rxBuffer1);
-    default:
-      return 0U;
-  }
-}
-
-void CSerialPort::writeInt(uint8_t n, const uint8_t* data, uint16_t length, bool flush)
-{
-  bitband_t tc = (bitband_t)BITBAND_PERIPH(&USART1->SR, USART_SR_TC_Pos);
-  
-  switch (n) {
-    case 1U:
-      USART1TxData(data, length);
-      *tc = 0;
-      
-      if (flush) {
-        while (!RINGBUFF_EMPTY(txBuffer1) || !tc)
-          ;
-      }
-      break;
-    default:
-      break;
-  }
-}
-
-#endif

SerialTeensy.cpp

@@ -1,4 +1,6 @@
 /*
+ *   Copyright (C) 2017 by Chris Huitema
+ *
  *   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
@@ -182,7 +184,7 @@ void CSerialPort::beginInt(uint8_t n, int speed)
   }
 }
 
-int CSerialPort::availableInt(uint8_t n)
+int CSerialPort::availableForReadInt(uint8_t n)
 {
   switch (n) {
     case 1U:

Utils.cpp

@@ -30,6 +30,15 @@ uint8_t countBits8(uint8_t bits)
   return BITS_TABLE[bits];
 }
 
+uint8_t countBits16(uint16_t bits)
+{
+  uint8_t* p = (uint8_t*)&bits;
+  uint8_t n = 0U;
+  n += BITS_TABLE[p[0U]];
+  n += BITS_TABLE[p[1U]];
+  return n;
+}
+
 uint8_t countBits32(uint32_t bits)
 {
   uint8_t* p = (uint8_t*)&bits;

Utils.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,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
@@ -23,15 +23,14 @@
 #include "stm32f4xx.h"
 #elif defined(STM32F7XX)
 #include "stm32f7xx.h"
-#elif defined(STM32F105xC)
-#include "stm32f1xx.h"
-#include <cstddef>
 #else
 #include <Arduino.h>
 #endif
 
 uint8_t countBits8(uint8_t bits);
 
+uint8_t countBits16(uint16_t bits);
+
 uint8_t countBits32(uint32_t bits);
 
 uint8_t countBits64(uint64_t bits);