Implement Kerchunk TX option.

Add forgotten file for large frame handling

.gitignore

@@ -0,0 +1,5 @@
+*.o
+obj/
+bin/
+GitVersion.h
+build/

.gitmodules

@@ -0,0 +1,9 @@
+[submodule "STM32F4XX_Lib"]
+	path = STM32F4XX_Lib
+	url = https://github.com/juribeparada/STM32F4XX_Lib.git
+[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-2015 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2017 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -17,8 +17,6 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-// #define  WANT_DEBUG
-
 #include "Config.h"
 #include "Globals.h"
 #include "CWIdTX.h"
@@ -77,6 +75,9 @@ const struct {
   {'/', 0xEAE80000U, 16U},
   {'?', 0xAEEA0000U, 18U},
   {',', 0xEEAEE000U, 22U},
+  {'-', 0xEAAE0000U, 18U},
+  {'=', 0xEAB80000U, 16U},
+  {'.', 0xBAEB8000U, 20U},
   {' ', 0x00000000U, 4U},
   {0U,  0x00000000U, 0U}
 };
@@ -170,4 +171,3 @@ void CCWIdTX::reset()
   m_poPtr = 0U;
   m_n     = 0U;
 }
-

CalDMR.cpp

@@ -21,19 +21,190 @@
 #include "Globals.h"
 #include "CalDMR.h"
 
+// Voice LC BS Header, CC: 1, srcID: 1, dstID: TG9
+const uint8_t VH_1K[] = {0x00U,
+         0x00U, 0x20U, 0x08U, 0x08U, 0x02U, 0x38U, 0x15U, 0x00U, 0x2CU, 0xA0U, 0x14U,
+         0x60U, 0x84U, 0x6DU, 0xFFU, 0x57U, 0xD7U, 0x5DU, 0xF5U, 0xDEU, 0x30U, 0x30U,
+         0x01U, 0x10U, 0x01U, 0x40U, 0x03U, 0xC0U, 0x13U, 0xC1U, 0x1EU, 0x80U, 0x6FU};
+
+// Voice Term BS with LC, CC: 1, srcID: 1, dstID: TG9
+const uint8_t VT_1K[] = {0x00U,
+         0x00U, 0x4FU, 0x08U, 0xDCU, 0x02U, 0x88U, 0x15U, 0x78U, 0x2CU, 0xD0U, 0x14U,
+         0xC0U, 0x84U, 0xADU, 0xFFU, 0x57U, 0xD7U, 0x5DU, 0xF5U, 0xD9U, 0x65U, 0x24U,
+         0x02U, 0x28U, 0x06U, 0x20U, 0x0FU, 0x80U, 0x1BU, 0xC1U, 0x07U, 0x80U, 0x5CU};
+
+// Voice LC MS Header, CC: 1, srcID: 1, dstID: TG9
+const uint8_t VH_DMO1K[] = {0x00U,
+         0x00U, 0x20U, 0x08U, 0x08U, 0x02U, 0x38U, 0x15U, 0x00U, 0x2CU, 0xA0U, 0x14U,
+         0x60U, 0x84U, 0x6DU, 0x5DU, 0x7FU, 0x77U, 0xFDU, 0x75U, 0x7EU, 0x30U, 0x30U,
+         0x01U, 0x10U, 0x01U, 0x40U, 0x03U, 0xC0U, 0x13U, 0xC1U, 0x1EU, 0x80U, 0x6FU};
+
+// Voice Term MS with LC, CC: 1, srcID: 1, dstID: TG9
+const uint8_t VT_DMO1K[] = {0x00U,
+         0x00U, 0x4FU, 0x08U, 0xDCU, 0x02U, 0x88U, 0x15U, 0x78U, 0x2CU, 0xD0U, 0x14U,
+         0xC0U, 0x84U, 0xADU, 0x5DU, 0x7FU, 0x77U, 0xFDU, 0x75U, 0x79U, 0x65U, 0x24U,
+         0x02U, 0x28U, 0x06U, 0x20U, 0x0FU, 0x80U, 0x1BU, 0xC1U, 0x07U, 0x80U, 0x5CU};
+
+// Voice coding data + FEC, 1031 Hz Test Pattern
+const uint8_t VOICE_1K[] = {0x00U,
+         0xCEU, 0xA8U, 0xFEU, 0x83U, 0xACU, 0xC4U, 0x58U, 0x20U, 0x0AU, 0xCEU, 0xA8U,
+         0xFEU, 0x83U, 0xA0U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x0CU, 0xC4U, 0x58U, 
+         0x20U, 0x0AU, 0xCEU, 0xA8U, 0xFEU, 0x83U, 0xACU, 0xC4U, 0x58U, 0x20U, 0x0AU};
+
+// Embedded LC BS: CC: 1, srcID: 1, dstID: TG9
+const uint8_t SYNCEMB_1K[6][7] = {
+         {0x07U, 0x55U, 0xFDU, 0x7DU, 0xF7U, 0x5FU, 0x70U},   // BS VOICE SYNC      (audio seq 0)
+         {0x01U, 0x30U, 0x00U, 0x00U, 0x90U, 0x09U, 0x10U},   // EMB + Embedded LC1 (audio seq 1)
+         {0x01U, 0x70U, 0x00U, 0x90U, 0x00U, 0x07U, 0x40U},   // EMB + Embedded LC2 (audio seq 2)
+         {0x01U, 0x70U, 0x00U, 0x31U, 0x40U, 0x07U, 0x40U},   // EMB + Embedded LC3 (audio seq 3)
+         {0x01U, 0x50U, 0xA1U, 0x71U, 0xD1U, 0x70U, 0x70U},   // EMB + Embedded LC4 (audio seq 4)
+         {0x01U, 0x10U, 0x00U, 0x00U, 0x00U, 0x0EU, 0x20U}};  // EMB                (audio seq 5)
+
+// Embedded LC MS: CC: 1, srcID: 1, dstID: TG9
+const uint8_t SYNCEMB_DMO1K[6][7] = {
+         {0x07U, 0xF7U, 0xD5U, 0xDDU, 0x57U, 0xDFU, 0xD0U},   // MS VOICE SYNC      (audio seq 0)
+         {0x01U, 0x30U, 0x00U, 0x00U, 0x90U, 0x09U, 0x10U},   // EMB + Embedded LC1 (audio seq 1)
+         {0x01U, 0x70U, 0x00U, 0x90U, 0x00U, 0x07U, 0x40U},   // EMB + Embedded LC2 (audio seq 2)
+         {0x01U, 0x70U, 0x00U, 0x31U, 0x40U, 0x07U, 0x40U},   // EMB + Embedded LC3 (audio seq 3)
+         {0x01U, 0x50U, 0xA1U, 0x71U, 0xD1U, 0x70U, 0x70U},   // EMB + Embedded LC4 (audio seq 4)
+         {0x01U, 0x10U, 0x00U, 0x00U, 0x00U, 0x0EU, 0x20U}};  // EMB                (audio seq 5)
+
+// Short LC:
+// TS1: dstID: 0, ACTIVITY_NONE
+// TS2: dstID: TG9, ACTIVITY_VOICE
+const uint8_t SHORTLC_1K[] = {0x33U, 0x3AU, 0xA0U, 0x30U, 0x00U, 0x55U, 0xA6U, 0x5FU, 0x50U};
 
 CCalDMR::CCalDMR() :
-m_transmit(false) 
+m_transmit(false),
+m_state(DMRCAL1K_IDLE),
+m_frame_start(0U),
+m_dmr1k(),
+m_audioSeq(0)
 {
+  ::memcpy(m_dmr1k, VOICE_1K, DMR_FRAME_LENGTH_BYTES + 1U);
 }
 
 void CCalDMR::process()
 {
-  if (m_transmit) {
-    dmrTX.setCal(true);
-    dmrTX.process();
-  } else {
-    dmrTX.setCal(false);
+  switch (m_modemState) {
+    case STATE_DMRCAL:
+    case STATE_LFCAL:
+      if (m_transmit) {
+        dmrTX.setCal(true);
+        dmrTX.process();
+      } else {
+        dmrTX.setCal(false);
+      }
+      break;
+    case STATE_DMRCAL1K:
+      dmr1kcal();
+      break;
+    case STATE_DMRDMO1K:
+      dmrdmo1k();
+      break;
+    default:
+      break;
+  }
+}
+
+void CCalDMR::createData1k(uint8_t n)
+{
+  for(uint8_t i = 0; i < 5U; i++)
+    m_dmr1k[i + 15U] = SYNCEMB_1K[n][i + 1U];
+
+  m_dmr1k[14U] &= 0xF0U;
+  m_dmr1k[20U] &= 0x0FU;
+  m_dmr1k[14U] |= SYNCEMB_1K[n][0] & 0x0FU;
+  m_dmr1k[20U] |= SYNCEMB_1K[n][6] & 0xF0U;
+}
+
+void CCalDMR::createDataDMO1k(uint8_t n)
+{
+  for(uint8_t i = 0; i < 5U; i++)
+    m_dmr1k[i + 15U] = SYNCEMB_DMO1K[n][i + 1U];
+
+  m_dmr1k[14U] &= 0xF0U;
+  m_dmr1k[20U] &= 0x0FU;
+  m_dmr1k[14U] |= SYNCEMB_DMO1K[n][0] & 0x0FU;
+  m_dmr1k[20U] |= SYNCEMB_DMO1K[n][6] & 0xF0U;
+}
+
+void CCalDMR::dmr1kcal()
+{
+  dmrTX.process();
+
+  uint16_t space = dmrTX.getSpace2();
+  if (space < 1U)
+    return;
+
+  switch (m_state) {
+    case DMRCAL1K_VH:
+      dmrTX.setColorCode(1U);
+      dmrTX.writeShortLC(SHORTLC_1K, 9U);
+      dmrTX.writeData2(VH_1K, DMR_FRAME_LENGTH_BYTES + 1U);
+      dmrTX.setStart(true);
+      m_state = DMRCAL1K_VOICE;
+      break;
+    case DMRCAL1K_VOICE:
+      createData1k(m_audioSeq);
+      dmrTX.writeData2(m_dmr1k, DMR_FRAME_LENGTH_BYTES + 1U);
+      if(m_audioSeq == 5U) {
+        m_audioSeq = 0U;
+        if(!m_transmit)
+          m_state = DMRCAL1K_VT;
+      } else
+        m_audioSeq++;
+      break;
+    case DMRCAL1K_VT:
+      dmrTX.writeData2(VT_1K, DMR_FRAME_LENGTH_BYTES + 1U);
+      m_frame_start = dmrTX.getFrameCount();
+      m_state = DMRCAL1K_WAIT;
+      break;
+    case DMRCAL1K_WAIT:
+      if (dmrTX.getFrameCount() > (m_frame_start + 30U)) {
+        dmrTX.setStart(false);
+        dmrTX.resetFifo2();
+        m_audioSeq = 0U;
+        m_state = DMRCAL1K_IDLE;
+      }
+      break;
+    default:
+        m_state = DMRCAL1K_IDLE;
+      break;
+  }
+}
+
+void CCalDMR::dmrdmo1k()
+{
+  dmrDMOTX.process();
+
+  uint16_t space = dmrDMOTX.getSpace();
+  if (space < 1U)
+    return;
+
+  switch (m_state) {
+    case DMRCAL1K_VH:
+      dmrDMOTX.writeData(VH_DMO1K, DMR_FRAME_LENGTH_BYTES + 1U);
+      m_state = DMRCAL1K_VOICE;
+      break;
+    case DMRCAL1K_VOICE:
+      createDataDMO1k(m_audioSeq);
+      dmrDMOTX.writeData(m_dmr1k, DMR_FRAME_LENGTH_BYTES + 1U);
+      if(m_audioSeq == 5U) {
+        m_audioSeq = 0U;
+        if(!m_transmit)
+          m_state = DMRCAL1K_VT;
+      } else
+        m_audioSeq++;
+      break;
+    case DMRCAL1K_VT:
+      dmrDMOTX.writeData(VT_DMO1K, DMR_FRAME_LENGTH_BYTES + 1U);
+      m_state = DMRCAL1K_IDLE;
+      break;
+    default:
+        m_state = DMRCAL1K_IDLE;
+        m_audioSeq = 0U;
+      break;
   }
 }
 
@@ -44,6 +215,9 @@ uint8_t CCalDMR::write(const uint8_t* data, uint8_t length)
 
   m_transmit = data[0U] == 1U;
 
+  if(m_transmit && m_state == DMRCAL1K_IDLE && (m_modemState == STATE_DMRCAL1K || m_modemState == STATE_DMRDMO1K))
+    m_state = DMRCAL1K_VH;
+
   return 0U;
 }
 

CalDMR.h

@@ -23,16 +23,32 @@
 #include "Config.h"
 #include "DMRDefines.h"
 
+enum DMRCAL1K {
+  DMRCAL1K_IDLE,
+  DMRCAL1K_VH,
+  DMRCAL1K_VOICE,
+  DMRCAL1K_VT,
+  DMRCAL1K_WAIT
+};
+
 class CCalDMR {
 public:
   CCalDMR();
 
   void process();
+  void dmr1kcal();
+  void dmrdmo1k();
+  void createData1k(uint8_t n);
+  void createDataDMO1k(uint8_t n);
 
   uint8_t write(const uint8_t* data, uint8_t length);
 
 private:
-  bool m_transmit;
+  bool      m_transmit;
+  DMRCAL1K  m_state;
+  uint32_t  m_frame_start;
+  uint8_t   m_dmr1k[DMR_FRAME_LENGTH_BYTES + 1U];
+  uint8_t   m_audioSeq;
 };
 
 #endif

CalFM.cpp

@@ -0,0 +1,127 @@
+/*
+ *   Copyright (C) 2009-2015 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2016 by Colin Durbridge G4EML
+ *   Copyright (C) 2020 by Phil Taylor M0VSE
+ *
+ *   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 "CalFM.h"
+
+
+const struct TONE_TABLE {
+  uint16_t  frequency;
+  uint16_t length;
+  q31_t    increment;
+} TONE_TABLE_DATA[] = {
+  {2495U, 10U, 223248821},
+  {2079U, 12U, 186025772},
+  {1633U, 15U, 146118367},
+  {1247U, 19U, 111579672},
+  {1039U, 23U, 93012886},
+  {956U,  25U, 85541432}};
+
+const uint8_t TONE_TABLE_DATA_LEN = 6U;
+
+CCalFM::CCalFM() :
+m_frequency(0),
+m_length(0),
+m_tone(NULL),
+m_level(128 * 12),
+m_transmit(false),
+m_audioSeq(0),
+m_lastState(STATE_IDLE)
+{
+}
+
+void CCalFM::process()
+{
+  const TONE_TABLE* entry = NULL;
+
+  if (m_modemState != m_lastState)
+  {
+    switch (m_modemState) {
+        case STATE_FMCAL10K:
+          m_frequency = 956U;
+          break;
+        case STATE_FMCAL12K:
+          m_frequency = 1039U;
+          break;
+        case STATE_FMCAL15K:
+          m_frequency = 1247U;
+          break;
+        case STATE_FMCAL20K:
+          m_frequency = 1633U;
+          break;
+        case STATE_FMCAL25K:
+          m_frequency = 2079U;
+          break;
+        case STATE_FMCAL30K:
+          m_frequency = 2495U;
+          break;
+        default:
+          m_frequency = 0U;
+          break;
+    }
+
+    for (uint8_t i = 0U; i < TONE_TABLE_DATA_LEN; i++) {
+      if (TONE_TABLE_DATA[i].frequency == m_frequency) {
+        entry = TONE_TABLE_DATA + i;
+        break;
+      }
+    }
+
+    if (entry == NULL)
+      return;
+
+    m_length = entry->length;
+
+    delete[] m_tone;
+    m_tone = new q15_t[m_length];
+
+    q31_t arg = 0;
+    for (uint16_t i = 0U; i < m_length; i++) {
+      q63_t value = ::arm_sin_q31(arg) * q63_t(m_level);
+      m_tone[i] = q15_t(__SSAT((value >> 31), 16));
+
+      arg += entry->increment;
+    }
+
+    m_lastState=m_modemState;
+  }
+
+  if (m_transmit)
+  {
+    uint16_t space = io.getSpace();
+    while (space > m_length)
+    {
+      io.write(m_modemState,m_tone,m_length);
+      space -= m_length;
+    }
+  }
+}
+
+
+uint8_t CCalFM::write(const uint8_t* data, uint8_t length)
+{
+  if (length != 1U)
+    return 4U;
+
+  m_transmit = data[0U] == 1U;
+
+  return 0U;
+}

CalFM.h

@@ -0,0 +1,51 @@
+/*
+ *   Copyright (C) 2009-2015 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2016 by Colin Durbridge G4EML
+ *   Copyright (C) 2020 by Phil Taylor M0VSE
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#if !defined(CALFM_H)
+#define  CALFM_H
+
+#include "Config.h"
+
+class CCalFM {
+public:
+  CCalFM();
+
+  void process();
+  void fm10kcal();
+  void fm12k5cal();
+  void fm15kcal();
+  void fm20kcal();
+  void fm25kcal();
+  void fm30kcal();
+
+  uint8_t write(const uint8_t* data, uint8_t length);
+
+private:
+  uint16_t  m_frequency;
+  uint16_t  m_length;
+  q15_t*    m_tone;
+  q15_t     m_level;
+  bool      m_transmit;
+  uint8_t   m_audioSeq;
+  uint8_t   m_lastState;
+};
+
+#endif
+

CalNXDN.cpp

@@ -0,0 +1,94 @@
+/*
+ *   Copyright (C) 2018 by Andy Uribe CA6JAU
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "Config.h"
+#include "Globals.h"
+#include "CalNXDN.h"
+
+// NXDN 1031 Hz Test Pattern, RAN: 1, Unit ID: 1, Dst Group ID: 1, Outbound Direction
+const uint8_t NXDN_CAL1K[4][49] = {
+                            {0x00U,
+                             0xCDU, 0xF5U, 0x9DU, 0x5DU, 0x7CU, 0xFAU, 0x0AU, 0x6EU, 0x8AU, 0x23U, 0x56U, 0xE8U,
+                             0x4CU, 0xAAU, 0xDEU, 0x8BU, 0x26U, 0xE4U, 0xF2U, 0x82U, 0x88U,
+                             0xC6U, 0x8AU, 0x74U, 0x29U, 0xA4U, 0xECU, 0xD0U, 0x08U, 0x22U,
+                             0xCEU, 0xA2U, 0xFCU, 0x01U, 0x8CU, 0xECU, 0xDAU, 0x0AU, 0xA0U,
+                             0xEEU, 0x8AU, 0x7EU, 0x2BU, 0x26U, 0xCCU, 0xF8U, 0x8AU, 0x08U},
+
+                            {0x00U,
+                             0xCDU, 0xF5U, 0x9DU, 0x5DU, 0x7CU, 0x6DU, 0xBBU, 0x0EU, 0xB3U, 0xA4U, 0x26U, 0xA8U,
+                             0x4CU, 0xAAU, 0xDEU, 0x8BU, 0x26U, 0xE4U, 0xF2U, 0x82U, 0x88U,
+                             0xC6U, 0x8AU, 0x74U, 0x29U, 0xA4U, 0xECU, 0xD0U, 0x08U, 0x22U,
+                             0xCEU, 0xA2U, 0xFCU, 0x01U, 0x8CU, 0xECU, 0xDAU, 0x0AU, 0xA0U,
+                             0xEEU, 0x8AU, 0x7EU, 0x2BU, 0x26U, 0xCCU, 0xF8U, 0x8AU, 0x08U},
+
+                            {0x00U,
+                             0xCDU, 0xF5U, 0x9DU, 0x5DU, 0x76U, 0x3AU, 0x1BU, 0x4AU, 0x81U, 0xA8U, 0xE2U, 0x80U,
+                             0x4CU, 0xAAU, 0xDEU, 0x8BU, 0x26U, 0xE4U, 0xF2U, 0x82U, 0x88U,
+                             0xC6U, 0x8AU, 0x74U, 0x29U, 0xA4U, 0xECU, 0xD0U, 0x08U, 0x22U,
+                             0xCEU, 0xA2U, 0xFCU, 0x01U, 0x8CU, 0xECU, 0xDAU, 0x0AU, 0xA0U,
+                             0xEEU, 0x8AU, 0x7EU, 0x2BU, 0x26U, 0xCCU, 0xF8U, 0x8AU, 0x08U},
+
+                            {0x00U,
+                             0xCDU, 0xF5U, 0x9DU, 0x5DU, 0x74U, 0x28U, 0x83U, 0x02U, 0xB0U, 0x2DU, 0x07U, 0xE2U,
+                             0x4CU, 0xAAU, 0xDEU, 0x8BU, 0x26U, 0xE4U, 0xF2U, 0x82U, 0x88U,
+                             0xC6U, 0x8AU, 0x74U, 0x29U, 0xA4U, 0xECU, 0xD0U, 0x08U, 0x22U,
+                             0xCEU, 0xA2U, 0xFCU, 0x01U, 0x8CU, 0xECU, 0xDAU, 0x0AU, 0xA0U,
+                             0xEEU, 0x8AU, 0x7EU, 0x2BU, 0x26U, 0xCCU, 0xF8U, 0x8AU, 0x08U}};
+
+CCalNXDN::CCalNXDN() :
+m_transmit(false),
+m_state(NXDNCAL1K_IDLE),
+m_audioSeq(0U)
+{
+}
+
+void CCalNXDN::process()
+{
+  nxdnTX.process();
+
+  uint16_t space = nxdnTX.getSpace();
+  if (space < 1U)
+    return;
+
+  switch (m_state) {
+    case NXDNCAL1K_TX:
+      nxdnTX.writeData(NXDN_CAL1K[m_audioSeq], NXDN_FRAME_LENGTH_BYTES + 1U);
+      m_audioSeq = (m_audioSeq + 1U) % 4U;
+      if(!m_transmit)
+        m_state = NXDNCAL1K_IDLE;
+      break;
+    default:
+        m_state = NXDNCAL1K_IDLE;
+        m_audioSeq = 0U;
+      break;
+  }
+}
+
+uint8_t CCalNXDN::write(const uint8_t* data, uint8_t length)
+{
+  if (length != 1U)
+    return 4U;
+
+  m_transmit = data[0U] == 1U;
+
+  if(m_transmit && m_state == NXDNCAL1K_IDLE)
+    m_state = NXDNCAL1K_TX;
+
+  return 0U;
+}
+

CalNXDN.h

@@ -0,0 +1,44 @@
+/*
+ *   Copyright (C) 2018 by Andy Uribe CA6JAU
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#if !defined(CALNXDN_H)
+#define  CALNXDN_H
+
+#include "Config.h"
+
+enum NXDNCAL1K {
+  NXDNCAL1K_IDLE,
+  NXDNCAL1K_TX
+};
+
+class CCalNXDN {
+public:
+  CCalNXDN();
+
+  void process();
+
+  uint8_t write(const uint8_t* data, uint8_t length);
+
+private:
+  bool      m_transmit;
+  NXDNCAL1K m_state;
+  uint8_t   m_audioSeq;
+};
+
+#endif
+

CalP25.cpp

@@ -0,0 +1,97 @@
+/*
+ *   Copyright (C) 2018 by Andy Uribe CA6JAU
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "Config.h"
+#include "Globals.h"
+#include "CalP25.h"
+
+// Recommended 1011 Hz test pattern for P25 Phase 1 (ANSI/TIA-102.CAAA)
+// NAC: 0x293, srcID: 1, dstID: TG1
+unsigned char LDU1_1K[] = {0x00,
+                           0x55, 0x75, 0xF5, 0xFF, 0x77, 0xFF, 0x29, 0x35, 0x54, 0x7B, 0xCB, 0x19, 0x4D, 0x0D, 0xCE, 0x24, 0xA1, 0x24,
+                           0x0D, 0x43, 0x3C, 0x0B, 0xE1, 0xB9, 0x18, 0x44, 0xFC, 0xC1, 0x62, 0x96, 0x27, 0x60, 0xE4, 0xE2, 0x4A, 0x10,
+                           0x90, 0xD4, 0x33, 0xC0, 0xBE, 0x1B, 0x91, 0x84, 0x4C, 0xFC, 0x16, 0x29, 0x62, 0x76, 0x0E, 0xC0, 0x00, 0x00,
+                           0x00, 0x00, 0x03, 0x89, 0x28, 0x49, 0x0D, 0x43, 0x3C, 0x02, 0xF8, 0x6E, 0x46, 0x11, 0x3F, 0xC1, 0x62, 0x94,
+                           0x89, 0xD8, 0x39, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x38, 0x24, 0xA1, 0x24, 0x35, 0x0C, 0xF0, 0x2F, 0x86, 0xE4,
+                           0x18, 0x44, 0xFF, 0x05, 0x8A, 0x58, 0x9D, 0x83, 0xB0, 0x00, 0x00, 0x00, 0x00, 0x70, 0xE2, 0x4A, 0x12, 0x40,
+                           0xD4, 0x33, 0xC0, 0xBE, 0x1B, 0x91, 0x84, 0x4F, 0xF0, 0x16, 0x29, 0x62, 0x76, 0x0E, 0x6D, 0xE5, 0xD5, 0x48,
+                           0xAD, 0xE3, 0x89, 0x28, 0x49, 0x0D, 0x43, 0x3C, 0x08, 0xF8, 0x6E, 0x46, 0x11, 0x3F, 0xC1, 0x62, 0x96, 0x24,
+                           0xD8, 0x3B, 0xA1, 0x41, 0xC2, 0xD2, 0xBA, 0x38, 0x90, 0xA1, 0x24, 0x35, 0x0C, 0xF0, 0x2F, 0x86, 0xE4, 0x60,
+                           0x44, 0xFF, 0x05, 0x8A, 0x58, 0x9D, 0x83, 0x94, 0xC8, 0xFB, 0x02, 0x35, 0xA4, 0xE2, 0x4A, 0x12, 0x43, 0x50,
+                           0x33, 0xC0, 0xBE, 0x1B, 0x91, 0x84, 0x4F, 0xF0, 0x58, 0x29, 0x62, 0x76, 0x0E, 0xC0, 0x00, 0x00, 0x00, 0x0C,
+                           0x89, 0x28, 0x49, 0x0D, 0x43, 0x3C, 0x0B, 0xE1, 0xB8, 0x46, 0x11, 0x3F, 0xC1, 0x62, 0x96, 0x27, 0x60, 0xE4};
+
+unsigned char LDU2_1K[] = {0x00,
+                           0x55, 0x75, 0xF5, 0xFF, 0x77, 0xFF, 0x29, 0x3A, 0xB8, 0xA4, 0xEF, 0xB0, 0x9A, 0x8A, 0xCE, 0x24, 0xA1, 0x24,
+                           0x0D, 0x43, 0x3C, 0x0B, 0xE1, 0xB9, 0x18, 0x44, 0xFC, 0xC1, 0x62, 0x96, 0x27, 0x60, 0xEC, 0xE2, 0x4A, 0x10,
+                           0x90, 0xD4, 0x33, 0xC0, 0xBE, 0x1B, 0x91, 0x84, 0x4C, 0xFC, 0x16, 0x29, 0x62, 0x76, 0x0E, 0x40, 0x00, 0x00,
+                           0x00, 0x00, 0x03, 0x89, 0x28, 0x49, 0x0D, 0x43, 0x3C, 0x02, 0xF8, 0x6E, 0x46, 0x11, 0x3F, 0xC1, 0x62, 0x94,
+                           0x89, 0xD8, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x24, 0xA1, 0x24, 0x35, 0x0C, 0xF0, 0x2F, 0x86, 0xE4,
+                           0x18, 0x44, 0xFF, 0x05, 0x8A, 0x58, 0x9D, 0x83, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE2, 0x4A, 0x12, 0x40,
+                           0xD4, 0x33, 0xC0, 0xBE, 0x1B, 0x91, 0x84, 0x4F, 0xF0, 0x16, 0x29, 0x62, 0x76, 0x0E, 0xE0, 0xE0, 0x00, 0x00,
+                           0x00, 0x03, 0x89, 0x28, 0x49, 0x0D, 0x43, 0x3C, 0x08, 0xF8, 0x6E, 0x46, 0x11, 0x3F, 0xC1, 0x62, 0x96, 0x24,
+                           0xD8, 0x39, 0xAE, 0x8B, 0x48, 0xB6, 0x49, 0x38, 0x90, 0xA1, 0x24, 0x35, 0x0C, 0xF0, 0x2F, 0x86, 0xE4, 0x60,
+                           0x44, 0xFF, 0x05, 0x8A, 0x58, 0x9D, 0x83, 0xB9, 0xA8, 0xF4, 0xF1, 0xFD, 0x60, 0xE2, 0x4A, 0x12, 0x43, 0x50,
+                           0x33, 0xC0, 0xBE, 0x1B, 0x91, 0x84, 0x4F, 0xF0, 0x58, 0x29, 0x62, 0x76, 0x0E, 0x40, 0x00, 0x00, 0x00, 0x0C,
+                           0x89, 0x28, 0x49, 0x0D, 0x43, 0x3C, 0x0B, 0xE1, 0xB8, 0x46, 0x11, 0x3F, 0xC1, 0x62, 0x96, 0x27, 0x60, 0xEC};
+
+CCalP25::CCalP25() :
+m_transmit(false),
+m_state(P25CAL1K_IDLE)
+{
+}
+
+void CCalP25::process()
+{
+  p25TX.process();
+
+  uint16_t space = p25TX.getSpace();
+  if (space < 1U)
+    return;
+
+  switch (m_state) {
+    case P25CAL1K_LDU1:
+      p25TX.writeData(LDU1_1K, P25_LDU_FRAME_LENGTH_BYTES + 1U);
+      m_state = P25CAL1K_LDU2;
+      break;
+    case P25CAL1K_LDU2:
+      p25TX.writeData(LDU2_1K, P25_LDU_FRAME_LENGTH_BYTES + 1U);
+      if(!m_transmit)
+        m_state = P25CAL1K_IDLE;
+      else
+        m_state = P25CAL1K_LDU1;
+      break;
+    default:
+        m_state = P25CAL1K_IDLE;
+      break;
+  }
+}
+
+uint8_t CCalP25::write(const uint8_t* data, uint8_t length)
+{
+  if (length != 1U)
+    return 4U;
+
+  m_transmit = data[0U] == 1U;
+
+  if(m_transmit && m_state == P25CAL1K_IDLE)
+    m_state = P25CAL1K_LDU1;
+
+  return 0U;
+}
+

CalP25.h

@@ -0,0 +1,45 @@
+/*
+ *   Copyright (C) 2018 by Andy Uribe CA6JAU
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#if !defined(CALP25_H)
+#define  CALP25_H
+
+#include "Config.h"
+#include "P25Defines.h"
+
+enum P25CAL1K {
+  P25CAL1K_IDLE,
+  P25CAL1K_LDU1,
+  P25CAL1K_LDU2
+};
+
+class CCalP25 {
+public:
+  CCalP25();
+
+  void process();
+
+  uint8_t write(const uint8_t* data, uint8_t length);
+
+private:
+  bool      m_transmit;
+  P25CAL1K  m_state;
+};
+
+#endif
+

CalPOCSAG.cpp

@@ -0,0 +1,49 @@
+/*
+ *   Copyright (C) 2019 by Florian Wolters DF2ET
+ *
+ *   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 "CalPOCSAG.h"
+
+
+CCalPOCSAG::CCalPOCSAG() :
+m_state(POCSAGCAL_IDLE)
+{
+}
+
+void CCalPOCSAG::process()
+{
+  if (m_state == POCSAGCAL_IDLE)
+    return;
+
+  uint16_t space = io.getSpace();
+  if (space <= 165U)
+    return;
+
+  pocsagTX.writeByte(0xAAU);
+}
+
+uint8_t CCalPOCSAG::write(const uint8_t* data, uint8_t length)
+{
+  if (length != 1U)
+    return 4U;
+
+  m_state = data[0U] == 1U ? POCSAGCAL_TX : POCSAGCAL_IDLE;
+
+  return 0U;
+}

CalPOCSAG.h

@@ -0,0 +1,41 @@
+/*
+ *   Copyright (C) 2019 by Florian Wolters DF2ET
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#if !defined(CALPOCSAG_H)
+#define  CALPOCSAG_H
+
+#include "Config.h"
+
+enum POCSAGCAL {
+  POCSAGCAL_IDLE,
+  POCSAGCAL_TX
+};
+
+class CCalPOCSAG {
+public:
+  CCalPOCSAG();
+
+  void process();
+
+  uint8_t write(const uint8_t* data, uint8_t length);
+
+private:
+  POCSAGCAL m_state;
+};
+
+#endif

CalRSSI.cpp

@@ -0,0 +1,65 @@
+/*
+ *   Copyright (C) 2016 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"
+#include "Globals.h"
+#include "CalRSSI.h"
+#include "Utils.h"
+
+CCalRSSI::CCalRSSI() :
+m_count(0U),
+m_accum(0U),
+m_min(0xFFFFU),
+m_max(0x0000U)
+{
+}
+
+void CCalRSSI::samples(const uint16_t* rssi, uint8_t length)
+{
+  for (uint16_t i = 0U; i < length; i++) {
+    uint16_t ss = rssi[i];
+
+    m_accum += ss;
+
+    if (ss > m_max)
+      m_max = ss;
+    if (ss < m_min)
+      m_min = ss;
+
+    m_count++;
+    if (m_count >= 24000U) {
+      uint16_t ave = m_accum / m_count;
+
+      uint8_t buffer[6U];
+      buffer[0U] = (m_max >> 8) & 0xFFU;
+      buffer[1U] = (m_max >> 0) & 0xFFU;
+      buffer[2U] = (m_min >> 8) & 0xFFU;
+      buffer[3U] = (m_min >> 0) & 0xFFU;
+      buffer[4U] = (ave >> 8) & 0xFFU;
+      buffer[5U] = (ave >> 0) & 0xFFU;
+
+      serial.writeRSSIData(buffer, 6U);
+
+      m_count = 0U;
+      m_accum = 0U;
+      m_min   = 0xFFFFU;
+      m_max   = 0x0000U;
+    }
+  }
+}
+

CalRSSI.h

@@ -0,0 +1,38 @@
+/*
+ *   Copyright (C) 2016 by Jonathan Naylor G4KLX
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#if !defined(CALRSSI_H)
+#define  CALRSSI_H
+
+#include "Config.h"
+
+class CCalRSSI {
+public:
+  CCalRSSI();
+
+  void samples(const uint16_t* rssi, uint8_t length);
+
+private:
+  uint32_t m_count;
+  uint32_t m_accum;
+  uint16_t m_min;
+  uint16_t m_max;
+};
+
+#endif
+

Config.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016 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
@@ -27,7 +27,7 @@
 // Frequencies such as 10.0 Mhz (48000 * 208.333) or 20 Mhz (48000 * 416.666) are not suitable.
 //
 // For 12 MHz
-// #define EXTERNAL_OSC 12000000
+#define EXTERNAL_OSC 12000000
 // For 12.288 MHz
 // #define EXTERNAL_OSC 12288000
 // For 14.4 MHz
@@ -35,25 +35,40 @@
 // 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
 
-// Use pins to output the current mode
-// #define ARDUINO_MODE_PINS
+// Use pins to output the current mode via 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
 
 // For the SP8NTH board
 // #define ARDUINO_DUE_NTH
 
-// To use wider C4FSK filters for DMR, System Fusion and P25 on transmit
-// #define WIDE_C4FSK_FILTERS_TX
-// To use wider C4FSK filters for DMR, System Fusion and P25 on receive
-// #define WIDE_C4FSK_FILTERS_RX
+// For ST Nucleo-64 STM32F446RE board
+// #define STM32F4_NUCLEO_MORPHO_HEADER
+// #define STM32F4_NUCLEO_ARDUINO_HEADER
+
+// Use separate mode pins to switch external channel/filters/bandwidth for example
+// #define MODE_PINS
+
+// For the VK6MST Pi3 Shield communicating over i2c. i2c address & speed defined in i2cTeensy.cpp
+// #define VK6MST_TEENSY_PI3_SHIELD_I2C
 
 // Pass RSSI information to the host
 // #define SEND_RSSI_DATA
@@ -61,5 +76,20 @@
 // Use the modem as a serial repeater for Nextion displays
 // #define SERIAL_REPEATER
 
-#endif
+// To reduce CPU load, you can remove the DC blocker by commenting out the next line
+#define USE_DCBLOCKER
 
+// Constant Service LED once repeater is running 
+// Do not use if employing an external hardware watchdog 
+// #define CONSTANT_SRV_LED
+
+// Use the YSF and P25 LEDs for NXDN
+// #define USE_ALTERNATE_NXDN_LEDS
+
+// Use the D-Star and DMR LEDs for POCSAG
+// #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-2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2017 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,8 +16,6 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#define  WANT_DEBUG
-
 #include "Config.h"
 #include "Globals.h"
 #include "DMRDMORX.h"
@@ -59,8 +57,7 @@ m_colorCode(0U),
 m_state(DMORXS_NONE),
 m_n(0U),
 m_type(0U),
-m_rssiCount(0U),
-m_rssi(0U)
+m_rssi()
 {
 }
 
@@ -73,7 +70,6 @@ void CDMRDMORX::reset()
   m_state     = DMORXS_NONE;
   m_startPtr  = 0U;
   m_endPtr    = NOENDPTR;
-  m_rssiCount = 0U;
 }
 
 void CDMRDMORX::samples(const q15_t* samples, const uint16_t* rssi, uint8_t length)
@@ -89,6 +85,7 @@ void CDMRDMORX::samples(const q15_t* samples, const uint16_t* rssi, uint8_t leng
 bool CDMRDMORX::processSample(q15_t sample, uint16_t rssi)
 {
   m_buffer[m_dataPtr] = sample;
+  m_rssi[m_dataPtr] = rssi;
 
   m_bitBuffer[m_bitPtr] <<= 1;
   if (sample < 0)
@@ -97,9 +94,6 @@ bool CDMRDMORX::processSample(q15_t sample, uint16_t rssi)
   if (m_state == DMORXS_NONE) {
     correlateSync(true);
   } else {
-    // Grab the RSSI data during the frame
-    if (m_state == DMORXS_VOICE && m_dataPtr == m_syncPtr)
-      m_rssi = rssi;
 
     uint16_t min  = m_syncPtr + DMO_BUFFER_LENGTH_SAMPLES - 1U;
     uint16_t max  = m_syncPtr + 1U;
@@ -148,7 +142,7 @@ bool CDMRDMORX::processSample(q15_t sample, uint16_t rssi)
         switch (dataType) {
           case DT_DATA_HEADER:
             DEBUG4("DMRDMORX: data header found pos/centre/threshold", m_syncPtr, centre, threshold);
-            serial.writeDMRData(true, frame, DMR_FRAME_LENGTH_BYTES + 1U);
+            writeRSSIData(frame);
             m_state = DMORXS_DATA;
             m_type  = 0x00U;
             break;
@@ -157,32 +151,32 @@ bool CDMRDMORX::processSample(q15_t sample, uint16_t rssi)
           case DT_RATE_1_DATA:
             if (m_state == DMORXS_DATA) {
               DEBUG4("DMRDMORX: data payload found pos/centre/threshold", m_syncPtr, centre, threshold);
-              serial.writeDMRData(true, frame, DMR_FRAME_LENGTH_BYTES + 1U);
+              writeRSSIData(frame);
               m_type = dataType;
             }
             break;
           case DT_VOICE_LC_HEADER:
             DEBUG4("DMRDMORX: voice header found pos/centre/threshold", m_syncPtr, centre, threshold);
-            serial.writeDMRData(true, frame, DMR_FRAME_LENGTH_BYTES + 1U);
+            writeRSSIData(frame);
             m_state = DMORXS_VOICE;
             break;
           case DT_VOICE_PI_HEADER:
             if (m_state == DMORXS_VOICE) {
               DEBUG4("DMRDMORX: voice pi header found pos/centre/threshold", m_syncPtr, centre, threshold);
-              serial.writeDMRData(true, frame, DMR_FRAME_LENGTH_BYTES + 1U);
+              writeRSSIData(frame);
             }
             m_state = DMORXS_VOICE;
             break;
           case DT_TERMINATOR_WITH_LC:
             if (m_state == DMORXS_VOICE) {
               DEBUG4("DMRDMORX: voice terminator found pos/centre/threshold", m_syncPtr, centre, threshold);
-              serial.writeDMRData(true, frame, DMR_FRAME_LENGTH_BYTES + 1U);
+              writeRSSIData(frame);
               reset();
             }
             break;
           default:    // DT_CSBK
             DEBUG4("DMRDMORX: csbk found pos/centre/threshold", m_syncPtr, centre, threshold);
-            serial.writeDMRData(true, frame, DMR_FRAME_LENGTH_BYTES + 1U);
+            writeRSSIData(frame);
             reset();
             break;
         }
@@ -190,22 +184,7 @@ bool CDMRDMORX::processSample(q15_t sample, uint16_t rssi)
     } else if (m_control == CONTROL_VOICE) {
       // Voice sync
       DEBUG4("DMRDMORX: voice sync found pos/centre/threshold", m_syncPtr, centre, threshold);
-#if defined(SEND_RSSI_DATA)
-      // Send RSSI data approximately every second
-      if (m_rssiCount == 2U) {
-        frame[34U] = (m_rssi >> 8) & 0xFFU;
-        frame[35U] = (m_rssi >> 0) & 0xFFU;
-        serial.writeDMRData(true, frame, DMR_FRAME_LENGTH_BYTES + 3U);
-      } else {
-        serial.writeDMRData(true, frame, DMR_FRAME_LENGTH_BYTES + 1U);
-      }
-
-      m_rssiCount++;
-      if (m_rssiCount >= 16U)
-        m_rssiCount = 0U;
-#else
-      serial.writeDMRData(true, frame, DMR_FRAME_LENGTH_BYTES + 1U);
-#endif
+	    writeRSSIData(frame);
       m_state     = DMORXS_VOICE;
       m_syncCount = 0U;
       m_n         = 0U;
@@ -225,26 +204,12 @@ bool CDMRDMORX::processSample(q15_t sample, uint16_t rssi)
         } else {
           frame[0U] = ++m_n;
         }
-#if defined(SEND_RSSI_DATA)
-        // Send RSSI data approximately every second
-        if (m_rssiCount == 2U) {
-          frame[34U] = (m_rssi >> 8) & 0xFFU;
-          frame[35U] = (m_rssi >> 0) & 0xFFU;
-          serial.writeDMRData(true, frame, DMR_FRAME_LENGTH_BYTES + 3U);
-        } else {
-          serial.writeDMRData(true, frame, DMR_FRAME_LENGTH_BYTES + 1U);
-        }
 
-        m_rssiCount++;
-        if (m_rssiCount >= 16U)
-          m_rssiCount = 0U;
-#else
         serial.writeDMRData(true, frame, DMR_FRAME_LENGTH_BYTES + 1U);
-#endif
       } else if (m_state == DMORXS_DATA) {
         if (m_type != 0x00U) {
           frame[0U] = CONTROL_DATA | m_type;
-          serial.writeDMRData(true, frame, DMR_FRAME_LENGTH_BYTES + 1U);
+          writeRSSIData(frame);
         }
       }
     }
@@ -267,16 +232,13 @@ bool CDMRDMORX::processSample(q15_t sample, uint16_t rssi)
 
 void CDMRDMORX::correlateSync(bool first)
 {
-  uint8_t errs1 = countBits32((m_bitBuffer[m_bitPtr] & DMR_SYNC_SYMBOLS_MASK) ^ DMR_S2_DATA_SYNC_SYMBOLS);
-  uint8_t errs2 = countBits32((m_bitBuffer[m_bitPtr] & DMR_SYNC_SYMBOLS_MASK) ^ DMR_MS_DATA_SYNC_SYMBOLS);
+  uint8_t errs = countBits32((m_bitBuffer[m_bitPtr] & DMR_SYNC_SYMBOLS_MASK) ^ DMR_MS_DATA_SYNC_SYMBOLS);
 
   // The voice sync is the complement of the data sync
-  bool data1  = (errs1 <= MAX_SYNC_SYMBOLS_ERRS);
-  bool data2  = (errs2 <= MAX_SYNC_SYMBOLS_ERRS);
-  bool voice1 = (errs1 >= (DMR_SYNC_LENGTH_SYMBOLS - MAX_SYNC_SYMBOLS_ERRS));
-  bool voice2 = (errs2 >= (DMR_SYNC_LENGTH_SYMBOLS - MAX_SYNC_SYMBOLS_ERRS));
+  bool data  = (errs <= MAX_SYNC_SYMBOLS_ERRS);
+  bool voice = (errs >= (DMR_SYNC_LENGTH_SYMBOLS - MAX_SYNC_SYMBOLS_ERRS));
 
-  if (data1 || data2 || voice1 || voice2) {
+  if (data || voice) {
     uint16_t ptr = m_dataPtr + DMO_BUFFER_LENGTH_SAMPLES - DMR_SYNC_LENGTH_SAMPLES + DMR_RADIO_SYMBOL_LENGTH;
     if (ptr >= DMO_BUFFER_LENGTH_SAMPLES)
       ptr -= DMO_BUFFER_LENGTH_SAMPLES;
@@ -285,23 +247,34 @@ void CDMRDMORX::correlateSync(bool first)
     q15_t min =  16000;
     q15_t max = -16000;
 
-    uint32_t mask = 0x00800000U;
-    for (uint8_t i = 0U; i < DMR_SYNC_LENGTH_SYMBOLS; i++, mask >>= 1) {
-      bool b;
-      if (data1 || voice1)
-        b = (DMR_S2_DATA_SYNC_SYMBOLS & mask) == mask;
+    for (uint8_t i = 0U; i < DMR_SYNC_LENGTH_SYMBOLS; i++) {
+      q15_t val = m_buffer[ptr];
+
+      if (val > max)
+        max = val;
+      if (val < min)
+        min = val;
+
+      int8_t corrVal;
+      if (data)
+        corrVal = DMR_MS_DATA_SYNC_SYMBOLS_VALUES[i];
       else
-        b = (DMR_MS_DATA_SYNC_SYMBOLS & mask) == mask;
+        corrVal = DMR_MS_VOICE_SYNC_SYMBOLS_VALUES[i];
 
-      if (m_buffer[ptr] > max)
-        max = m_buffer[ptr];
-      if (m_buffer[ptr] < min)
-        min = m_buffer[ptr];
-
-      if (data1 || data2)
-        corr += b ? -m_buffer[ptr] : m_buffer[ptr];
-      else  // if (voice)
-        corr += b ? m_buffer[ptr] : -m_buffer[ptr];
+      switch (corrVal) {
+      case +3:
+        corr -= (val + val + val);
+        break;
+      case +1:
+        corr -= val;
+        break;
+      case -1:
+        corr += val;
+        break;
+      default:  // -3
+        corr += (val + val + val);
+        break;
+      }
 
       ptr += DMR_RADIO_SYMBOL_LENGTH;
       if (ptr >= DMO_BUFFER_LENGTH_SAMPLES)
@@ -321,21 +294,16 @@ void CDMRDMORX::correlateSync(bool first)
 
       samplesToBits(ptr, DMR_SYNC_LENGTH_SYMBOLS, sync, 4U, centre, threshold);
 
-      if (data1 || data2) {
+      if (data) {
         uint8_t errs = 0U;
-        for (uint8_t i = 0U; i < DMR_SYNC_BYTES_LENGTH; i++) {
-          if (data1)
-            errs += countBits8((sync[i] & DMR_SYNC_BYTES_MASK[i]) ^ DMR_S2_DATA_SYNC_BYTES[i]);
-          else
-            errs += countBits8((sync[i] & DMR_SYNC_BYTES_MASK[i]) ^ DMR_MS_DATA_SYNC_BYTES[i]);
-        }
-
+        for (uint8_t i = 0U; i < DMR_SYNC_BYTES_LENGTH; i++)
+          errs += countBits8((sync[i] & DMR_SYNC_BYTES_MASK[i]) ^ DMR_MS_DATA_SYNC_BYTES[i]);
+ 
         if (errs <= MAX_SYNC_BYTES_ERRS) {
           if (first) {
             m_threshold[0U] = m_threshold[1U] = m_threshold[2U] = m_threshold[3U] = threshold;
             m_centre[0U]    = m_centre[1U]    = m_centre[2U]    = m_centre[3U]    = centre;
             m_averagePtr    = 0U;
-            m_rssiCount     = 0U;
           } else {
             m_threshold[m_averagePtr] = threshold;
             m_centre[m_averagePtr]    = centre;
@@ -359,19 +327,14 @@ void CDMRDMORX::correlateSync(bool first)
         }
       } else {  // if (voice1 || voice2)
         uint8_t errs = 0U;
-        for (uint8_t i = 0U; i < DMR_SYNC_BYTES_LENGTH; i++) {
-          if (voice1)
-            errs += countBits8((sync[i] & DMR_SYNC_BYTES_MASK[i]) ^ DMR_S2_VOICE_SYNC_BYTES[i]);
-          else
-            errs += countBits8((sync[i] & DMR_SYNC_BYTES_MASK[i]) ^ DMR_MS_VOICE_SYNC_BYTES[i]);
-        }
+        for (uint8_t i = 0U; i < DMR_SYNC_BYTES_LENGTH; i++)
+          errs += countBits8((sync[i] & DMR_SYNC_BYTES_MASK[i]) ^ DMR_MS_VOICE_SYNC_BYTES[i]);
 
         if (errs <= MAX_SYNC_BYTES_ERRS) {
           if (first) {
             m_threshold[0U] = m_threshold[1U] = m_threshold[2U] = m_threshold[3U] = threshold;
             m_centre[0U]    = m_centre[1U]    = m_centre[2U]    = m_centre[3U]    = centre;
             m_averagePtr    = 0U;
-            m_rssiCount     = 0U;
           } else {
             m_threshold[m_averagePtr] = threshold;
             m_centre[m_averagePtr]    = centre;
@@ -436,3 +399,27 @@ void CDMRDMORX::setColorCode(uint8_t colorCode)
   m_colorCode = colorCode;
 }
 
+void CDMRDMORX::writeRSSIData(uint8_t* frame)
+{
+#if defined(SEND_RSSI_DATA)
+  // Calculate RSSI average over a burst period. We don't take into account 2.5 ms at the beginning and 2.5 ms at the end
+  uint16_t start = m_startPtr + DMR_SYNC_LENGTH_SAMPLES / 2U;
+
+  uint32_t accum = 0U;
+  for (uint16_t i = 0U; i < (DMR_FRAME_LENGTH_SAMPLES - DMR_SYNC_LENGTH_SAMPLES); i++) {
+    accum += m_rssi[start];
+	
+	start++;
+    if (start >= DMO_BUFFER_LENGTH_SAMPLES)
+      start -= DMO_BUFFER_LENGTH_SAMPLES;
+  }
+
+  uint16_t avg = accum / (DMR_FRAME_LENGTH_SAMPLES - DMR_SYNC_LENGTH_SAMPLES);
+  frame[34U] = (avg >> 8) & 0xFFU;
+  frame[35U] = (avg >> 0) & 0xFFU;
+
+  serial.writeDMRData(true, frame, DMR_FRAME_LENGTH_BYTES + 3U);
+#else
+  serial.writeDMRData(true, frame, DMR_FRAME_LENGTH_BYTES + 1U);
+#endif
+}

DMRDMORX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017 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
@@ -58,13 +58,12 @@ private:
   DMORX_STATE m_state;
   uint8_t     m_n;
   uint8_t     m_type;
-  uint16_t    m_rssiCount;
-  uint16_t    m_rssi;
-
+  uint16_t    m_rssi[DMO_BUFFER_LENGTH_SAMPLES];
+  
   bool processSample(q15_t sample, uint16_t rssi);
   void correlateSync(bool first);
   void samplesToBits(uint16_t start, uint8_t count, uint8_t* buffer, uint16_t offset, q15_t centre, q15_t threshold);
+  void writeRSSIData(uint8_t* frame);
 };
 
 #endif
-

DMRDMOTX.cpp

@@ -1,6 +1,7 @@
 /*
- *   Copyright (C) 2009-2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2017 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
+ *   Copyright (C) 2017 by Andy Uribe CA6JAU
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -17,30 +18,34 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-// #define WANT_DEBUG
-
 #include "Config.h"
 #include "Globals.h"
 #include "DMRSlotType.h"
 
-#if defined(WIDE_C4FSK_FILTERS_TX)
-// Generated using rcosdesign(0.2, 4, 5, 'sqrt') in MATLAB
-static q15_t DMR_C4FSK_FILTER[] = {688, -680, -2158, -3060, -2724, -775, 2684, 7041, 11310, 14425, 15565, 14425,
-                                   11310, 7041, 2684, -775, -2724, -3060, -2158, -680, 688, 0};
-const uint16_t DMR_C4FSK_FILTER_LEN = 22U;
-#else
 // Generated using rcosdesign(0.2, 8, 5, 'sqrt') in MATLAB
-static q15_t DMR_C4FSK_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 DMR_C4FSK_FILTER_LEN = 42U;
-#endif
+static q15_t RRC_0_2_FILTER[] = {0, 0, 0, 0, 850, 219, -720, -1548, -1795, -1172, 237, 1927, 3120, 3073, 1447, -1431, -4544, -6442,
+                                 -5735, -1633, 5651, 14822, 23810, 30367, 32767, 30367, 23810, 14822, 5651, -1633, -5735, -6442,
+                                 -4544, -1431, 1447, 3073, 3120, 1927, 237, -1172, -1795, -1548, -720, 219, 850}; // numTaps = 45, L = 5
+const uint16_t RRC_0_2_FILTER_PHASE_LEN = 9U; // phaseLength = numTaps/L
 
-const q15_t DMR_LEVELA[] = { 640,  640 , 640,  640,  640};
-const q15_t DMR_LEVELB[] = { 213,  213,  213,  213,  213};
-const q15_t DMR_LEVELC[] = {-213, -213, -213, -213, -213};
-const q15_t DMR_LEVELD[] = {-640, -640, -640, -640, -640};
+const q15_t DMR_LEVELA =  1362;
+const q15_t DMR_LEVELB =  454;
+const q15_t DMR_LEVELC = -454;
+const q15_t DMR_LEVELD = -1362;
 
+const uint8_t BIT_MASK_TABLE[] = {0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02U, 0x01U};
+
+#define WRITE_BIT1(p,i,b) p[(i)>>3] = (b) ? (p[(i)>>3] | BIT_MASK_TABLE[(i)&7]) : (p[(i)>>3] & ~BIT_MASK_TABLE[(i)&7])
+#define READ_BIT1(p,i)    (p[(i)>>3] & BIT_MASK_TABLE[(i)&7])
+
+// PR FILL pattern
+const uint8_t PR_FILL[] =
+        {0x63U, 0xEAU, 0x00U, 0x76U, 0x6CU, 0x76U, 0xC4U, 0x52U, 0xC8U, 0x78U,
+         0x09U, 0x2DU, 0xB8U, 0x79U, 0x27U, 0x57U, 0x9BU, 0x31U, 0xBCU, 0x3EU,
+         0xEAU, 0x45U, 0xC3U, 0x30U, 0x49U, 0x17U, 0x93U, 0xAEU, 0x8BU, 0x6DU,
+         0xA4U, 0xA5U, 0xADU, 0xA2U, 0xF1U, 0x35U, 0xB5U, 0x3CU, 0x1EU};
+
+const uint8_t DMR_SYNC = 0x5FU;
 
 CDMRDMOTX::CDMRDMOTX() :
 m_fifo(),
@@ -49,14 +54,14 @@ m_modState(),
 m_poBuffer(),
 m_poLen(0U),
 m_poPtr(0U),
-m_txDelay(240U),      // 200ms
-m_count(0U)
+m_txDelay(240U)       // 200ms
 {
-  ::memset(m_modState, 0x00U, 70U * sizeof(q15_t));
+  ::memset(m_modState, 0x00U, 16U * sizeof(q15_t));
 
-  m_modFilter.numTaps = DMR_C4FSK_FILTER_LEN;
-  m_modFilter.pState  = m_modState;
-  m_modFilter.pCoeffs = DMR_C4FSK_FILTER;
+  m_modFilter.L           = DMR_RADIO_SYMBOL_LENGTH;
+  m_modFilter.phaseLength = RRC_0_2_FILTER_PHASE_LEN;
+  m_modFilter.pCoeffs     = RRC_0_2_FILTER;
+  m_modFilter.pState      = m_modState;
 }
 
 void CDMRDMOTX::process()
@@ -64,13 +69,17 @@ void CDMRDMOTX::process()
   if (m_poLen == 0U && m_fifo.getData() > 0U) {
     if (!m_tx) {
       for (uint16_t i = 0U; i < m_txDelay; i++)
-        m_poBuffer[m_poLen++] = 0x00U;
-    } else {
-      for (unsigned int i = 0U; i < 72U; i++)
-        m_poBuffer[m_poLen++] = 0x00U;
+        m_poBuffer[i] = DMR_SYNC;
 
+      m_poLen = m_txDelay;
+    } else {
       for (unsigned int i = 0U; i < DMR_FRAME_LENGTH_BYTES; i++)
-        m_poBuffer[i] = m_fifo.get();
+        m_fifo.get(m_poBuffer[i]);
+
+      for (unsigned int i = 0U; i < 39U; i++)
+        m_poBuffer[i + DMR_FRAME_LENGTH_BYTES] = PR_FILL[i];
+
+      m_poLen = 72U;
     }
 
     m_poPtr = 0U;
@@ -112,53 +121,34 @@ uint8_t CDMRDMOTX::writeData(const uint8_t* data, uint8_t length)
 
 void CDMRDMOTX::writeByte(uint8_t c)
 {
-  q15_t inBuffer[DMR_RADIO_SYMBOL_LENGTH * 4U + 1U];
-  q15_t outBuffer[DMR_RADIO_SYMBOL_LENGTH * 4U + 1U];
+  q15_t inBuffer[4U];
+  q15_t outBuffer[DMR_RADIO_SYMBOL_LENGTH * 4U];
 
   const uint8_t MASK = 0xC0U;
 
-  q15_t* p = inBuffer;
-  for (uint8_t i = 0U; i < 4U; i++, c <<= 2, p += DMR_RADIO_SYMBOL_LENGTH) {
+  for (uint8_t i = 0U; i < 4U; i++, c <<= 2) {
     switch (c & MASK) {
       case 0xC0U:
-        ::memcpy(p, DMR_LEVELA, DMR_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
+        inBuffer[i] = DMR_LEVELA;
         break;
       case 0x80U:
-        ::memcpy(p, DMR_LEVELB, DMR_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
+        inBuffer[i] = DMR_LEVELB;
         break;
       case 0x00U:
-        ::memcpy(p, DMR_LEVELC, DMR_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
+        inBuffer[i] = DMR_LEVELC;
         break;
       default:
-        ::memcpy(p, DMR_LEVELD, DMR_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
+        inBuffer[i] = DMR_LEVELD;
         break;
     }
   }
 
-  uint16_t blockSize = DMR_RADIO_SYMBOL_LENGTH * 4U;
+  ::arm_fir_interpolate_q15(&m_modFilter, inBuffer, outBuffer, 4U);
 
-  // Handle the case of the oscillator not being accurate enough
-  if (m_sampleCount > 0U) {
-    m_count += DMR_RADIO_SYMBOL_LENGTH * 4U;
-
-    if (m_count >= m_sampleCount) {
-      if (m_sampleInsert) {
-        inBuffer[DMR_RADIO_SYMBOL_LENGTH * 4U] = inBuffer[DMR_RADIO_SYMBOL_LENGTH * 4U - 1U];
-        blockSize++;
-      } else {
-        blockSize--;
-      }
-
-      m_count -= m_sampleCount;
-    }
-  }
-
-  ::arm_fir_fast_q15(&m_modFilter, inBuffer, outBuffer, blockSize);
-
-  io.write(STATE_DMR, outBuffer, blockSize);
+  io.write(STATE_DMR, outBuffer, DMR_RADIO_SYMBOL_LENGTH * 4U);
 }
 
-uint16_t CDMRDMOTX::getSpace() const
+uint8_t CDMRDMOTX::getSpace() const
 {
   return m_fifo.getSpace() / (DMR_FRAME_LENGTH_BYTES + 2U);
 }
@@ -166,5 +156,8 @@ uint16_t CDMRDMOTX::getSpace() const
 void CDMRDMOTX::setTXDelay(uint8_t delay)
 {
   m_txDelay = 600U + uint16_t(delay) * 12U;        // 500ms + tx delay
+
+  if (m_txDelay > 1200U)
+    m_txDelay = 1200U;
 }
 

DMRDMOTX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -23,7 +23,7 @@
 #include "Config.h"
 #include "DMRDefines.h"
 
-#include "SerialRB.h"
+#include "RingBuffer.h"
 
 class CDMRDMOTX {
 public:
@@ -35,17 +35,16 @@ public:
 
   void setTXDelay(uint8_t delay);
 
-  uint16_t getSpace() const;
+  uint8_t getSpace() const;
 
 private:
-  CSerialRB            m_fifo;
-  arm_fir_instance_q15 m_modFilter;
-  q15_t                m_modState[70U];    // NoTaps + BlockSize - 1, 42 + 20 - 1 plus some spare
-  uint8_t              m_poBuffer[80U];
-  uint16_t             m_poLen;
-  uint16_t             m_poPtr;
-  uint16_t             m_txDelay;
-  uint32_t             m_count;
+  CRingBuffer<uint8_t>                        m_fifo;
+  arm_fir_interpolate_instance_q15 m_modFilter;
+  q15_t                            m_modState[16U];    // blockSize + phaseLength - 1, 4 + 9 - 1 plus some spare
+  uint8_t                          m_poBuffer[1200U];
+  uint16_t                         m_poLen;
+  uint16_t                         m_poPtr;
+  uint32_t                         m_txDelay;
 
   void writeByte(uint8_t c);
 };

DMRDefines.h

@@ -61,32 +61,32 @@ const uint8_t  DMR_MS_DATA_SYNC_BYTES[]  = {0x0DU, 0x5DU, 0x7FU, 0x77U, 0xFDU, 0
 const uint8_t  DMR_MS_VOICE_SYNC_BYTES[] = {0x07U, 0xF7U, 0xD5U, 0xDDU, 0x57U, 0xDFU, 0xD0U};
 const uint8_t  DMR_BS_DATA_SYNC_BYTES[]  = {0x0DU, 0xFFU, 0x57U, 0xD7U, 0x5DU, 0xF5U, 0xD0U};
 const uint8_t  DMR_BS_VOICE_SYNC_BYTES[] = {0x07U, 0x55U, 0xFDU, 0x7DU, 0xF7U, 0x5FU, 0x70U};
-const uint8_t  DMR_S1_DATA_SYNC_BYTES[]  = {0x0FU, 0x7FU, 0xDDU, 0x5DU, 0xDFU, 0xD5U, 0x50U};
-const uint8_t  DMR_S1_VOICE_SYNC_BYTES[] = {0x05U, 0xD5U, 0x77U, 0xF7U, 0x75U, 0x7FU, 0xF0U};
-const uint8_t  DMR_S2_DATA_SYNC_BYTES[]  = {0x0DU, 0x75U, 0x57U, 0xF5U, 0xFFU, 0x7FU, 0x50U};
-const uint8_t  DMR_S2_VOICE_SYNC_BYTES[] = {0x07U, 0xDFU, 0xFDU, 0x5FU, 0x55U, 0xD5U, 0xF0U};
 const uint8_t  DMR_SYNC_BYTES_MASK[]     = {0x0FU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xF0U};
 
 const uint64_t DMR_MS_DATA_SYNC_BITS  = 0x0000D5D7F77FD757U;
 const uint64_t DMR_MS_VOICE_SYNC_BITS = 0x00007F7D5DD57DFDU;
 const uint64_t DMR_BS_DATA_SYNC_BITS  = 0x0000DFF57D75DF5DU;
 const uint64_t DMR_BS_VOICE_SYNC_BITS = 0x0000755FD7DF75F7U;
-const uint64_t DMR_S1_DATA_SYNC_BITS  = 0x0000F7FDD5DDFD55U;
-const uint64_t DMR_S1_VOICE_SYNC_BITS = 0x00005D577F7757FFU;
-const uint64_t DMR_S2_DATA_SYNC_BITS  = 0x0000D7557F5FF7F5U;
-const uint64_t DMR_S2_VOICE_SYNC_BITS = 0x00007DFFD5F55D5FU;
 const uint64_t DMR_SYNC_BITS_MASK     = 0x0000FFFFFFFFFFFFU;
 
 const uint32_t DMR_MS_DATA_SYNC_SYMBOLS  = 0x0076286EU;
 const uint32_t DMR_MS_VOICE_SYNC_SYMBOLS = 0x0089D791U;
 const uint32_t DMR_BS_DATA_SYNC_SYMBOLS  = 0x00439B4DU;
 const uint32_t DMR_BS_VOICE_SYNC_SYMBOLS = 0x00BC64B2U;
-const uint32_t DMR_S1_DATA_SYNC_SYMBOLS  = 0x0021751FU;
-const uint32_t DMR_S1_VOICE_SYNC_SYMBOLS = 0x00DE8AE0U;
-const uint32_t DMR_S2_DATA_SYNC_SYMBOLS  = 0x006F8C23U;
-const uint32_t DMR_S2_VOICE_SYNC_SYMBOLS = 0x009073DCU;
 const uint32_t DMR_SYNC_SYMBOLS_MASK     = 0x00FFFFFFU;
 
+// D     5      D     7      F     7      7     F      D     7      5     7
+// 11 01 01 01  11 01 01 11  11 11 01 11  01 11 11 11  11 01 01 11  01 01 01 11
+// -3 +3 +3 +3  -3 +3 +3 -3  -3 -3 +3 -3  +3 -3 -3 -3  -3 +3 +3 -3  +3 +3 +3 -3
+
+const int8_t DMR_MS_DATA_SYNC_SYMBOLS_VALUES[] = {-3, +3, +3, +3, -3, +3, +3, -3, -3, -3, +3, -3, +3, -3, -3, -3, -3, +3, +3, -3, +3, +3, +3, -3};
+
+// 7     F      7     D      5     D      D     5      7     D      F     D
+// 01 11 11 11  01 11 11 01  01 01 11 01  11 01 01 01  01 11 11 01  11 11 11 01
+// +3 -3 -3 -3  +3 -3 -3 +3  +3 +3 -3 +3  -3 +3 +3 +3  +3 -3 -3 +3  -3 -3 -3 +3
+
+const int8_t DMR_MS_VOICE_SYNC_SYMBOLS_VALUES[] = {+3, -3, -3, -3, +3, -3, -3, +3, +3, +3, -3, +3, -3, +3, +3, +3, +3, -3, -3, +3, -3, -3, -3, +3};
+
 const uint8_t DT_VOICE_PI_HEADER    = 0U;
 const uint8_t DT_VOICE_LC_HEADER    = 1U;
 const uint8_t DT_TERMINATOR_WITH_LC = 2U;

DMRIdleRX.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2017 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,8 +16,6 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#define  WANT_DEBUG
-
 #include "Config.h"
 #include "Globals.h"
 #include "DMRIdleRX.h"
@@ -84,16 +82,28 @@ void CDMRIdleRX::processSample(q15_t sample)
     q15_t max = -16000;
     q15_t min =  16000;
 
-    uint32_t mask = 0x00800000U;
-    for (uint8_t i = 0U; i < DMR_SYNC_LENGTH_SYMBOLS; i++, mask >>= 1) {
-      bool b = (DMR_MS_DATA_SYNC_SYMBOLS & mask) == mask;
+    for (uint8_t i = 0U; i < DMR_SYNC_LENGTH_SYMBOLS; i++) {
+      q15_t val = m_buffer[ptr];
 
-      if (m_buffer[ptr] > max)
-        max = m_buffer[ptr];
-      if (m_buffer[ptr] < min)
-        min = m_buffer[ptr];
+      if (val > max)
+        max = val;
+      if (val < min)
+        min = val;
 
-      corr += b ? -m_buffer[ptr] : m_buffer[ptr];
+      switch (DMR_MS_DATA_SYNC_SYMBOLS_VALUES[i]) {
+      case +3:
+        corr -= (val + val + val);
+        break;
+      case +1:
+        corr -= val;
+        break;
+      case -1:
+        corr += val;
+        break;
+      default:  // -3
+        corr += (val + val + val);
+        break;
+      }
 
       ptr += DMR_RADIO_SYMBOL_LENGTH;
       if (ptr >= DMR_FRAME_LENGTH_SAMPLES)
@@ -150,7 +160,7 @@ void CDMRIdleRX::processSample(q15_t sample)
     }
 
     m_endPtr  = NOENDPTR;
-    m_maxCorr = 0U;
+    m_maxCorr = 0;
   }
 
   m_dataPtr++;
@@ -199,4 +209,3 @@ void CDMRIdleRX::setColorCode(uint8_t colorCode)
 {
   m_colorCode = colorCode;
 }
-

DMRIdleRX.h

@@ -43,8 +43,8 @@ private:
   q15_t    m_threshold;
   uint8_t  m_colorCode;
 
-  void    processSample(q15_t sample);
-  void    samplesToBits(uint16_t start, uint8_t count, uint8_t* buffer, uint16_t offset, q15_t centre, q15_t threshold);
+  void processSample(q15_t sample);
+  void samplesToBits(uint16_t start, uint8_t count, uint8_t* buffer, uint16_t offset, q15_t centre, q15_t threshold);
 };
 
 #endif

DMRSlotRX.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2017 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,8 +16,6 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#define  WANT_DEBUG
-
 #include "Config.h"
 #include "Globals.h"
 #include "DMRSlotRX.h"
@@ -65,8 +63,7 @@ m_delay(0U),
 m_state(DMRRXS_NONE),
 m_n(0U),
 m_type(0U),
-m_rssiCount(0U),
-m_rssi(0U)
+m_rssi()
 {
 }
 
@@ -91,7 +88,6 @@ void CDMRSlotRX::reset()
   m_state     = DMRRXS_NONE;
   m_startPtr  = 0U;
   m_endPtr    = NOENDPTR;
-  m_rssiCount = 0U;
 }
 
 bool CDMRSlotRX::processSample(q15_t sample, uint16_t rssi)
@@ -105,7 +101,8 @@ bool CDMRSlotRX::processSample(q15_t sample, uint16_t rssi)
     return m_state != DMRRXS_NONE;
 
   m_buffer[m_dataPtr] = sample;
-
+  m_rssi[m_dataPtr] = rssi;
+  
   m_bitBuffer[m_bitPtr] <<= 1;
   if (sample < 0)
     m_bitBuffer[m_bitPtr] |= 0x01U;
@@ -114,9 +111,6 @@ bool CDMRSlotRX::processSample(q15_t sample, uint16_t rssi)
     if (m_dataPtr >= SCAN_START && m_dataPtr <= SCAN_END)
       correlateSync(true);
   } else {
-    // Grab the RSSI data during the frame
-    if (m_state == DMRRXS_VOICE && m_dataPtr == m_syncPtr)
-      m_rssi = rssi;
 
     uint16_t min = m_syncPtr - 1U;
     uint16_t max = m_syncPtr + 1U;
@@ -151,7 +145,7 @@ bool CDMRSlotRX::processSample(q15_t sample, uint16_t rssi)
         switch (dataType) {
           case DT_DATA_HEADER:
             DEBUG5("DMRSlotRX: data header found slot/pos/centre/threshold", m_slot ? 2U : 1U, m_syncPtr, centre, threshold);
-            serial.writeDMRData(m_slot, frame, DMR_FRAME_LENGTH_BYTES + 1U);
+            writeRSSIData(frame);
             m_state = DMRRXS_DATA;
             m_type  = 0x00U;
             break;
@@ -160,33 +154,33 @@ bool CDMRSlotRX::processSample(q15_t sample, uint16_t rssi)
           case DT_RATE_1_DATA:
             if (m_state == DMRRXS_DATA) {
               DEBUG5("DMRSlotRX: data payload found slot/pos/centre/threshold", m_slot ? 2U : 1U, m_syncPtr, centre, threshold);
-              serial.writeDMRData(m_slot, frame, DMR_FRAME_LENGTH_BYTES + 1U);
+              writeRSSIData(frame);
               m_type = dataType;
             }
             break;
           case DT_VOICE_LC_HEADER:
             DEBUG5("DMRSlotRX: voice header found slot/pos/centre/threshold", m_slot ? 2U : 1U, m_syncPtr, centre, threshold);
-            serial.writeDMRData(m_slot, frame, DMR_FRAME_LENGTH_BYTES + 1U);
+            writeRSSIData(frame);
             m_state = DMRRXS_VOICE;
             break;
           case DT_VOICE_PI_HEADER:
             if (m_state == DMRRXS_VOICE) {
               DEBUG5("DMRSlotRX: voice pi header found slot/pos/centre/threshold", m_slot ? 2U : 1U, m_syncPtr, centre, threshold);
-              serial.writeDMRData(m_slot, frame, DMR_FRAME_LENGTH_BYTES + 1U);
+              writeRSSIData(frame);
             }
             m_state = DMRRXS_VOICE;
             break;
           case DT_TERMINATOR_WITH_LC:
             if (m_state == DMRRXS_VOICE) {
               DEBUG5("DMRSlotRX: voice terminator found slot/pos/centre/threshold", m_slot ? 2U : 1U, m_syncPtr, centre, threshold);
-              serial.writeDMRData(m_slot, frame, DMR_FRAME_LENGTH_BYTES + 1U);
+              writeRSSIData(frame);
               m_state  = DMRRXS_NONE;
               m_endPtr = NOENDPTR;
             }
             break;
           default:    // DT_CSBK
             DEBUG5("DMRSlotRX: csbk found slot/pos/centre/threshold", m_slot ? 2U : 1U, m_syncPtr, centre, threshold);
-            serial.writeDMRData(m_slot, frame, DMR_FRAME_LENGTH_BYTES + 1U);
+            writeRSSIData(frame);
             m_state  = DMRRXS_NONE;
             m_endPtr = NOENDPTR;
             break;
@@ -195,22 +189,7 @@ bool CDMRSlotRX::processSample(q15_t sample, uint16_t rssi)
     } else if (m_control == CONTROL_VOICE) {
       // Voice sync
       DEBUG5("DMRSlotRX: voice sync found slot/pos/centre/threshold", m_slot ? 2U : 1U, m_syncPtr, centre, threshold);
-#if defined(SEND_RSSI_DATA)
-      // Send RSSI data approximately every second
-      if (m_rssiCount == 2U) {
-        frame[34U] = (m_rssi >> 8) & 0xFFU;
-        frame[35U] = (m_rssi >> 0) & 0xFFU;
-        serial.writeDMRData(m_slot, frame, DMR_FRAME_LENGTH_BYTES + 3U);
-      } else {
-        serial.writeDMRData(m_slot, frame, DMR_FRAME_LENGTH_BYTES + 1U);
-      }
-
-      m_rssiCount++;
-      if (m_rssiCount >= 16U)
-        m_rssiCount = 0U;
-#else
-      serial.writeDMRData(m_slot, frame, DMR_FRAME_LENGTH_BYTES + 1U);
-#endif
+      writeRSSIData(frame);
       m_state     = DMRRXS_VOICE;
       m_syncCount = 0U;
       m_n         = 0U;
@@ -231,26 +210,12 @@ bool CDMRSlotRX::processSample(q15_t sample, uint16_t rssi)
         } else {
           frame[0U] = ++m_n;
         }
-#if defined(SEND_RSSI_DATA)
-        // Send RSSI data approximately every second
-        if (m_rssiCount == 2U) {
-          frame[34U] = (m_rssi >> 8) & 0xFFU;
-          frame[35U] = (m_rssi >> 0) & 0xFFU;
-          serial.writeDMRData(m_slot, frame, DMR_FRAME_LENGTH_BYTES + 3U);
-        } else {
-          serial.writeDMRData(m_slot, frame, DMR_FRAME_LENGTH_BYTES + 1U);
-        }
 
-        m_rssiCount++;
-        if (m_rssiCount >= 16U)
-          m_rssiCount = 0U;
-#else
         serial.writeDMRData(m_slot, frame, DMR_FRAME_LENGTH_BYTES + 1U);
-#endif
       } else if (m_state == DMRRXS_DATA) {
         if (m_type != 0x00U) {
           frame[0U] = CONTROL_DATA | m_type;
-          serial.writeDMRData(m_slot, frame, DMR_FRAME_LENGTH_BYTES + 1U);
+          writeRSSIData(frame);
         }
       }
     }
@@ -280,19 +245,34 @@ void CDMRSlotRX::correlateSync(bool first)
     q15_t min =  16000;
     q15_t max = -16000;
 
-    uint32_t mask = 0x00800000U;
-    for (uint8_t i = 0U; i < DMR_SYNC_LENGTH_SYMBOLS; i++, mask >>= 1) {
-      bool b = (DMR_MS_DATA_SYNC_SYMBOLS & mask) == mask;
+    for (uint8_t i = 0U; i < DMR_SYNC_LENGTH_SYMBOLS; i++) {
+      q15_t val = m_buffer[ptr];
 
-      if (m_buffer[ptr] > max)
-        max = m_buffer[ptr];
-      if (m_buffer[ptr] < min)
-        min = m_buffer[ptr];
+      if (val > max)
+        max = val;
+      if (val < min)
+        min = val;
 
+      int8_t corrVal;
       if (data)
-        corr += b ? -m_buffer[ptr] : m_buffer[ptr];
-      else  // if (voice)
-        corr += b ? m_buffer[ptr] : -m_buffer[ptr];
+        corrVal = DMR_MS_DATA_SYNC_SYMBOLS_VALUES[i];
+      else
+        corrVal = DMR_MS_VOICE_SYNC_SYMBOLS_VALUES[i];
+
+      switch (corrVal) {
+      case +3:
+        corr -= (val + val + val);
+        break;
+      case +1:
+        corr -= val;
+        break;
+      case -1:
+        corr += val;
+        break;
+      default:  // -3
+        corr += (val + val + val);
+        break;
+      }
 
       ptr += DMR_RADIO_SYMBOL_LENGTH;
     }
@@ -317,7 +297,6 @@ void CDMRSlotRX::correlateSync(bool first)
             m_threshold[0U] = m_threshold[1U] = m_threshold[2U] = m_threshold[3U] = threshold;
             m_centre[0U]    = m_centre[1U]    = m_centre[2U]    = m_centre[3U]    = centre;
             m_averagePtr    = 0U;
-            m_rssiCount     = 0U;
           } else {
             m_threshold[m_averagePtr] = threshold;
             m_centre[m_averagePtr]    = centre;
@@ -343,7 +322,6 @@ void CDMRSlotRX::correlateSync(bool first)
             m_threshold[0U] = m_threshold[1U] = m_threshold[2U] = m_threshold[3U] = threshold;
             m_centre[0U]    = m_centre[1U]    = m_centre[2U]    = m_centre[3U]    = centre;
             m_averagePtr    = 0U;
-            m_rssiCount     = 0U;
           } else {
             m_threshold[m_averagePtr] = threshold;
             m_centre[m_averagePtr]    = centre;
@@ -403,3 +381,22 @@ void CDMRSlotRX::setDelay(uint8_t delay)
   m_delay = delay;
 }
 
+void CDMRSlotRX::writeRSSIData(uint8_t* frame)
+{
+#if defined(SEND_RSSI_DATA)
+  // Calculate RSSI average over a burst period. We don't take into account 2.5 ms at the beginning and 2.5 ms at the end
+  uint16_t start = m_startPtr + DMR_SYNC_LENGTH_SAMPLES / 2U;
+
+  uint32_t accum = 0U;
+  for (uint16_t i = 0U; i < (DMR_FRAME_LENGTH_SAMPLES - DMR_SYNC_LENGTH_SAMPLES); i++)
+    accum += m_rssi[start++];
+
+  uint16_t avg = accum / (DMR_FRAME_LENGTH_SAMPLES - DMR_SYNC_LENGTH_SAMPLES);
+  frame[34U] = (avg >> 8) & 0xFFU;
+  frame[35U] = (avg >> 0) & 0xFFU;
+
+  serial.writeDMRData(m_slot, frame, DMR_FRAME_LENGTH_BYTES + 3U);
+#else
+  serial.writeDMRData(m_slot, frame, DMR_FRAME_LENGTH_BYTES + 1U);
+#endif
+}

DMRSlotRX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017 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
@@ -62,12 +62,11 @@ private:
   DMRRX_STATE m_state;
   uint8_t     m_n;
   uint8_t     m_type;
-  uint16_t    m_rssiCount;
-  uint16_t    m_rssi;
+  uint16_t    m_rssi[900U];
 
   void correlateSync(bool first);
   void samplesToBits(uint16_t start, uint8_t count, uint8_t* buffer, uint16_t offset, q15_t centre, q15_t threshold);
+  void writeRSSIData(uint8_t* frame);
 };
 
 #endif
-

DMRTX.cpp

@@ -1,6 +1,7 @@
 /*
- *   Copyright (C) 2009-2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2017 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
+ *   Copyright (C) 2017 by Andy Uribe CA6JAU
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -17,31 +18,22 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-// #define WANT_DEBUG
-
 #include "Config.h"
 #include "Globals.h"
 #include "DMRSlotType.h"
 
-#if defined(WIDE_C4FSK_FILTERS_TX)
-// Generated using rcosdesign(0.2, 4, 5, 'sqrt') in MATLAB
-static q15_t DMR_C4FSK_FILTER[] = {688, -680, -2158, -3060, -2724, -775, 2684, 7041, 11310, 14425, 15565, 14425,
-                                   11310, 7041, 2684, -775, -2724, -3060, -2158, -680, 688, 0};
-const uint16_t DMR_C4FSK_FILTER_LEN = 22U;
-#else
 // Generated using rcosdesign(0.2, 8, 5, 'sqrt') in MATLAB
-static q15_t DMR_C4FSK_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 DMR_C4FSK_FILTER_LEN = 42U;
-#endif
+static q15_t RRC_0_2_FILTER[] = {0, 0, 0, 0, 850, 219, -720, -1548, -1795, -1172, 237, 1927, 3120, 3073, 1447, -1431, -4544, -6442,
+                                 -5735, -1633, 5651, 14822, 23810, 30367, 32767, 30367, 23810, 14822, 5651, -1633, -5735, -6442,
+                                 -4544, -1431, 1447, 3073, 3120, 1927, 237, -1172, -1795, -1548, -720, 219, 850}; // numTaps = 45, L = 5
+const uint16_t RRC_0_2_FILTER_PHASE_LEN = 9U; // phaseLength = numTaps/L
 
-const q15_t DMR_LEVELA[] = { 640,  640 , 640,  640,  640};
-const q15_t DMR_LEVELB[] = { 213,  213,  213,  213,  213};
-const q15_t DMR_LEVELC[] = {-213, -213, -213, -213, -213};
-const q15_t DMR_LEVELD[] = {-640, -640, -640, -640, -640};
+const q15_t DMR_LEVELA =  1362;
+const q15_t DMR_LEVELB =  454;
+const q15_t DMR_LEVELC = -454;
+const q15_t DMR_LEVELD = -1362;
 
-// The PR FILL and Data Sync pattern.
+// The PR FILL and BS Data Sync pattern.
 const uint8_t IDLE_DATA[] =
         {0x53U, 0xC2U, 0x5EU, 0xABU, 0xA8U, 0x67U, 0x1DU, 0xC7U, 0x38U, 0x3BU, 0xD9U,
          0x36U, 0x00U, 0x0DU, 0xFFU, 0x57U, 0xD7U, 0x5DU, 0xF5U, 0xD0U, 0x03U, 0xF6U,
@@ -61,6 +53,9 @@ const uint8_t BIT_MASK_TABLE[] = {0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02
 #define WRITE_BIT1(p,i,b) p[(i)>>3] = (b) ? (p[(i)>>3] | BIT_MASK_TABLE[(i)&7]) : (p[(i)>>3] & ~BIT_MASK_TABLE[(i)&7])
 #define READ_BIT1(p,i)    (p[(i)>>3] & BIT_MASK_TABLE[(i)&7])
 
+const uint32_t STARTUP_COUNT = 20U;
+const uint32_t ABORT_COUNT = 6U;
+
 CDMRTX::CDMRTX() :
 m_fifo(),
 m_modFilter(),
@@ -74,20 +69,25 @@ m_markBuffer(),
 m_poBuffer(),
 m_poLen(0U),
 m_poPtr(0U),
-m_count(0U),
+m_frameCount(0U),
+m_abortCount(),
 m_abort()
 {
-  ::memset(m_modState, 0x00U, 70U * sizeof(q15_t));
+  ::memset(m_modState, 0x00U, 16U * sizeof(q15_t));
 
-  m_modFilter.numTaps = DMR_C4FSK_FILTER_LEN;
-  m_modFilter.pState  = m_modState;
-  m_modFilter.pCoeffs = DMR_C4FSK_FILTER;
+  m_modFilter.L           = DMR_RADIO_SYMBOL_LENGTH;
+  m_modFilter.phaseLength = RRC_0_2_FILTER_PHASE_LEN;
+  m_modFilter.pCoeffs     = RRC_0_2_FILTER;
+  m_modFilter.pState      = m_modState;
 
   ::memcpy(m_newShortLC, EMPTY_SHORT_LC, 12U);
   ::memcpy(m_shortLC,    EMPTY_SHORT_LC, 12U);
 
   m_abort[0U] = false;
   m_abort[1U] = false;
+
+  m_abortCount[0U] = 0U;
+  m_abortCount[1U] = 0U;
 }
 
 void CDMRTX::process()
@@ -215,10 +215,12 @@ uint8_t CDMRTX::writeAbort(const uint8_t* data, uint8_t length)
 
   switch (data[0U]) {
     case 1U:
+      m_abortCount[0U] = 0U;
       m_abort[0U] = true;
       return 0U;
 
     case 2U:
+      m_abortCount[1U] = 0U;
       m_abort[1U] = true;
       return 0U;
 
@@ -231,7 +233,9 @@ void CDMRTX::setStart(bool start)
 {
   m_state = start ? DMRTXSTATE_SLOT1 : DMRTXSTATE_IDLE;
 
-  m_count = 0U;
+  m_frameCount = 0U;
+  m_abortCount[0U] = 0U;
+  m_abortCount[1U] = 0U;
 
   m_abort[0U] = false;
   m_abort[1U] = false;
@@ -240,82 +244,56 @@ void CDMRTX::setStart(bool start)
 void CDMRTX::setCal(bool start)
 {
   m_state = start ? DMRTXSTATE_CAL : DMRTXSTATE_IDLE;
-
-  m_count = 0U;
 }
 
 void CDMRTX::writeByte(uint8_t c, uint8_t control)
 {
-  q15_t inBuffer[DMR_RADIO_SYMBOL_LENGTH * 4U + 1U];
-  q15_t outBuffer[DMR_RADIO_SYMBOL_LENGTH * 4U + 1U];
+  q15_t inBuffer[4U];
+  q15_t outBuffer[DMR_RADIO_SYMBOL_LENGTH * 4U];
 
   const uint8_t MASK = 0xC0U;
 
-  q15_t* p = inBuffer;
-  for (uint8_t i = 0U; i < 4U; i++, c <<= 2, p += DMR_RADIO_SYMBOL_LENGTH) {
+  for (uint8_t i = 0U; i < 4U; i++, c <<= 2) {
     switch (c & MASK) {
       case 0xC0U:
-        ::memcpy(p, DMR_LEVELA, DMR_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
+        inBuffer[i] = DMR_LEVELA;
         break;
       case 0x80U:
-        ::memcpy(p, DMR_LEVELB, DMR_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
+        inBuffer[i] = DMR_LEVELB;
         break;
       case 0x00U:
-        ::memcpy(p, DMR_LEVELC, DMR_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
+        inBuffer[i] = DMR_LEVELC;
         break;
       default:
-        ::memcpy(p, DMR_LEVELD, DMR_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
+        inBuffer[i] = DMR_LEVELD;
         break;
     }
   }
 
-  uint16_t blockSize = DMR_RADIO_SYMBOL_LENGTH * 4U;
-
-  uint8_t controlBuffer[DMR_RADIO_SYMBOL_LENGTH * 4U + 1U];
+  uint8_t controlBuffer[DMR_RADIO_SYMBOL_LENGTH * 4U];
   ::memset(controlBuffer, MARK_NONE, DMR_RADIO_SYMBOL_LENGTH * 4U * sizeof(uint8_t));
   controlBuffer[DMR_RADIO_SYMBOL_LENGTH * 2U] = control;  
 
-  // Handle the case of the oscillator not being accurate enough
-  if (m_sampleCount > 0U) {
-    m_count += DMR_RADIO_SYMBOL_LENGTH * 4U;
+  ::arm_fir_interpolate_q15(&m_modFilter, inBuffer, outBuffer, 4U);
 
-    if (m_count >= m_sampleCount) {
-      if (m_sampleInsert) {
-        inBuffer[DMR_RADIO_SYMBOL_LENGTH * 4U] = inBuffer[DMR_RADIO_SYMBOL_LENGTH * 4U - 1U];
-        for (int8_t i = DMR_RADIO_SYMBOL_LENGTH * 4U - 1; i >= 0; i--)
-          controlBuffer[i + 1] = controlBuffer[i];
-        blockSize++;
-      } else {
-        controlBuffer[DMR_RADIO_SYMBOL_LENGTH * 2U - 1U] = control;  
-        for (uint8_t i = 0U; i < (DMR_RADIO_SYMBOL_LENGTH * 4U - 1U); i++)
-          controlBuffer[i] = controlBuffer[i + 1U];
-        blockSize--;
-      }
-
-      m_count -= m_sampleCount;
-    }
-  }
-
-  ::arm_fir_fast_q15(&m_modFilter, inBuffer, outBuffer, blockSize);
-
-  io.write(STATE_DMR, outBuffer, blockSize, controlBuffer);
+  io.write(STATE_DMR, outBuffer, DMR_RADIO_SYMBOL_LENGTH * 4U, controlBuffer);
 }
 
-uint16_t CDMRTX::getSpace1() const
+uint8_t CDMRTX::getSpace1() const
 {
   return m_fifo[0U].getSpace() / (DMR_FRAME_LENGTH_BYTES + 2U);
 }
 
-uint16_t CDMRTX::getSpace2() const
+uint8_t CDMRTX::getSpace2() const
 {
   return m_fifo[1U].getSpace() / (DMR_FRAME_LENGTH_BYTES + 2U);
 }
 
 void CDMRTX::createData(uint8_t slotIndex)
 {
-  if (m_fifo[slotIndex].getData()> 0U) {
+  if (m_fifo[slotIndex].getData() >= DMR_FRAME_LENGTH_BYTES && m_frameCount >= STARTUP_COUNT && m_abortCount[slotIndex] >= ABORT_COUNT) {
     for (unsigned int i = 0U; i < DMR_FRAME_LENGTH_BYTES; i++) {
-      m_poBuffer[i]   = m_fifo[slotIndex].get();
+      m_fifo[slotIndex].get(m_poBuffer[i]);
       m_markBuffer[i] = MARK_NONE;
     }
   } else {
@@ -333,17 +311,42 @@ void CDMRTX::createData(uint8_t slotIndex)
 
 void CDMRTX::createCal()
 {
-  for (unsigned int i = 0U; i < DMR_FRAME_LENGTH_BYTES; i++) {
-    m_poBuffer[i]   = 0x5FU;              // +3, +3, -3, -3 pattern for deviation cal.
-    m_markBuffer[i] = MARK_NONE;
+  // 1.2 kHz sine wave generation
+  if (m_modemState == STATE_DMRCAL) {
+    for (unsigned int i = 0U; i < DMR_FRAME_LENGTH_BYTES; i++) {
+      m_poBuffer[i]   = 0x5FU;              // +3, +3, -3, -3 pattern for deviation cal.
+      m_markBuffer[i] = MARK_NONE;
+    }
+
+    m_poLen = DMR_FRAME_LENGTH_BYTES;
+  }
+
+  // 80 Hz square wave generation
+  if (m_modemState == STATE_LFCAL) {
+    for (unsigned int i = 0U; i < 7U; i++) {
+      m_poBuffer[i]   = 0x55U;              // +3, +3, ... pattern
+      m_markBuffer[i] = MARK_NONE;
+    }
+
+    m_poBuffer[7U]   = 0x5FU;               // +3, +3, -3, -3 pattern
+
+    for (unsigned int i = 8U; i < 15U; i++) {
+      m_poBuffer[i]   = 0xFFU;              // -3, -3, ... pattern
+      m_markBuffer[i] = MARK_NONE;
+    }
+
+    m_poLen = 15U;
   }
 
-  m_poLen = DMR_FRAME_LENGTH_BYTES;
   m_poPtr = 0U;
 }
 
 void CDMRTX::createCACH(uint8_t txSlotIndex, uint8_t rxSlotIndex)
 {
+  m_frameCount++;
+  m_abortCount[0U]++;
+  m_abortCount[1U]++;
+
   if (m_cachPtr >= 12U)
     m_cachPtr = 0U;
 
@@ -359,7 +362,9 @@ void CDMRTX::createCACH(uint8_t txSlotIndex, uint8_t rxSlotIndex)
   m_markBuffer[1U] = MARK_NONE;
   m_markBuffer[2U] = rxSlotIndex == 1U ? MARK_SLOT1 : MARK_SLOT2;
 
-  bool at = m_fifo[rxSlotIndex].getData() > 0U;
+  bool at = false;
+  if (m_frameCount >= STARTUP_COUNT)
+    at = m_fifo[rxSlotIndex].getData() > 0U;
   bool tc = txSlotIndex == 1U;
   bool ls0 = true;            // For 1 and 2
   bool ls1 = true;
@@ -395,3 +400,17 @@ void CDMRTX::setColorCode(uint8_t colorCode)
   slotType.encode(colorCode, DT_IDLE, m_idle);
 }
 
+void CDMRTX::resetFifo1()
+{
+  m_fifo[0U].reset();
+}
+
+void CDMRTX::resetFifo2()
+{
+  m_fifo[1U].reset();
+}
+
+uint32_t CDMRTX::getFrameCount()
+{
+  return m_frameCount;
+}

DMRTX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -23,7 +23,7 @@
 #include "Config.h"
 #include "DMRDefines.h"
 
-#include "SerialRB.h"
+#include "RingBuffer.h"
 
 enum DMRTXSTATE {
   DMRTXSTATE_IDLE,
@@ -48,27 +48,32 @@ public:
   void setCal(bool start);
 
   void process();
-
-  uint16_t getSpace1() const;
-  uint16_t getSpace2() const;
+  
+  void resetFifo1();
+  void resetFifo2();
+  uint32_t getFrameCount();
+  
+  uint8_t getSpace1() const;
+  uint8_t getSpace2() const;
 
   void setColorCode(uint8_t colorCode);
 
 private:
-  CSerialRB            m_fifo[2U];
-  arm_fir_instance_q15 m_modFilter;
-  q15_t                m_modState[70U];    // NoTaps + BlockSize - 1, 42 + 20 - 1 plus some spare
-  DMRTXSTATE           m_state;
-  uint8_t              m_idle[DMR_FRAME_LENGTH_BYTES];
-  uint8_t              m_cachPtr;
-  uint8_t              m_shortLC[12U];
-  uint8_t              m_newShortLC[12U];
-  uint8_t              m_markBuffer[40U];
-  uint8_t              m_poBuffer[40U];
-  uint16_t             m_poLen;
-  uint16_t             m_poPtr;
-  uint32_t             m_count;
-  bool                 m_abort[2U];
+  CRingBuffer<uint8_t>                        m_fifo[2U];
+  arm_fir_interpolate_instance_q15 m_modFilter;
+  q15_t                            m_modState[16U];    // blockSize + phaseLength - 1, 4 + 9 - 1 plus some spare
+  DMRTXSTATE                       m_state;
+  uint8_t                          m_idle[DMR_FRAME_LENGTH_BYTES];
+  uint8_t                          m_cachPtr;
+  uint8_t                          m_shortLC[12U];
+  uint8_t                          m_newShortLC[12U];
+  uint8_t                          m_markBuffer[40U];
+  uint8_t                          m_poBuffer[40U];
+  uint16_t                         m_poLen;
+  uint16_t                         m_poPtr;
+  uint32_t                         m_frameCount;
+  uint32_t                         m_abortCount[2U];
+  bool                             m_abort[2U];
 
   void createData(uint8_t slotIndex);
   void createCACH(uint8_t txSlotIndex, uint8_t rxSlotIndex);

DStarRX.cpp

@@ -1,5 +1,6 @@
 /*
- *   Copyright (C) 2009-2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2017 by Andy Uribe CA6JAU
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -16,8 +17,6 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-// #define  WANT_DEBUG
-
 #include "Config.h"
 #include "Globals.h"
 #include "DStarRX.h"
@@ -29,13 +28,7 @@ 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 = 50U * DSTAR_DATA_LENGTH_BITS;
-
-const unsigned int SYNC_POS        = 21U * DSTAR_DATA_LENGTH_BITS;
-const unsigned int SYNC_SCAN_START = SYNC_POS - 3U;
-const unsigned int SYNC_SCAN_END   = SYNC_POS + 3U;
-
-const q15_t THRESHOLD = 0;
+const unsigned int MAX_SYNC_BITS = 100U * DSTAR_DATA_LENGTH_BITS;
 
 // D-Star bit order version of 0x55 0x55 0x6E 0x0A
 const uint32_t FRAME_SYNC_DATA = 0x00557650U;
@@ -50,7 +43,7 @@ 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 uint8_t  END_SYNC_ERRS = 3U;
+const uint8_t  END_SYNC_ERRS = 1U;
 
 const uint8_t BIT_MASK_TABLE0[] = {0x7FU, 0xBFU, 0xDFU, 0xEFU, 0xF7U, 0xFBU, 0xFDU, 0xFEU};
 const uint8_t BIT_MASK_TABLE1[] = {0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02U, 0x01U};
@@ -259,8 +252,8 @@ m_pathMemory1(),
 m_pathMemory2(),
 m_pathMemory3(),
 m_fecOutput(),
-m_samples(),
-m_samplesPtr(0U)
+m_rssiAccum(0U),
+m_rssiCount(0U)
 {
 }
 
@@ -272,15 +265,17 @@ void CDStarRX::reset()
   m_patternBuffer = 0x00U;
   m_rxBufferBits  = 0U;
   m_dataBits      = 0U;
-  m_samplesPtr    = 0U;
+  m_rssiAccum     = 0U;
+  m_rssiCount     = 0U;
 }
 
-void CDStarRX::samples(const q15_t* samples, uint8_t length)
+void CDStarRX::samples(const q15_t* samples, const uint16_t* rssi, uint8_t length)
 {
   for (uint16_t i = 0U; i < length; i++) {
-    m_samples[m_samplesPtr] = samples[i];
+    m_rssiAccum += rssi[i];
+    m_rssiCount++;
 
-    bool bit = samples[i] < THRESHOLD;
+    bool bit = samples[i] < 0;
 
     if (bit != m_prev) {
       if (m_pll < (PLLMAX / 2U))
@@ -310,10 +305,6 @@ void CDStarRX::samples(const q15_t* samples, uint8_t length)
           break;
       }
     }
-
-    m_samplesPtr++;
-    if (m_samplesPtr >= DSTAR_DATA_SYNC_LENGTH_BITS)
-      m_samplesPtr = 0U;
   }
 }
 
@@ -330,6 +321,9 @@ void CDStarRX::processNone(bool bit)
     ::memset(m_rxBuffer, 0x00U, DSTAR_FEC_SECTION_LENGTH_BYTES);
     m_rxBufferBits = 0U;
 
+    m_rssiAccum = 0U;
+    m_rssiCount = 0U;
+
     m_rxState = DSRXS_HEADER;
     return;
   }
@@ -341,12 +335,17 @@ void CDStarRX::processNone(bool bit)
     io.setDecode(true);
     io.setADCDetection(true);
 
-    serial.writeDStarData(DSTAR_DATA_SYNC_BYTES, DSTAR_DATA_LENGTH_BYTES);
+    // 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  = 0U;
+    m_dataBits  = MAX_SYNC_BITS;
     m_rxState   = DSRXS_DATA;
     return;
   }
@@ -370,13 +369,13 @@ void CDStarRX::processHeader(bool bit)
       io.setDecode(true);
       io.setADCDetection(true);
 
-      serial.writeDStarHeader(header, DSTAR_HEADER_LENGTH_BYTES);
+      writeRSSIHeader(header);
 
       ::memset(m_rxBuffer, 0x00U, DSTAR_DATA_LENGTH_BYTES + 2U);
       m_rxBufferBits = 0U;
 
-      m_rxState   = DSRXS_DATA;
-      m_dataBits  = SYNC_POS - DSTAR_DATA_LENGTH_BITS + 1U;
+      m_rxState  = DSRXS_DATA;
+      m_dataBits = MAX_SYNC_BITS;
     } else {
       // The checksum failed, return to looking for syncs
       m_rxState = DSRXS_NONE;
@@ -408,38 +407,29 @@ void CDStarRX::processData(bool bit)
 
   // Fuzzy matching of the data sync bit sequence
   bool syncSeen = false;
-  if (m_dataBits >= SYNC_SCAN_START && m_dataBits <= (SYNC_POS + 1U)) {
+  if (m_rxBufferBits >= (DSTAR_DATA_LENGTH_BITS - 3U)) {
     if (countBits32((m_patternBuffer & DATA_SYNC_MASK) ^ DATA_SYNC_DATA) <= DATA_SYNC_ERRS) {
-#if defined(WANT_DEBUG)
-      if (m_dataBits < SYNC_POS)
-        DEBUG2("DStarRX: found data sync in Data, early", SYNC_POS - m_dataBits);
-      else
-        DEBUG1("DStarRX: found data sync in Data");
-#endif
       m_rxBufferBits = DSTAR_DATA_LENGTH_BITS;
-      m_dataBits = 0U;
-      syncSeen   = true;
+      m_dataBits     = MAX_SYNC_BITS;
+      syncSeen       = true;
     }
   }
 
   // Check to see if the sync is arriving late
-  if (m_dataBits == SYNC_POS) {
+  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) {
-        DEBUG2("DStarRX: found data sync in Data, late", i);
         m_rxBufferBits -= i;
-        m_dataBits     -= i;
         break;
       }
     }
   }
 
-  m_dataBits++;
+  m_dataBits--;
 
-  // We've not seen a data sync for too long, signal RXLOST and change to RX_NONE
-  if (m_dataBits >= MAX_SYNC_BITS) {
+  if (m_dataBits == 0U) {
     DEBUG1("DStarRX: data sync timed out, lost lock");
 
     io.setDecode(false);
@@ -457,9 +447,10 @@ void CDStarRX::processData(bool bit)
       m_rxBuffer[9U]  = DSTAR_DATA_SYNC_BYTES[9U];
       m_rxBuffer[10U] = DSTAR_DATA_SYNC_BYTES[10U];
       m_rxBuffer[11U] = DSTAR_DATA_SYNC_BYTES[11U];
-    }
-
-    serial.writeDStarData(m_rxBuffer, DSTAR_DATA_LENGTH_BYTES);
+	    writeRSSIData(m_rxBuffer);
+    } else {
+	    serial.writeDStarData(m_rxBuffer, DSTAR_DATA_LENGTH_BYTES);
+	  }
 
     // Start the next frame
     ::memset(m_rxBuffer, 0x00U, DSTAR_DATA_LENGTH_BYTES + 2U);
@@ -467,6 +458,48 @@ void CDStarRX::processData(bool bit)
   }
 }
 
+void CDStarRX::writeRSSIHeader(unsigned char* header)
+{
+#if defined(SEND_RSSI_DATA)
+  if (m_rssiCount > 0U) {
+    uint16_t rssi = m_rssiAccum / m_rssiCount;
+
+    header[41U] = (rssi >> 8) & 0xFFU;
+    header[42U] = (rssi >> 0) & 0xFFU;
+
+    serial.writeDStarHeader(header, DSTAR_HEADER_LENGTH_BYTES + 2U);
+  } else {
+    serial.writeDStarHeader(header, DSTAR_HEADER_LENGTH_BYTES + 0U);
+  }
+#else
+  serial.writeDStarHeader(header, DSTAR_HEADER_LENGTH_BYTES + 0U);
+#endif
+
+  m_rssiAccum = 0U;
+  m_rssiCount = 0U;
+}
+
+void CDStarRX::writeRSSIData(unsigned char* data)
+{
+#if defined(SEND_RSSI_DATA)
+  if (m_rssiCount > 0U) {
+    uint16_t rssi = m_rssiAccum / m_rssiCount;
+
+    data[12U] = (rssi >> 8) & 0xFFU;
+    data[13U] = (rssi >> 0) & 0xFFU;
+
+    serial.writeDStarData(data, DSTAR_DATA_LENGTH_BYTES + 2U);
+  } else {
+    serial.writeDStarData(data, DSTAR_DATA_LENGTH_BYTES + 0U);
+  }
+#else
+  serial.writeDStarData(data, DSTAR_DATA_LENGTH_BYTES + 0U);
+#endif
+
+  m_rssiAccum = 0U;
+  m_rssiCount = 0U;
+}
+
 bool CDStarRX::rxHeader(uint8_t* in, uint8_t* out)
 {
   int i;
@@ -682,4 +715,3 @@ 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];
 }
-

DStarRX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017 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
@@ -32,7 +32,7 @@ class CDStarRX {
 public:
   CDStarRX();
 
-  void samples(const q15_t* samples, uint8_t length);
+  void samples(const q15_t* samples, const uint16_t* rssi, uint8_t length);
 
   void reset();
 
@@ -51,12 +51,14 @@ private:
   unsigned int m_pathMemory2[42U];
   unsigned int m_pathMemory3[42U];
   uint8_t      m_fecOutput[42U];
-  q15_t        m_samples[DSTAR_DATA_SYNC_LENGTH_BITS];
-  uint8_t      m_samplesPtr;
-
+  uint32_t     m_rssiAccum;
+  uint16_t     m_rssiCount;
+  
   void    processNone(bool bit);
   void    processHeader(bool bit);
   void    processData(bool bit);
+  void    writeRSSIHeader(unsigned char* header);
+  void    writeRSSIData(unsigned char* data);
   bool    rxHeader(uint8_t* in, uint8_t* out);
   void    acs(int* metric);
   void    viterbiDecode(int* data);

DStarTX.cpp

@@ -1,5 +1,6 @@
 /*
- *   Copyright (C) 2009-2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2017 by Andy Uribe CA6JAU
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -16,8 +17,6 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#define WANT_DEBUG
-
 #include "Config.h"
 #include "Globals.h"
 #include "DStarTX.h"
@@ -28,12 +27,12 @@ const uint8_t BIT_SYNC = 0xAAU;
 
 const uint8_t FRAME_SYNC[] = {0xEAU, 0xA6U, 0x00U};
 
-// Generated using gaussfir(0.5, 4, 5) in MATLAB
-static q15_t DSTAR_GMSK_FILTER[] = {8, 104, 760, 3158, 7421, 9866, 7421, 3158, 760, 104, 8, 0};
-const uint16_t DSTAR_GMSK_FILTER_LEN = 12U;
+// Generated using gaussfir(0.35, 1, 5) in MATLAB
+static q15_t GAUSSIAN_0_35_FILTER[] = {0, 0, 0, 0, 1001, 3514, 9333, 18751, 28499, 32767, 28499, 18751, 9333, 3514, 1001}; // numTaps = 15, L = 5
+const uint16_t GAUSSIAN_0_35_FILTER_PHASE_LEN = 3U; // phaseLength = numTaps/L
 
-const q15_t DSTAR_LEVEL0[] = {-800, -800, -800, -800, -800};
-const q15_t DSTAR_LEVEL1[] = { 800,  800,  800,  800,  800};
+const q15_t DSTAR_LEVEL0 = -841;
+const q15_t DSTAR_LEVEL1 =  841;
 
 const uint8_t BIT_MASK_TABLE[] = {0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02U, 0x01U};
 
@@ -195,14 +194,14 @@ m_modState(),
 m_poBuffer(),
 m_poLen(0U),
 m_poPtr(0U),
-m_txDelay(60U),      // 100ms
-m_count(0U)
+m_txDelay(60U)       // 100ms
 {
-  ::memset(m_modState, 0x00U, 60U * sizeof(q15_t));
+  ::memset(m_modState, 0x00U, 20U * sizeof(q15_t));
 
-  m_modFilter.numTaps = DSTAR_GMSK_FILTER_LEN;
-  m_modFilter.pState  = m_modState;
-  m_modFilter.pCoeffs = DSTAR_GMSK_FILTER;
+  m_modFilter.L           = DSTAR_RADIO_BIT_LENGTH;
+  m_modFilter.phaseLength = GAUSSIAN_0_35_FILTER_PHASE_LEN;
+  m_modFilter.pCoeffs     = GAUSSIAN_0_35_FILTER;
+  m_modFilter.pState      = m_modState;
 }
 
 void CDStarTX::process()
@@ -214,17 +213,16 @@ void CDStarTX::process()
 
   if (type == DSTAR_HEADER && m_poLen == 0U) {
     if (!m_tx) {
-      m_count = 0U;
-
       for (uint16_t i = 0U; i < m_txDelay; i++)
         m_poBuffer[m_poLen++] = BIT_SYNC;
     } else {
+      uint8_t dummy;
       // Pop the type byte off
-      m_buffer.get();
+      m_buffer.get(dummy);
 
       uint8_t header[DSTAR_HEADER_LENGTH_BYTES];
       for (uint8_t i = 0U; i < DSTAR_HEADER_LENGTH_BYTES; i++)
-        header[i] = m_buffer.get();
+        m_buffer.get(header[i]);
 
       uint8_t buffer[86U];
       txHeader(header, buffer + 2U);
@@ -241,21 +239,20 @@ void CDStarTX::process()
   }
  
   if (type == DSTAR_DATA && m_poLen == 0U) {
-    if (!m_tx)
-      m_count = 0U;
-
     // Pop the type byte off
-    m_buffer.get();
+    uint8_t dummy;
+    m_buffer.get(dummy);
 
     for (uint8_t i = 0U; i < DSTAR_DATA_LENGTH_BYTES; i++)
-      m_poBuffer[m_poLen++] = m_buffer.get();
+      m_buffer.get(m_poBuffer[m_poLen++]);
 
     m_poPtr = 0U;
   }
 
   if (type == DSTAR_EOT && m_poLen == 0U) {
     // Pop the type byte off
-    m_buffer.get();
+    uint8_t dummy;
+    m_buffer.get(dummy);
 
     for (uint8_t j = 0U; j < 3U; j++) {
       for (uint8_t i = 0U; i < DSTAR_EOT_LENGTH_BYTES; i++)
@@ -394,7 +391,7 @@ void CDStarTX::txHeader(const uint8_t* in, uint8_t* out) const
     if (i < 660U) {
       if (d & 0x08U)
         out[INTERLEAVE_TABLE_TX[i * 2U]] |= (0x01U << INTERLEAVE_TABLE_TX[i * 2U + 1U]);
-        i++;
+      i++;
 
       if (d & 0x04U)
         out[INTERLEAVE_TABLE_TX[i * 2U]] |= (0x01U << INTERLEAVE_TABLE_TX[i * 2U + 1U]);
@@ -417,50 +414,34 @@ void CDStarTX::txHeader(const uint8_t* in, uint8_t* out) const
 
 void CDStarTX::writeByte(uint8_t c)
 {
-  q15_t inBuffer[DSTAR_RADIO_BIT_LENGTH * 8U + 1U];
-  q15_t outBuffer[DSTAR_RADIO_BIT_LENGTH * 8U + 1U];
+  q15_t inBuffer[8U];
+  q15_t outBuffer[DSTAR_RADIO_BIT_LENGTH * 8U];
 
   uint8_t mask = 0x01U;
 
-  q15_t* p = inBuffer;
-  for (uint8_t i = 0U; i < 8U; i++, p += DSTAR_RADIO_BIT_LENGTH) {
+  for (uint8_t i = 0U; i < 8U; i++) {
     if ((c & mask) == mask)
-      ::memcpy(p, DSTAR_LEVEL0, DSTAR_RADIO_BIT_LENGTH * sizeof(q15_t));
+      inBuffer[i] = DSTAR_LEVEL0;
     else
-      ::memcpy(p, DSTAR_LEVEL1, DSTAR_RADIO_BIT_LENGTH * sizeof(q15_t));
+      inBuffer[i] = DSTAR_LEVEL1;
 
     mask <<= 1;
   }
 
-  uint16_t blockSize = DSTAR_RADIO_BIT_LENGTH * 8U;
-
-  // Handle the case of the oscillator not being accurate enough
-  if (m_sampleCount > 0U) {
-    m_count += DSTAR_RADIO_BIT_LENGTH * 8U;
-
-    if (m_count >= m_sampleCount) {
-      if (m_sampleInsert) {
-        inBuffer[DSTAR_RADIO_BIT_LENGTH * 8U] = inBuffer[DSTAR_RADIO_BIT_LENGTH * 8U - 1U];
-        blockSize++;
-      } else {
-        blockSize--;
-      }
-
-      m_count -= m_sampleCount;
-    }
-  }
-
-  ::arm_fir_fast_q15(&m_modFilter, inBuffer, outBuffer, blockSize);
-
-  io.write(STATE_DSTAR, outBuffer, blockSize);
+  ::arm_fir_interpolate_q15(&m_modFilter, inBuffer, outBuffer, 8U);
+  
+  io.write(STATE_DSTAR, outBuffer, DSTAR_RADIO_BIT_LENGTH * 8U);
 }
 
 void CDStarTX::setTXDelay(uint8_t delay)
 {
-  m_txDelay = 150U + uint16_t(delay) * 6U;        // 250ms + tx delay
+  m_txDelay = 300U + uint16_t(delay) * 6U;        // 250ms + tx delay
+
+  if (m_txDelay > 600U)
+    m_txDelay = 600U;
 }
 
-uint16_t CDStarTX::getSpace() const
+uint8_t CDStarTX::getSpace() const
 {
   return m_buffer.getSpace() / (DSTAR_DATA_LENGTH_BYTES + 1U);
 }

DStarTX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017 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
@@ -21,7 +21,7 @@
 
 #include "Config.h"
 
-#include "SerialRB.h"
+#include "RingBuffer.h"
 
 class CDStarTX {
 public:
@@ -35,17 +35,16 @@ public:
 
   void setTXDelay(uint8_t delay);
 
-  uint16_t getSpace() const;
+  uint8_t getSpace() const;
 
 private:
-  CSerialRB            m_buffer;
-  arm_fir_instance_q15 m_modFilter;
-  q15_t                m_modState[60U];    // NoTaps + BlockSize - 1, 12 + 40 - 1 plus some spare
-  uint8_t              m_poBuffer[500U];
-  uint16_t             m_poLen;
-  uint16_t             m_poPtr;
-  uint16_t             m_txDelay;          // In bytes
-  uint32_t             m_count;
+  CRingBuffer<uint8_t>             m_buffer;
+  arm_fir_interpolate_instance_q15 m_modFilter;
+  q15_t                            m_modState[20U];    // blockSize + phaseLength - 1, 8 + 9 - 1 plus some spare
+  uint8_t                          m_poBuffer[600U];
+  uint16_t                         m_poLen;
+  uint16_t                         m_poPtr;
+  uint16_t                         m_txDelay;          // In bytes
 
   void txHeader(const uint8_t* in, uint8_t* out) const;
   void writeByte(uint8_t c);

Debug.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017 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
@@ -20,9 +20,6 @@
 #define  DEBUG_H
 
 #include "Config.h"
-
-#if defined(WANT_DEBUG)
-
 #include "Globals.h"
 
 #define  DEBUG1(a)          serial.writeDebug((a))
@@ -30,18 +27,6 @@
 #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  ASSERT(a)          serial.writeAssert((a),#a,__FILE__,__LINE__)
-
-#else
-
-#define  DEBUG1(a)          
-#define  DEBUG2(a,b)        
-#define  DEBUG3(a,b,c)      
-#define  DEBUG4(a,b,c,d)    
-#define  DEBUG5(a,b,c,d,e)  
-#define  ASSERT(a)          
-
-#endif
 
 #endif
 

FM.cpp

@@ -0,0 +1,782 @@
+/*
+ *   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"
+#include "Globals.h"
+#include "FM.h"
+
+
+const uint16_t FM_TX_BLOCK_SIZE = 100U;
+const uint16_t FM_SERIAL_BLOCK_SIZE = 84U;//this is the number of sample pairs to send over serial. One sample pair is 3bytes.
+                                          //three times this value shall never exceed 252
+const uint16_t FM_SERIAL_BLOCK_SIZE_BYTES = FM_SERIAL_BLOCK_SIZE * 3U;
+
+CFM::CFM() :
+m_callsign(),
+m_rfAck(),
+m_extAck(),
+m_ctcssRX(),
+m_ctcssTX(),
+m_timeoutTone(),
+m_state(FS_LISTENING),
+m_callsignAtStart(false),
+m_callsignAtEnd(false),
+m_callsignAtLatch(false),
+m_callsignTimer(),
+m_timeoutTimer(),
+m_holdoffTimer(),
+m_kerchunkTimer(),
+m_kerchunkTX(true),
+m_ackMinTimer(),
+m_ackDelayTimer(),
+m_hangTimer(),
+m_statusTimer(),
+m_filterStage1(  724,   1448,   724, 32768, -37895, 21352),//3rd order Cheby Filter 300 to 2700Hz, 0.2dB passband ripple, sampling rate 24kHz
+m_filterStage2(32768,      0,-32768, 32768, -50339, 19052),
+m_filterStage3(32768, -65536, 32768, 32768, -64075, 31460),
+m_blanking(),
+m_useCOS(true),
+m_cosInvert(false),
+m_rfAudioBoost(1U),
+m_extAudioBoost(1U),
+m_downsampler(400U),// 100 ms of audio
+m_extEnabled(false),
+m_rxLevel(1),
+m_inputRFRB(2401U),   // 100ms of audio + 1 sample
+m_outputRFRB(2400U),  // 100ms of audio
+m_inputExtRB()
+{
+  m_statusTimer.setTimeout(1U, 0U);
+
+  insertDelay(100U);
+}
+
+void CFM::samples(bool cos, q15_t* samples, uint8_t length)
+{
+  if (m_useCOS) {
+    if (m_cosInvert)
+      cos = !cos;
+  } else {
+    cos = true;
+  }
+
+  clock(length);
+
+  uint8_t i = 0U;
+  for (; i < length; i++) {
+    // ARMv7-M has hardware integer division 
+    q15_t currentRFSample = q15_t((q31_t(samples[i]) << 8) / m_rxLevel);
+    uint8_t ctcssState = m_ctcssRX.process(currentRFSample);
+
+    if (!m_useCOS) {
+      // Delay the audio by 100ms to better match the CTCSS detector output
+      m_inputRFRB.put(currentRFSample);
+      m_inputRFRB.get(currentRFSample);
+    }
+
+    q15_t currentExtSample;
+    bool inputExt = m_inputExtRB.getSample(currentExtSample);//always consume the external input data so it does not overflow
+    inputExt = inputExt && m_extEnabled;
+
+    if (!inputExt && (CTCSS_NOT_READY(ctcssState)) && m_modemState != STATE_FM) {
+      //Not enough samples to determine if you have CTCSS, just carry on. But only if we haven't any external data in the queue
+      continue;
+    } else if ((inputExt || CTCSS_READY(ctcssState)) && m_modemState != STATE_FM) {
+      //we had enough samples for CTCSS and we are in some other mode than FM
+      bool validCTCSS = CTCSS_VALID(ctcssState);
+      stateMachine(validCTCSS && cos, inputExt);
+      if (m_modemState != STATE_FM)
+        continue;
+    } else if ((inputExt || CTCSS_NOT_READY(ctcssState)) && m_modemState == STATE_FM && i == length - 1) {
+      //Not enough samples for CTCSS but we already are in FM, trigger the state machine
+      //but do not trigger the state machine on every single sample, save CPU!
+      bool validCTCSS = CTCSS_VALID(ctcssState);
+      stateMachine(validCTCSS && cos, inputExt);
+    }
+
+    q15_t currentSample = currentRFSample;
+    q15_t currentBoost  = m_rfAudioBoost;
+    if (m_state == FS_RELAYING_EXT || m_state == FS_KERCHUNK_EXT) {
+      currentSample = currentExtSample;
+      currentBoost  = m_extAudioBoost;
+    }
+
+    // Only let RF audio through when relaying RF audio
+    if (m_state == FS_RELAYING_RF || m_state == FS_KERCHUNK_RF || m_state == FS_RELAYING_EXT || m_state == FS_KERCHUNK_EXT) {
+      currentSample = m_blanking.process(currentSample);
+      if (m_extEnabled && (m_state == FS_RELAYING_RF || m_state == FS_KERCHUNK_RF))
+        m_downsampler.addSample(currentSample);
+
+      currentSample *= currentBoost;
+    } else {
+      currentSample = 0;
+    }
+
+    if (!m_callsign.isRunning() && !m_extAck.isRunning())
+      currentSample += m_rfAck.getHighAudio();
+
+    if (!m_callsign.isRunning() && !m_rfAck.isRunning())
+      currentSample += m_extAck.getHighAudio();
+
+    if (!m_rfAck.isRunning() && !m_extAck.isRunning()) {
+      if (m_state == FS_LISTENING)
+        currentSample += m_callsign.getHighAudio();
+      else
+        currentSample += m_callsign.getLowAudio();
+    }
+
+    if (!m_callsign.isRunning() && !m_rfAck.isRunning() && !m_extAck.isRunning())
+      currentSample += m_timeoutTone.getAudio();
+
+    currentSample = m_filterStage3.filter(m_filterStage2.filter(m_filterStage1.filter(currentSample)));
+
+    currentSample += m_ctcssTX.getAudio();
+
+    m_outputRFRB.put(currentSample);
+  }
+}
+
+void CFM::process()
+{
+  uint16_t space = io.getSpace();
+  uint16_t length = m_outputRFRB.getData();
+
+  if (space > 10U && length >= FM_TX_BLOCK_SIZE ) {
+    space -= 2U;
+    if (length > FM_TX_BLOCK_SIZE)
+      length = FM_TX_BLOCK_SIZE;
+    if (space > FM_TX_BLOCK_SIZE)
+      space = FM_TX_BLOCK_SIZE;
+    if (length > space)
+      length = space;
+
+    q15_t samples[FM_TX_BLOCK_SIZE];
+
+    for (uint16_t i = 0U; i < length; i++) {
+      q15_t sample = 0;
+      m_outputRFRB.get(sample);
+      samples[i] = sample;
+    }
+
+    io.write(STATE_FM, samples, length);
+  }
+
+  if (m_extEnabled) {
+    uint16_t length = m_downsampler.getData();
+
+    if (length >= FM_SERIAL_BLOCK_SIZE) {
+      if (length > FM_SERIAL_BLOCK_SIZE)
+        length = FM_SERIAL_BLOCK_SIZE;
+        
+      TSamplePairPack serialSamples[FM_SERIAL_BLOCK_SIZE];
+
+      for (uint16_t j = 0U; j < length; j++)
+        m_downsampler.getPackedData(serialSamples[j]);
+
+      serial.writeFMData((uint8_t*)serialSamples, length * sizeof(TSamplePairPack));
+    }
+  }
+}
+
+void CFM::reset()
+{
+  m_state = FS_LISTENING;
+
+  m_callsignTimer.stop();
+  m_timeoutTimer.stop();
+  m_kerchunkTimer.stop();
+  m_ackMinTimer.stop();
+  m_ackDelayTimer.stop();
+  m_hangTimer.stop();
+  m_statusTimer.stop();
+
+  m_ctcssRX.reset();
+  m_rfAck.stop();
+  m_extAck.stop();
+  m_callsign.stop();
+  m_timeoutTone.stop();
+
+  m_outputRFRB.reset();
+  m_inputExtRB.reset();
+
+  m_downsampler.reset();
+}
+
+uint8_t CFM::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)
+{
+  m_callsignAtStart = callsignAtStart;
+  m_callsignAtEnd   = callsignAtEnd;
+  m_callsignAtLatch = callsignAtLatch;
+
+  uint16_t holdoffTime  = holdoff * 60U;
+  uint16_t callsignTime = time * 60U;
+
+  m_holdoffTimer.setTimeout(holdoffTime, 0U);
+  m_callsignTimer.setTimeout(callsignTime, 0U);
+
+  if (holdoffTime > 0U)
+    m_holdoffTimer.start();
+
+  return m_callsign.setParams(callsign, speed, frequency, highLevel, lowLevel);
+}
+
+uint8_t CFM::setAck(const char* rfAck, uint8_t speed, uint16_t frequency, uint8_t minTime, uint16_t delay, uint8_t level)
+{
+  m_ackDelayTimer.setTimeout(0U, delay);
+
+  if (minTime > 0U)
+    m_ackMinTimer.setTimeout(minTime, delay);
+
+  return m_rfAck.setParams(rfAck, speed, frequency, level, level);
+}
+
+uint8_t CFM::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)
+{
+  m_useCOS    = useCOS;
+  m_cosInvert = cosInvert;
+
+  m_rfAudioBoost = q15_t(rfAudioBoost);
+
+  m_timeoutTimer.setTimeout(timeout, 0U);
+
+  m_kerchunkTimer.setTimeout(kerchunkTime, 0U);
+  m_kerchunkTX = kerchunkTX;
+
+  m_hangTimer.setTimeout(hangTime, 0U);
+
+  m_timeoutTone.setParams(timeoutLevel);
+  m_blanking.setParams(maxDev, timeoutLevel);
+
+  m_rxLevel = rxLevel; //q15_t(255)/q15_t(rxLevel >> 1);
+
+  uint8_t ret = m_ctcssRX.setParams(ctcssFrequency, ctcssHighThreshold, ctcssLowThreshold);
+  if (ret != 0U)
+    return ret;
+
+  return m_ctcssTX.setParams(ctcssFrequency, ctcssLevel);
+}
+
+uint8_t CFM::setExt(const char* ack, uint8_t audioBoost, uint8_t speed, uint16_t frequency, uint8_t level)
+{
+  m_extEnabled = true;
+
+  m_extAudioBoost = q15_t(audioBoost);
+
+  return m_extAck.setParams(ack, speed, frequency, level, level);
+}
+
+void CFM::stateMachine(bool validRFSignal, bool validExtSignal)
+{
+  switch (m_state) {
+    case FS_LISTENING:
+      listeningState(validRFSignal, validExtSignal);
+      break;
+    case FS_KERCHUNK_RF:
+      kerchunkRFState(validRFSignal);
+      break;
+    case FS_RELAYING_RF:
+      relayingRFState(validRFSignal);
+      break;
+    case FS_RELAYING_WAIT_RF:
+      relayingRFWaitState(validRFSignal);
+      break;
+    case FS_TIMEOUT_RF:
+      timeoutRFState(validRFSignal);
+      break;
+    case FS_TIMEOUT_WAIT_RF:
+      timeoutRFWaitState(validRFSignal);
+      break;
+    case FS_KERCHUNK_EXT:
+      kerchunkExtState(validExtSignal);
+      break;
+    case FS_RELAYING_EXT:
+      relayingExtState(validExtSignal);
+      break;
+    case FS_RELAYING_WAIT_EXT:
+      relayingExtWaitState(validExtSignal);
+      break;
+    case FS_TIMEOUT_EXT:
+      timeoutExtState(validExtSignal);
+      break;
+    case FS_TIMEOUT_WAIT_EXT:
+      timeoutExtWaitState(validExtSignal);
+      break;
+    case FS_HANG:
+      hangState(validRFSignal, validExtSignal);
+      break;
+    default:
+      break;
+  }
+
+  if (m_state == FS_LISTENING && !m_rfAck.isWanted() && !m_extAck.isWanted() && !m_callsign.isWanted()) {
+    m_outputRFRB.reset();
+    m_downsampler.reset();
+  }
+}
+
+void CFM::clock(uint8_t length)
+{
+  m_callsignTimer.clock(length);
+  m_timeoutTimer.clock(length);
+  m_holdoffTimer.clock(length);
+  m_kerchunkTimer.clock(length);
+  m_ackMinTimer.clock(length);
+  m_ackDelayTimer.clock(length);
+  m_hangTimer.clock(length);
+  m_statusTimer.clock(length);
+
+  if (m_statusTimer.isRunning() && m_statusTimer.hasExpired()) {
+    serial.writeFMStatus(m_state);
+    m_statusTimer.start();
+  }
+}
+
+void CFM::listeningState(bool validRFSignal, bool validExtSignal)
+{
+  if (validRFSignal) {
+    if (m_kerchunkTimer.getTimeout() > 0U) {
+      DEBUG1("State to KERCHUNK_RF");
+      m_state = FS_KERCHUNK_RF;
+      m_kerchunkTimer.start();
+      if (m_callsignAtStart && !m_callsignAtLatch)
+        sendCallsign();
+    } else {
+      DEBUG1("State to RELAYING_RF");
+      m_state = FS_RELAYING_RF;
+      if (m_callsignAtStart)
+        sendCallsign();
+    }
+
+    if (m_state == FS_RELAYING_RF || (m_state == FS_KERCHUNK_RF && m_kerchunkTX)) {
+      insertSilence(50U);
+
+      beginRelaying();
+
+      m_callsignTimer.start();
+
+      io.setDecode(true);
+      io.setADCDetection(true);
+
+      m_statusTimer.start();
+      serial.writeFMStatus(m_state);
+    }
+  } else if (validExtSignal) {
+    if (m_kerchunkTimer.getTimeout() > 0U) {
+      DEBUG1("State to KERCHUNK_EXT");
+      m_state = FS_KERCHUNK_EXT;
+      m_kerchunkTimer.start();
+      if (m_callsignAtStart && !m_callsignAtLatch)
+        sendCallsign();
+    } else {
+      DEBUG1("State to RELAYING_EXT");
+      m_state = FS_RELAYING_EXT;
+      if (m_callsignAtStart)
+        sendCallsign();
+    }
+
+    if (m_state == FS_RELAYING_EXT || (m_state == FS_KERCHUNK_EXT && m_kerchunkTX)) {
+      insertSilence(50U);
+
+      beginRelaying();
+
+      m_callsignTimer.start();
+
+      m_statusTimer.start();
+      serial.writeFMStatus(m_state);
+    }
+  }
+}
+
+void CFM::kerchunkRFState(bool validSignal)
+{
+  if (validSignal) {
+    if (m_kerchunkTimer.hasExpired()) {
+      DEBUG1("State to RELAYING_RF");
+      m_state = FS_RELAYING_RF;
+      m_kerchunkTimer.stop();
+      if (!m_kerchunkTX) {
+        insertSilence(50U);
+
+        beginRelaying();
+
+        m_callsignTimer.start();
+
+        io.setDecode(true);
+        io.setADCDetection(true);
+
+        m_statusTimer.start();
+        serial.writeFMStatus(m_state);
+      }
+      if (m_callsignAtStart && m_callsignAtLatch) {
+        sendCallsign();
+        m_callsignTimer.start();
+      }
+    }
+  } else {
+    io.setDecode(false);
+    io.setADCDetection(false);
+
+    DEBUG1("State to LISTENING");
+    m_state = FS_LISTENING;
+    m_kerchunkTimer.stop();
+    m_timeoutTimer.stop();
+    m_ackMinTimer.stop();
+    m_callsignTimer.stop();
+    m_statusTimer.stop();
+
+    if (m_extEnabled)
+      serial.writeFMEOT();
+  }
+}
+
+void CFM::relayingRFState(bool validSignal)
+{
+  if (validSignal) {
+    if (m_timeoutTimer.isRunning() && m_timeoutTimer.hasExpired()) {
+      DEBUG1("State to TIMEOUT_RF");
+      m_state = FS_TIMEOUT_RF;
+      m_ackMinTimer.stop();
+      m_timeoutTimer.stop();
+      m_timeoutTone.start();
+
+      if (m_extEnabled)
+        serial.writeFMEOT();
+    }
+  } else {
+    io.setDecode(false);
+    io.setADCDetection(false);
+
+    DEBUG1("State to RELAYING_WAIT_RF");
+    m_state = FS_RELAYING_WAIT_RF;
+    m_ackDelayTimer.start();
+
+    if (m_extEnabled)
+      serial.writeFMEOT();
+  }
+
+  if (m_callsignTimer.isRunning() && m_callsignTimer.hasExpired()) {
+    sendCallsign();
+    m_callsignTimer.start();
+  }
+}
+
+void CFM::relayingRFWaitState(bool validSignal)
+{
+  if (validSignal) {
+    io.setDecode(true);
+    io.setADCDetection(true);
+
+    DEBUG1("State to RELAYING_RF");
+    m_state = FS_RELAYING_RF;
+    m_ackDelayTimer.stop();
+  } else {
+    if (m_ackDelayTimer.isRunning() && m_ackDelayTimer.hasExpired()) {
+      DEBUG1("State to HANG");
+      m_state = FS_HANG;
+
+      if (m_ackMinTimer.isRunning()) {
+        if (m_ackMinTimer.hasExpired()) {
+          DEBUG1("Send RF ack");
+          m_rfAck.start();
+          m_ackMinTimer.stop();
+        }
+      } else {
+          DEBUG1("Send RF ack");
+          m_rfAck.start();
+          m_ackMinTimer.stop();
+      }
+
+      m_ackDelayTimer.stop();
+      m_timeoutTimer.stop();
+      m_hangTimer.start();
+    }
+  }
+
+  if (m_callsignTimer.isRunning() && m_callsignTimer.hasExpired()) {
+    sendCallsign();
+    m_callsignTimer.start();
+  }
+}
+
+void CFM::kerchunkExtState(bool validSignal)
+{
+  if (validSignal) {
+    if (m_kerchunkTimer.hasExpired()) {
+      DEBUG1("State to RELAYING_EXT");
+      m_state = FS_RELAYING_EXT;
+      m_kerchunkTimer.stop();
+      if (!m_kerchunkTX) {
+        insertSilence(50U);
+
+        beginRelaying();
+
+        m_callsignTimer.start();
+
+        m_statusTimer.start();
+        serial.writeFMStatus(m_state);
+      }
+      if (m_callsignAtStart && m_callsignAtLatch) {
+        sendCallsign();
+        m_callsignTimer.start();
+      }
+    }
+  } else {
+    DEBUG1("State to LISTENING");
+    m_state = FS_LISTENING;
+    m_kerchunkTimer.stop();
+    m_timeoutTimer.stop();
+    m_ackMinTimer.stop();
+    m_callsignTimer.stop();
+    m_statusTimer.stop();
+  }
+}
+
+void CFM::relayingExtState(bool validSignal)
+{
+  if (validSignal) {
+    if (m_timeoutTimer.isRunning() && m_timeoutTimer.hasExpired()) {
+      DEBUG1("State to TIMEOUT_EXT");
+      m_state = FS_TIMEOUT_EXT;
+      m_ackMinTimer.stop();
+      m_timeoutTimer.stop();
+      m_timeoutTone.start();
+    }
+  } else {
+    DEBUG1("State to RELAYING_WAIT_EXT");
+    m_state = FS_RELAYING_WAIT_EXT;
+    m_ackDelayTimer.start();
+  }
+
+  if (m_callsignTimer.isRunning() && m_callsignTimer.hasExpired()) {
+    sendCallsign();
+    m_callsignTimer.start();
+  }
+}
+
+void CFM::relayingExtWaitState(bool validSignal)
+{
+  if (validSignal) {
+    DEBUG1("State to RELAYING_EXT");
+    m_state = FS_RELAYING_EXT;
+    m_ackDelayTimer.stop();
+  } else {
+    if (m_ackDelayTimer.isRunning() && m_ackDelayTimer.hasExpired()) {
+      DEBUG1("State to HANG");
+      m_state = FS_HANG;
+
+      if (m_ackMinTimer.isRunning()) {
+        if (m_ackMinTimer.hasExpired()) {
+          DEBUG1("Send Ext ack");
+          m_extAck.start();
+          m_ackMinTimer.stop();
+        }
+      } else {
+          DEBUG1("Send Ext ack");
+          m_extAck.start();
+          m_ackMinTimer.stop();
+      }
+
+      m_ackDelayTimer.stop();
+      m_timeoutTimer.stop();
+      m_hangTimer.start();
+    }
+  }
+
+  if (m_callsignTimer.isRunning() && m_callsignTimer.hasExpired()) {
+    sendCallsign();
+    m_callsignTimer.start();
+  }
+}
+
+void CFM::hangState(bool validRFSignal, bool validExtSignal)
+{
+  if (validRFSignal) {
+    io.setDecode(true);
+    io.setADCDetection(true);
+
+    DEBUG1("State to RELAYING_RF");
+    m_state = FS_RELAYING_RF;
+    DEBUG1("Stop ack");
+    m_rfAck.stop();
+    m_extAck.stop();
+    beginRelaying();
+  } else if (validExtSignal) {
+    DEBUG1("State to RELAYING_EXT");
+    m_state = FS_RELAYING_EXT;
+    DEBUG1("Stop ack");
+    m_rfAck.stop();
+    m_extAck.stop();
+    beginRelaying();
+  } else {
+    if (m_hangTimer.isRunning() && m_hangTimer.hasExpired()) {
+      DEBUG1("State to LISTENING");
+      m_state = FS_LISTENING;
+      m_hangTimer.stop();
+      m_statusTimer.stop();
+
+      if (m_callsignAtEnd)
+        sendCallsign();
+
+      m_callsignTimer.stop();
+
+    }
+  }
+
+  if (m_callsignTimer.isRunning() && m_callsignTimer.hasExpired()) {
+    sendCallsign();
+    m_callsignTimer.start();
+  }
+}
+
+void CFM::timeoutRFState(bool validSignal)
+{
+  if (!validSignal) {
+    io.setDecode(false);
+    io.setADCDetection(false);
+
+    DEBUG1("State to TIMEOUT_WAIT_RF");
+    m_state = FS_TIMEOUT_WAIT_RF;
+
+    if (m_callsignAtEnd)
+        sendCallsign();
+
+    m_ackDelayTimer.start();
+  }
+
+  if (m_callsignTimer.isRunning() && m_callsignTimer.hasExpired()) {
+    sendCallsign();
+    m_callsignTimer.start();
+  }
+}
+
+void CFM::timeoutRFWaitState(bool validSignal)
+{
+  if (validSignal) {
+    io.setDecode(true);
+    io.setADCDetection(true);
+
+    DEBUG1("State to TIMEOUT_RF");
+    m_state = FS_TIMEOUT_RF;
+    m_ackDelayTimer.stop();
+  } else {
+    if (m_ackDelayTimer.isRunning() && m_ackDelayTimer.hasExpired()) {
+      DEBUG1("State to HANG");
+      m_state = FS_HANG;
+      m_timeoutTone.stop();
+      DEBUG1("Send RF ack");
+      m_rfAck.start();
+      m_ackDelayTimer.stop();
+      m_ackMinTimer.stop();
+      m_timeoutTimer.stop();
+      m_hangTimer.start();
+    }
+  }
+
+  if (m_callsignTimer.isRunning() && m_callsignTimer.hasExpired()) {
+    sendCallsign();
+    m_callsignTimer.start();
+  }
+}
+
+void CFM::timeoutExtState(bool validSignal)
+{
+  if (!validSignal) {
+    DEBUG1("State to TIMEOUT_WAIT_EXT");
+    m_state = FS_TIMEOUT_WAIT_EXT;
+    m_ackDelayTimer.start();
+  }
+
+  if (m_callsignTimer.isRunning() && m_callsignTimer.hasExpired()) {
+    sendCallsign();
+    m_callsignTimer.start();
+  }
+}
+
+void CFM::timeoutExtWaitState(bool validSignal)
+{
+  if (validSignal) {
+    DEBUG1("State to TIMEOUT_EXT");
+    m_state = FS_TIMEOUT_EXT;
+    m_ackDelayTimer.stop();
+  } else {
+    if (m_ackDelayTimer.isRunning() && m_ackDelayTimer.hasExpired()) {
+      DEBUG1("State to HANG");
+      m_state = FS_HANG;
+      m_timeoutTone.stop();
+      DEBUG1("Send Ext ack");
+      m_extAck.start();
+      m_ackDelayTimer.stop();
+      m_ackMinTimer.stop();
+      m_timeoutTimer.stop();
+      m_hangTimer.start();
+    }
+  }
+
+  if (m_callsignTimer.isRunning() && m_callsignTimer.hasExpired()) {
+    sendCallsign();
+    m_callsignTimer.start();
+  }
+}
+void CFM::sendCallsign()
+{
+  if (m_holdoffTimer.isRunning()) {
+    if (m_holdoffTimer.hasExpired()) {
+      DEBUG1("Send callsign");
+      m_callsign.start();
+      m_holdoffTimer.start();
+    }
+  } else {
+    DEBUG1("Send callsign");
+    m_callsign.start();
+  }
+}
+
+void CFM::beginRelaying()
+{
+  m_timeoutTimer.start();
+  m_ackMinTimer.start();
+}
+
+uint8_t CFM::getSpace() const
+{
+  // The amount of free space for receiving external audio, in frames.
+  return m_inputExtRB.getSpace() / FM_SERIAL_BLOCK_SIZE_BYTES;
+}
+
+uint8_t CFM::writeData(const uint8_t* data, uint8_t length)
+{
+  //todo check if length is a multiple of 3
+  m_inputExtRB.addData(data, length);
+  return 0U;
+}
+
+void CFM::insertDelay(uint16_t ms)
+{
+  uint32_t nSamples = ms * 24U;
+
+  for (uint32_t i = 0U; i < nSamples; i++)
+    m_inputRFRB.put(0);
+}
+
+void CFM::insertSilence(uint16_t ms)
+{
+  uint32_t nSamples = ms * 24U;
+
+  for (uint32_t i = 0U; i < nSamples; i++)
+    m_outputRFRB.put(0);
+}

FM.h

@@ -0,0 +1,128 @@
+/*
+ *   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.
+ */
+
+#if !defined(FM_H)
+#define  FM_H
+
+#include "Config.h"
+
+#include "FMBlanking.h"
+#include "FMCTCSSRX.h"
+#include "FMCTCSSTX.h"
+#include "FMTimeout.h"
+#include "FMKeyer.h"
+#include "FMTimer.h"
+#include "RingBuffer.h"
+#include "FMDirectForm1.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
+};
+
+
+class CFM {
+public:
+  CFM();
+
+  void samples(bool cos, q15_t* samples, uint8_t length);
+
+  void process();
+
+  void reset();
+
+  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 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);
+
+private:
+  CFMKeyer             m_callsign;
+  CFMKeyer             m_rfAck;
+  CFMKeyer             m_extAck;
+  CFMCTCSSRX           m_ctcssRX;
+  CFMCTCSSTX           m_ctcssTX;
+  CFMTimeout           m_timeoutTone;
+  FM_STATE             m_state;
+  bool                 m_callsignAtStart;
+  bool                 m_callsignAtEnd;
+  bool                 m_callsignAtLatch;
+  CFMTimer             m_callsignTimer;
+  CFMTimer             m_timeoutTimer;
+  CFMTimer             m_holdoffTimer;
+  CFMTimer             m_kerchunkTimer;
+  bool                 m_kerchunkTX;
+  CFMTimer             m_ackMinTimer;
+  CFMTimer             m_ackDelayTimer;
+  CFMTimer             m_hangTimer;
+  CFMTimer             m_statusTimer;
+  CFMDirectFormI       m_filterStage1;
+  CFMDirectFormI       m_filterStage2;
+  CFMDirectFormI       m_filterStage3;
+  CFMBlanking          m_blanking;
+  bool                 m_useCOS;
+  bool                 m_cosInvert;
+  q15_t                m_rfAudioBoost;
+  q15_t                m_extAudioBoost;
+  CFMDownsampler       m_downsampler;
+  bool                 m_extEnabled;
+  q15_t                m_rxLevel;
+  CRingBuffer<q15_t>   m_inputRFRB;
+  CRingBuffer<q15_t>   m_outputRFRB;
+  CFMUpSampler         m_inputExtRB;
+
+  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 clock(uint8_t length);
+
+  void sendCallsign();
+  void beginRelaying();
+
+  void insertDelay(uint16_t ms);
+  void insertSilence(uint16_t ms);
+};
+
+#endif

FMBlanking.cpp

@@ -0,0 +1,82 @@
+/*
+ *   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"
+#include "Globals.h"
+#include "FMBlanking.h"
+
+// 2000 Hz sine wave at 24000 Hz sample rate
+const q31_t TONE[] = {0, 16384, 28378, 32767, 28378, 16384, 0, -16383, -28377, -32767, -28377, -16383};
+
+const uint8_t TONE_LEN = 12U;
+
+const uint32_t BLEEP_LEN = 2400U;   // 100ms
+
+CFMBlanking::CFMBlanking() :
+m_posValue(0),
+m_negValue(0),
+m_level(128 * 128),
+m_running(false),
+m_pos(0U),
+m_n(0U)
+{
+}
+
+void CFMBlanking::setParams(uint8_t value, uint8_t level)
+{
+  m_posValue = q15_t(value * 128);
+  m_negValue = -m_posValue;
+
+  m_level = q15_t(level * 128);
+}
+
+q15_t CFMBlanking::process(q15_t sample)
+{
+  if (m_posValue == 0)
+    return sample;
+
+  if (!m_running) {
+    if (sample >= m_posValue) {
+      m_running = true;
+      m_pos = 0U;
+      m_n   = 0U;
+    } else if (sample <= m_negValue) {
+      m_running = true;
+      m_pos = 0U;
+      m_n   = 0U;
+    }
+  }
+
+  if (!m_running)
+    return sample;
+
+  if (m_pos <= BLEEP_LEN) {
+    q31_t value = TONE[m_n++] * m_level;
+    sample = q15_t(__SSAT((value >> 15), 16));
+    if (m_n >= TONE_LEN)
+      m_n = 0U;
+  } else {
+    sample = 0;
+  }
+
+  m_pos++;
+  if (m_pos >= 12000U)
+    m_running = false;
+
+  return sample;
+}

FMBlanking.h

@@ -0,0 +1,41 @@
+/*
+ *   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.
+ */
+
+#if !defined(FMBlanking_H)
+#define  FMBlanking_H
+
+#include "Config.h"
+
+class CFMBlanking {
+public:
+  CFMBlanking();
+
+  void setParams(uint8_t value, uint8_t level);
+
+  q15_t process(q15_t sample);
+
+private:
+  q15_t    m_posValue;
+  q15_t    m_negValue;
+  q15_t    m_level;
+  bool     m_running;
+  uint32_t m_pos;
+  uint8_t  m_n;
+};
+
+#endif

FMCTCSSRX.cpp

@@ -0,0 +1,181 @@
+/*
+ *   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"
+#include "Globals.h"
+#include "FMCTCSSRX.h"
+
+const struct RX_CTCSS_TABLE {
+  uint8_t frequency;
+  q63_t   coeffDivTwo;
+} RX_CTCSS_TABLE_DATA[] = {
+  { 67U, 2147153298},
+  { 69U, 2147130228},
+  { 71U, 2147103212},
+  { 74U, 2147076297},
+  { 77U, 2147047330},
+  { 79U, 2147016195},
+  { 82U, 2146982775},
+  { 85U, 2146946945},
+  { 88U, 2146907275},
+  { 91U, 2146867538},
+  { 94U, 2146822298},
+  { 97U, 2146785526},
+  {100U, 2146747759},
+  {103U, 2146695349},
+  {107U, 2146637984},
+  {110U, 2146578604},
+  {114U, 2146513835},
+  {118U, 2146445080},
+  {123U, 2146370355},
+  {127U, 2146291161},
+  {131U, 2146205372},
+  {136U, 2146112589},
+  {141U, 2146014479},
+  {146U, 2145910829},
+  {151U, 2145796971},
+  {156U, 2145676831},
+  {159U, 2145604646},
+  {162U, 2145547790},
+  {165U, 2145468230},
+  {167U, 2145409363},
+  {171U, 2145324517},
+  {173U, 2145261046},
+  {177U, 2145170643},
+  {179U, 2145102321},
+  {183U, 2145006080},
+  {186U, 2144932648},
+  {189U, 2144830280},
+  {192U, 2144748638},
+  {196U, 2144639788},
+  {199U, 2144555290},
+  {203U, 2144436713},
+  {206U, 2144346237},
+  {210U, 2144217348},
+  {218U, 2143983951},
+  {225U, 2143735870},
+  {229U, 2143622139},
+  {233U, 2143469001},
+  {241U, 2143182299},
+  {250U, 2142874683},
+  {254U, 2142733729}};
+
+const uint8_t CTCSS_TABLE_DATA_LEN = 50U;
+
+// 4Hz bandwidth
+const uint16_t N = 24000U / 4U;
+
+CFMCTCSSRX::CFMCTCSSRX() :
+m_coeffDivTwo(0),
+m_highThreshold(0),
+m_lowThreshold(0),
+m_count(0U),
+m_q0(0),
+m_q1(0),
+m_result(CTS_NONE)
+{
+}
+
+uint8_t CFMCTCSSRX::setParams(uint8_t frequency, uint8_t highThreshold, uint8_t lowThreshold)
+{
+  m_coeffDivTwo = 0;
+
+  for (uint8_t i = 0U; i < CTCSS_TABLE_DATA_LEN; i++) {
+    if (RX_CTCSS_TABLE_DATA[i].frequency == frequency) {
+      m_coeffDivTwo = RX_CTCSS_TABLE_DATA[i].coeffDivTwo;
+      break;
+    }
+  }
+
+  if (m_coeffDivTwo == 0)
+    return 4U;
+
+  m_highThreshold = q31_t(highThreshold);
+  m_lowThreshold  = q31_t(lowThreshold);
+
+  return 0U;
+}
+
+uint8_t 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;
+
+  // Q31 multiplication, t3 = m_coeffDivTwo * 2 * m_q1
+  q63_t t1 = m_coeffDivTwo * 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 * m_coeffDivTwo;
+    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 previousCTCSSValid = CTCSS_VALID(m_result);
+
+    q31_t threshold = m_highThreshold;
+    if (previousCTCSSValid)
+      threshold = m_lowThreshold;
+
+    m_result |= CTS_READY;
+    if (value >= threshold)
+      m_result |= CTS_VALID;
+    else
+      m_result &= ~CTS_VALID;
+
+    if (previousCTCSSValid != CTCSS_VALID(m_result))
+      DEBUG4("CTCSS Value / Threshold / Valid", value, threshold, CTCSS_VALID(m_result));
+
+    m_count = 0U;
+    m_q0 = 0;
+    m_q1 = 0;
+  }
+
+  return m_result;
+}
+
+void CFMCTCSSRX::reset()
+{
+  m_q0 = 0;
+  m_q1 = 0;
+  m_result = CTS_NONE;
+  m_count  = 0U;
+}

FMCTCSSRX.h

@@ -0,0 +1,53 @@
+/*
+ *   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.
+ */
+
+#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;
+
+#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)
+
+class CFMCTCSSRX {
+public:
+  CFMCTCSSRX();
+
+  uint8_t setParams(uint8_t frequency, uint8_t highThreshold, uint8_t lowThreshold);
+  
+  uint8_t process(q15_t sample);
+
+  void reset();
+
+private:
+  q63_t    m_coeffDivTwo;
+  q31_t    m_highThreshold;
+  q31_t    m_lowThreshold;
+  uint16_t m_count;
+  q31_t    m_q0;
+  q31_t    m_q1;
+  uint8_t  m_result;
+};
+
+#endif

FMCTCSSTX.cpp

@@ -0,0 +1,125 @@
+/*
+ *   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"
+#include "Globals.h"
+#include "FMCTCSSTX.h"
+
+const struct TX_CTCSS_TABLE {
+  uint8_t  frequency;
+  uint16_t length;
+  q31_t    increment;
+} TX_CTCSS_TABLE_DATA[] = {
+  { 67U, 358U, 5995059},
+  { 69U, 346U, 6200860},
+  { 71U, 334U, 6433504},
+  { 74U, 323U, 6657200},
+  { 77U, 312U, 6889844},
+  { 79U, 301U, 7131436},
+  { 82U, 291U, 7381976},
+  { 85U, 281U, 7641463},
+  { 88U, 271U, 7918846},
+  { 91U, 262U, 8187282},
+  { 94U, 253U, 8482561},
+  { 97U, 246U, 8715205},
+  {100U, 240U, 8947849},
+  {103U, 232U, 9261024},
+  {107U, 224U, 9592094},
+  {110U, 216U, 9923165},
+  {114U, 209U, 10272131},
+  {118U, 202U, 10630045},
+  {123U, 195U, 11005854},
+  {127U, 189U, 11390612},
+  {131U, 182U, 11793265},
+  {136U, 176U, 12213814},
+  {141U, 170U, 12643310},
+  {146U, 164U, 13081755},
+  {151U, 159U, 13547043},
+  {156U, 153U, 14021279},
+  {159U, 150U, 14298662},
+  {162U, 148U, 14513411},
+  {165U, 145U, 14808690},
+  {167U, 143U, 15023438},
+  {171U, 140U, 15327665},
+  {173U, 138U, 15551361},
+  {177U, 135U, 15864536},
+  {179U, 133U, 16097180},
+  {183U, 131U, 16419303},
+  {186U, 129U, 16660894},
+  {189U, 126U, 16991965},
+  {192U, 124U, 17251452},
+  {196U, 122U, 17591471},
+  {199U, 120U, 17850958},
+  {203U, 118U, 18208872},
+  {206U, 116U, 18477308},
+  {210U, 114U, 18853117},
+  {218U, 110U, 19515258},
+  {225U, 106U, 20195295},
+  {229U, 105U, 20499521},
+  {233U, 103U, 20902175},
+  {241U,  99U, 21635898},
+  {250U,  96U, 22396465},
+  {254U,  94U, 22736484}};
+
+const uint8_t CTCSS_TABLE_DATA_LEN = 50U;
+
+CFMCTCSSTX::CFMCTCSSTX() :
+m_values(NULL),
+m_length(0U),
+m_n(0U)
+{
+}
+
+uint8_t CFMCTCSSTX::setParams(uint8_t frequency, uint8_t level)
+{
+  const TX_CTCSS_TABLE* entry = NULL;
+
+  for (uint8_t i = 0U; i < CTCSS_TABLE_DATA_LEN; i++) {
+    if (TX_CTCSS_TABLE_DATA[i].frequency == frequency) {
+      entry = TX_CTCSS_TABLE_DATA + i;
+      break;
+    }
+  }
+
+  if (entry == NULL)
+    return 4U;
+
+  m_length = entry->length;
+
+  delete[] m_values;
+  m_values = new q15_t[m_length];
+
+  q31_t arg = 0;
+  for (uint16_t i = 0U; i < m_length; i++) {
+    q63_t value = ::arm_sin_q31(arg) * q63_t(level * 13);
+    m_values[i] = q15_t(__SSAT((value >> 31), 16));
+
+    arg += entry->increment;
+  }
+
+  return 0U;
+}
+
+q15_t CFMCTCSSTX::getAudio()
+{
+  q15_t sample = m_values[m_n++];
+  if(m_n >= m_length)
+    m_n = 0U;
+  
+  return sample;
+}

FMCTCSSTX.h

@@ -0,0 +1,38 @@
+/*
+ *   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.
+ */
+
+#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();
+
+private:
+  q15_t*   m_values;
+  uint16_t m_length;
+  uint16_t m_n;
+};
+
+#endif

FMDirectForm1.h

@@ -0,0 +1,111 @@
+
+/*******************************************************************************
+This header file has been taken from:
+"A Collection of Useful C++ Classes for Digital Signal Processing"
+By Vinnie Falco 
+Bernd Porr adapted it for Linux and turned it into a filter using
+fixed point arithmetic.
+--------------------------------------------------------------------------------
+License: MIT License (http://www.opensource.org/licenses/mit-license.php)
+Copyright (c) 2009 by Vinnie Falco
+Copyright (C) 2013-2017, Bernd Porr, [email protected]
+Copyright (C) 2020 , Mario Molitor , [email protected]
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*******************************************************************************/
+
+// based on https://raw.githubusercontent.com/berndporr/iir_fixed_point/master/DirectFormI.h
+
+#include <cstdint>
+
+#ifndef DIRECTFORMI_H_
+#define DIRECTFORMI_H_
+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)
+	{
+		// FIR coefficients
+		c_b0 = b0;
+		c_b1 = b1;
+		c_b2 = b2;
+		// IIR coefficients
+		c_a1 = a1;
+		c_a2 = a2;
+		reset();
+	}
+
+	CFMDirectFormI(const CFMDirectFormI &my)
+	{
+	// 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
+		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 ()
+	{
+		m_x1 = 0;
+		m_x2 = 0;
+		m_y1 = 0;
+		m_y2 = 0;
+	}
+
+	// filtering operation: one sample in and one out
+	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;
+
+		q15_t out = __SSAT(out_upscaled >> 15, 15);
+
+		// update the delay lines
+		m_x2 = m_x1;
+		m_y2 = m_y1;
+		m_x1 = in;
+		m_y1 = out;
+
+		return out;
+	}
+
+private:
+	// delay line
+	q31_t m_x2; // x[n-2]
+	q31_t m_y2; // y[n-2]
+	q31_t m_x1; // x[n-1]
+	q31_t m_y1; // y[n-1]
+
+	// coefficients
+	q31_t c_b0,c_b1,c_b2; // FIR
+	q31_t c_a1,c_a2; // IIR
+};
+
+#endif /* DIRECTFORMI_H */

FMDownsampler.cpp

@@ -0,0 +1,74 @@
+/*
+ *   Copyright (C) 2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020 by Geoffrey Merck F4FXL - KC3FRA
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   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 "FMDownsampler.h"
+
+CFMDownsampler::CFMDownsampler(uint16_t length) :
+m_ringBuffer(length),
+m_samplePack(0U),
+m_samplePackPointer(NULL),
+m_sampleIndex(0U)
+{
+  m_samplePackPointer = (uint8_t*)&m_samplePack;
+}
+
+void CFMDownsampler::addSample(q15_t sample)
+{
+  uint32_t usample = uint32_t(int32_t(sample) + 2048);
+  //only take one of three samples
+  switch(m_sampleIndex){
+    case 0:
+      m_samplePack = usample << 12;
+    break;
+    case 3:{
+      m_samplePack |= usample;
+      
+      //we did not use MSB; skip it
+      TSamplePairPack pair{m_samplePackPointer[0U], m_samplePackPointer[1U], m_samplePackPointer[2U]}; 
+
+      m_ringBuffer.put(pair);
+
+      m_samplePack = 0U;//reset the sample pack
+    }
+    break;
+    default:
+        //Just skip this sample
+    break;
+  }
+
+  m_sampleIndex++;
+  if(m_sampleIndex >= 6U)//did we pack two samples ?
+      m_sampleIndex = 0U;  
+}
+
+bool CFMDownsampler::getPackedData(TSamplePairPack& data)
+{
+  return m_ringBuffer.get(data);
+}
+
+uint16_t CFMDownsampler::getData()
+{
+  return m_ringBuffer.getData();
+}
+
+void CFMDownsampler::reset()
+{
+  m_sampleIndex = 0U;
+}

FMDownsampler.h

@@ -0,0 +1,42 @@
+/*
+ *   Copyright (C) 2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020 by Geoffrey Merck F4FXL - KC3FRA
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#if !defined(FMDOWNSAMPLER_H)
+#define FMDOWNSAMPLER_H
+
+#include "Config.h"
+#include "RingBuffer.h"
+#include "FMSamplePairPack.h"
+
+class CFMDownsampler {
+public:
+  CFMDownsampler(uint16_t length);
+  void addSample(q15_t sample);
+  bool getPackedData(TSamplePairPack& data);
+  uint16_t getData();
+  void reset();
+
+private:
+  CRingBuffer<TSamplePairPack> m_ringBuffer;
+  uint32_t                     m_samplePack;
+  uint8_t*                     m_samplePackPointer;
+  uint8_t                      m_sampleIndex;
+};
+
+#endif

FMKeyer.cpp

@@ -0,0 +1,216 @@
+/*
+ *   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"
+#include "Globals.h"
+#include "FMKeyer.h"
+
+const struct {
+  char     c;
+  uint32_t pattern;
+  uint8_t  length;
+} SYMBOL_LIST[] = {
+  {'A', 0xB8000000U, 8U},
+  {'B', 0xEA800000U, 12U},
+  {'C', 0xEBA00000U, 14U},
+  {'D', 0xEA000000U, 10U},
+  {'E', 0x80000000U, 4U},
+  {'F', 0xAE800000U, 12U},
+  {'G', 0xEE800000U, 12U},
+  {'H', 0xAA000000U, 10U},
+  {'I', 0xA0000000U, 6U},
+  {'J', 0xBBB80000U, 16U},
+  {'K', 0xEB800000U, 12U},
+  {'L', 0xBA800000U, 12U},
+  {'M', 0xEE000000U, 10U},
+  {'N', 0xE8000000U, 8U},
+  {'O', 0xEEE00000U, 14U},
+  {'P', 0xBBA00000U, 14U},
+  {'Q', 0xEEB80000U, 16U},
+  {'R', 0xBA000000U, 10U},
+  {'S', 0xA8000000U, 8U},
+  {'T', 0xE0000000U, 6U},
+  {'U', 0xAE000000U, 10U},
+  {'V', 0xAB800000U, 12U},
+  {'W', 0xBB800000U, 12U},
+  {'X', 0xEAE00000U, 14U},
+  {'Y', 0xEBB80000U, 16U},
+  {'Z', 0xEEA00000U, 14U},
+  {'1', 0xBBBB8000U, 20U},
+  {'2', 0xAEEE0000U, 18U},
+  {'3', 0xABB80000U, 16U},
+  {'4', 0xAAE00000U, 14U},
+  {'5', 0xAA800000U, 12U},
+  {'6', 0xEAA00000U, 14U},
+  {'7', 0xEEA80000U, 16U},
+  {'8', 0xEEEA0000U, 18U},
+  {'9', 0xEEEE8000U, 20U},
+  {'0', 0xEEEEE000U, 22U},
+  {'/', 0xEAE80000U, 16U},
+  {'?', 0xAEEA0000U, 18U},
+  {',', 0xEEAEE000U, 22U},
+  {'-', 0xEAAE0000U, 18U},
+  {'=', 0xEAB80000U, 16U},
+  {'.', 0xBAEB8000U, 20U},
+  {' ', 0x00000000U, 4U},
+  {0U,  0x00000000U, 0U}
+};
+
+const uint8_t BIT_MASK_TABLE[] = {0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02U, 0x01U};
+
+#define WRITE_BIT_FM(p,i,b) p[(i)>>3] = (b) ? (p[(i)>>3] | BIT_MASK_TABLE[(i)&7]) : (p[(i)>>3] & ~BIT_MASK_TABLE[(i)&7])
+#define READ_BIT_FM(p,i)    (p[(i)>>3] & BIT_MASK_TABLE[(i)&7])
+
+CFMKeyer::CFMKeyer() :
+m_wanted(false),
+m_poBuffer(),
+m_poLen(0U),
+m_poPos(0U),
+m_dotLen(0U),
+m_dotPos(0U),
+m_audio(NULL),
+m_audioLen(0U),
+m_audioPos(0U),
+m_highLevel(0U),
+m_lowLevel(0)
+{
+}
+
+uint8_t CFMKeyer::setParams(const char* text, uint8_t speed, uint16_t frequency, uint8_t highLevel, uint8_t lowLevel)
+{
+  m_poLen = 0U;
+
+  for (uint8_t i = 0U; text[i] != '\0'; i++) {
+    for (uint8_t j = 0U; SYMBOL_LIST[j].c != 0U; j++) {
+      if (SYMBOL_LIST[j].c == text[i]) {
+        uint32_t MASK = 0x80000000U;
+        for (uint8_t k = 0U; k < SYMBOL_LIST[j].length; k++, m_poLen++, MASK >>= 1) {
+          bool b = (SYMBOL_LIST[j].pattern & MASK) == MASK;
+          WRITE_BIT_FM(m_poBuffer, m_poLen, b);
+
+          if (m_poLen >= 995U) {
+            m_poLen = 0U;
+            return 4U;
+          }
+        }
+
+        break;
+      }
+    }
+  }
+
+  m_highLevel = q15_t(highLevel);
+  m_lowLevel  = q15_t(lowLevel);
+
+  m_dotLen = 24000U / speed;   // In samples
+
+  m_audioLen = 24000U / frequency; // In samples
+
+  delete[] m_audio;
+  m_audio = new bool[m_audioLen];
+
+  for (uint16_t i = 0U; i < m_audioLen; i++) {
+    if (i < (m_audioLen / 2U))
+      m_audio[i] = true;
+    else
+      m_audio[i] = false;
+  }
+
+  return 0U;
+}
+
+q15_t CFMKeyer::getHighAudio()
+{
+  q15_t output = 0U;
+  if (!m_wanted)
+    return 0U;
+
+  bool b = READ_BIT_FM(m_poBuffer, m_poPos);
+  if (b)
+    output = m_audio[m_audioPos] ? m_highLevel : -m_highLevel;
+
+  m_audioPos++;
+  if (m_audioPos >= m_audioLen)
+    m_audioPos = 0U;
+  m_dotPos++;
+  if (m_dotPos >= m_dotLen) {
+    m_dotPos = 0U;
+    m_poPos++;
+    if (m_poPos >= m_poLen) {
+      stop();
+      return output;
+    }
+  }
+
+  return output;
+}
+
+q15_t CFMKeyer::getLowAudio()
+{
+  q15_t output = 0U;
+  if (!m_wanted)
+    return 0U;
+
+  bool b = READ_BIT_FM(m_poBuffer, m_poPos);
+  if (b)
+    output = m_audio[m_audioPos] ? m_lowLevel : -m_lowLevel;
+
+  m_audioPos++;
+  if (m_audioPos >= m_audioLen)
+    m_audioPos = 0U;
+  m_dotPos++;
+  if (m_dotPos >= m_dotLen) {
+    m_dotPos = 0U;
+    m_poPos++;
+    if (m_poPos >= m_poLen) {
+      stop();
+      return output;
+    }
+  }
+
+  return output;
+}
+
+void CFMKeyer::start()
+{
+  if (isRunning())
+    return;
+
+  m_wanted   = true;
+  m_poPos    = 0U;
+  m_dotPos   = 0U;
+  m_audioPos = 0U;
+}
+
+void CFMKeyer::stop()
+{
+  m_wanted   = false;
+  m_poPos    = 0U;
+  m_dotPos   = 0U;
+  m_audioPos = 0U;
+}
+
+bool CFMKeyer::isWanted() const
+{
+  return m_wanted;
+}
+
+bool CFMKeyer::isRunning() const
+{
+  return m_poPos > 0U || m_dotPos > 0U || m_audioPos > 0U;
+}

FMKeyer.h

@@ -0,0 +1,54 @@
+/*
+ *   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.
+ */
+
+#if !defined(FMKeyer_H)
+#define  FMKeyer_H
+
+#include "Config.h"
+
+class CFMKeyer {
+public:
+  CFMKeyer();
+
+  uint8_t setParams(const char* text, uint8_t speed, uint16_t frequency, uint8_t highLevel, uint8_t lowLevel);
+
+  q15_t getHighAudio();
+  q15_t getLowAudio();
+
+  void start();
+  void stop();
+
+  bool isRunning() const;
+
+  bool isWanted() const;
+
+private:
+  bool     m_wanted;
+  uint8_t  m_poBuffer[1000U];
+  uint16_t m_poLen;
+  uint16_t m_poPos;
+  uint16_t m_dotLen;
+  uint16_t m_dotPos;
+  bool*    m_audio;
+  uint16_t m_audioLen;
+  uint16_t m_audioPos;
+  q15_t    m_highLevel;
+  q15_t    m_lowLevel;
+};
+
+#endif

FMSamplePairPack.h

@@ -0,0 +1,29 @@
+/*
+ *   Copyright (C) 2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020 by Geoffrey Merck F4FXL - KC3FRA
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#if !defined(TSAMPLEPACK_H)
+#define TSAMPLEPACK_H
+
+struct TSamplePairPack {
+  uint8_t byte0;
+  uint8_t byte1;
+  uint8_t byte2;
+};
+
+#endif

FMTimeout.cpp

@@ -0,0 +1,76 @@
+/*
+ *   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"
+#include "Globals.h"
+#include "FMTimeout.h"
+
+// 400 Hz sine wave at 24000 Hz sample rate
+const q15_t BUSY_AUDIO[] = {0, 3426, 6813, 10126, 13328, 16384, 19261, 21926, 24351, 26510, 28378, 29935, 31164, 32052, 32588, 32767, 32588, 32052, 31164, 29935, 28378, 26510, 24351,
+                            21926, 19261, 16384, 13328, 10126, 6813, 3425, 0, -3425, -6813, -10126, -13328, -16384, -19261, -21926, -24351, -26510, -28378, -29935, -31164, -32052,
+                            -32588, -32768, -32588, -32052, -31164, -29935, -28378, -26510, -24351, -21926, -19261, -16384, -13328, -10126, -6813, -3425};
+const uint8_t BUSY_AUDIO_LEN = 60U;
+
+CFMTimeout::CFMTimeout() :
+m_level(128 * 128),
+m_running(false),
+m_pos(0U),
+m_n(0U)
+{
+}
+
+void CFMTimeout::setParams(uint8_t level)
+{
+  m_level = q15_t(level * 128);
+}
+
+q15_t CFMTimeout::getAudio()
+{
+  q15_t sample = 0U;
+  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));
+
+    m_n++;
+    if (m_n >= BUSY_AUDIO_LEN)
+      m_n = 0U;
+  } else {
+    sample = 0U;
+  }
+
+  m_pos++;
+  if (m_pos >= 24000U)
+    m_pos = 0U;
+
+  return sample;
+}
+
+void CFMTimeout::start()
+{
+  m_running = true;
+  m_pos = 0U;
+  m_n   = 0U;
+}
+
+void CFMTimeout::stop()
+{
+  m_running = false;
+}

FMTimeout.h

@@ -0,0 +1,42 @@
+/*
+ *   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.
+ */
+
+#if !defined(FMTimeout_H)
+#define  FMTimeout_H
+
+#include "Config.h"
+
+class CFMTimeout {
+public:
+  CFMTimeout();
+
+  void setParams(uint8_t level);
+
+  void start();
+  void stop();
+
+  q15_t getAudio();
+
+private:
+  q15_t    m_level;
+  bool     m_running;
+  uint32_t m_pos;
+  uint8_t  m_n;
+};
+
+#endif

FMTimer.cpp

@@ -0,0 +1,70 @@
+/*
+ *   Copyright (C) 2009,2010,2015,2020 by Jonathan Naylor G4KLX
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "Config.h"
+#include "Globals.h"
+#include "FMTimer.h"
+
+CFMTimer::CFMTimer() :
+m_timeout(0U),
+m_timer(0U)
+{
+}
+
+void CFMTimer::setTimeout(uint16_t secs, uint32_t msecs)
+{
+  m_timeout = (secs * 24000U) + (msecs * 24U);
+}
+
+uint32_t CFMTimer::getTimeout() const
+{
+  return m_timeout / 24U;
+}
+
+void CFMTimer::start()
+{
+  if (m_timeout > 0U)
+    m_timer = 1U;
+}
+
+void CFMTimer::stop()
+{
+  m_timer = 0U;
+}
+
+void CFMTimer::clock(uint8_t length)
+{
+  if (m_timer > 0U && m_timeout > 0U)
+    m_timer += length;
+}
+
+bool CFMTimer::isRunning() const
+{
+  return m_timer > 0U;
+}
+
+bool CFMTimer::hasExpired() const
+{
+  if (m_timeout == 0U || m_timer == 0U)
+    return false;
+
+  if (m_timer > m_timeout)
+    return true;
+
+  return false;
+}

FMTimer.h

@@ -0,0 +1,47 @@
+/*
+ *   Copyright (C) 2009,2010,2015,2020 by Jonathan Naylor G4KLX
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#if !defined(FMTimer_H)
+#define  FMTimer_H
+
+#include "Config.h"
+
+class CFMTimer {
+public:
+  CFMTimer();
+
+  void setTimeout(uint16_t secs, uint32_t msecs);
+
+  uint32_t getTimeout() const;
+
+  void start();
+  
+  void stop();
+
+  void clock(uint8_t length);
+
+  bool isRunning() const;
+  
+  bool hasExpired() const;
+
+private:
+  uint32_t m_timeout;
+  uint32_t m_timer;
+};
+
+#endif

FMUpSampler.cpp

@@ -0,0 +1,97 @@
+/*
+ *   Copyright (C) 2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020 by Geoffrey Merck F4FXL - KC3FRA
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   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 "FMUpSampler.h"
+
+const uint32_t FM_UPSAMPLE_MASK = 0x00000FFFU;
+
+CFMUpSampler::CFMUpSampler() :
+m_upSampleIndex(0),
+m_pack(0U),
+m_packPointer(NULL),
+m_samples(3600U), //300ms of 12 bit 8kHz audio
+m_running(false)
+{
+  m_packPointer = (uint8_t*)&m_pack;
+}
+
+void CFMUpSampler::reset()
+{
+    m_upSampleIndex = 0U;
+    m_pack = 0U;
+    m_samples.reset();
+    m_running = false;
+}
+
+void CFMUpSampler::addData(const uint8_t* data, uint16_t length)
+{
+  TSamplePairPack* packPointer = (TSamplePairPack*)data;
+  TSamplePairPack* packPointerEnd = packPointer + (length / 3U);
+  while(packPointer != packPointerEnd) {
+    m_samples.put(*packPointer);
+    packPointer++;
+  }
+  if(!m_running)
+    m_running = m_samples.getData() > 300U;//75ms of audio
+}
+
+bool CFMUpSampler::getSample(q15_t& sample)
+{
+  if(!m_running)
+    return false;
+
+  switch (m_upSampleIndex)
+  {
+  case 0: {
+    TSamplePairPack pairPack;
+    if(!m_samples.get(pairPack)) {
+      m_running = false;
+      return false;
+    }
+      
+    m_pack = 0U;
+    m_packPointer = (uint8_t*)&m_pack;
+
+    m_packPointer[0U] = pairPack.byte0;
+    m_packPointer[1U] = pairPack.byte1;
+    m_packPointer[2U] = pairPack.byte2;
+
+    sample = q15_t(m_pack >> 12) - 2048;
+    break;
+  }
+  case 3:
+    sample = q15_t(m_pack & FM_UPSAMPLE_MASK) - 2048;
+  break;
+  default:
+    sample = 0;
+  break;
+  }
+
+  m_upSampleIndex++;
+  if(m_upSampleIndex >= 6U)
+    m_upSampleIndex = 0U;
+
+  return true;
+}
+
+uint16_t CFMUpSampler::getSpace() const
+{
+  //return available space in bytes
+  return m_samples.getSpace() * sizeof(TSamplePairPack);
+}

FMUpSampler.h

@@ -0,0 +1,48 @@
+/*
+ *   Copyright (C) 2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020 by Geoffrey Merck F4FXL - KC3FRA
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#if !defined(FMUPSAMPLER_H)
+#define FMUPSAMPLER_H
+
+#include "Config.h"
+#include "RingBuffer.h"
+#include "FMSamplePairPack.h"
+
+class CFMUpSampler {
+public:
+  CFMUpSampler();
+
+  void reset();
+
+  void addData(const uint8_t* data, uint16_t length);
+
+  bool getSample(q15_t& sample);
+
+  uint16_t getSpace() const;
+
+private:
+  uint8_t m_upSampleIndex;
+  uint32_t m_pack;
+  uint8_t * m_packPointer;
+  CRingBuffer<TSamplePairPack> m_samples;
+  bool m_running;
+};
+
+#endif

Globals.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016 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
@@ -19,15 +19,23 @@
 #if !defined(GLOBALS_H)
 #define  GLOBALS_H
 
-#if defined(STM32F4XX) || defined(STM32F4)
+#if defined(STM32F4XX)
 #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__)
+#if defined(__SAM3X8E__) || defined(STM32F105xC)
 #define  ARM_MATH_CM3
-#elif defined(STM32F4XX) || defined(STM32F4) || defined(__MK20DX256__) || defined(__MK64FX512__) || defined(__MK66FX1M0__)
+#elif defined(STM32F7XX)
+#define  ARM_MATH_CM7
+#elif defined(STM32F4XX) || defined(__MK20DX256__) || defined(__MK64FX512__) || defined(__MK66FX1M0__)
 #define  ARM_MATH_CM4
 #else
 #error "Unknown processor type"
@@ -41,11 +49,28 @@ enum MMDVM_STATE {
   STATE_DMR       = 2,
   STATE_YSF       = 3,
   STATE_P25       = 4,
+  STATE_NXDN      = 5,
+  STATE_POCSAG    = 6,
+  STATE_FM        = 10,
 
   // Dummy states start at 90
+  STATE_NXDNCAL1K = 91,
+  STATE_DMRDMO1K  = 92,
+  STATE_P25CAL1K  = 93,
+  STATE_DMRCAL1K  = 94,
+  STATE_LFCAL     = 95,
+  STATE_RSSICAL   = 96,
   STATE_CWID      = 97,
   STATE_DMRCAL    = 98,
-  STATE_DSTARCAL  = 99
+  STATE_DSTARCAL  = 99,
+  STATE_INTCAL    = 100,
+  STATE_POCSAGCAL = 101,
+  STATE_FMCAL10K  = 102,
+  STATE_FMCAL12K  = 103,
+  STATE_FMCAL15K  = 104,
+  STATE_FMCAL20K  = 105,
+  STATE_FMCAL25K  = 106,
+  STATE_FMCAL30K  = 107
 };
 
 #include "SerialPort.h"
@@ -60,12 +85,21 @@ enum MMDVM_STATE {
 #include "YSFTX.h"
 #include "P25RX.h"
 #include "P25TX.h"
+#include "NXDNRX.h"
+#include "NXDNTX.h"
+#include "POCSAGTX.h"
 #include "CalDStarRX.h"
 #include "CalDStarTX.h"
+#include "CalFM.h"
 #include "CalDMR.h"
+#include "CalP25.h"
+#include "CalNXDN.h"
+#include "CalPOCSAG.h"
+#include "CalRSSI.h"
 #include "CWIdTX.h"
 #include "Debug.h"
 #include "IO.h"
+#include "FM.h"
 
 const uint8_t  MARK_SLOT1 = 0x08U;
 const uint8_t  MARK_SLOT2 = 0x04U;
@@ -76,21 +110,27 @@ 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__)
+const uint16_t TX_BUFFER_LEN = 2000U;
+#else
+const uint16_t TX_BUFFER_LEN = 4000U;
+#endif
+
 extern MMDVM_STATE m_modemState;
 
 extern bool m_dstarEnable;
 extern bool m_dmrEnable;
 extern bool m_ysfEnable;
 extern bool m_p25Enable;
+extern bool m_nxdnEnable;
+extern bool m_pocsagEnable;
+extern bool m_fmEnable;
 
 extern bool m_duplex;
 
 extern bool m_tx;
 extern bool m_dcd;
 
-extern uint32_t m_sampleCount;
-extern bool     m_sampleInsert;
-
 extern CSerialPort serial;
 extern CIO io;
 
@@ -110,11 +150,22 @@ extern CYSFTX ysfTX;
 extern CP25RX p25RX;
 extern CP25TX p25TX;
 
+extern CNXDNRX nxdnRX;
+extern CNXDNTX nxdnTX;
+
+extern CPOCSAGTX pocsagTX;
+
+extern CFM fm;
+
 extern CCalDStarRX calDStarRX;
 extern CCalDStarTX calDStarTX;
 extern CCalDMR     calDMR;
+extern CCalFM      calFM;
+extern CCalP25     calP25;
+extern CCalNXDN    calNXDN;
+extern CCalPOCSAG  calPOCSAG;
+extern CCalRSSI    calRSSI;
 
 extern CCWIdTX cwIdTX;
 
 #endif
-

I2CTeensy.cpp

@@ -0,0 +1,235 @@
+/*
+ *   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.
+ *
+ *   28-4-2017 Created for MMDVM Pi shield for Teensy by Chris Huitema
+ */
+
+#include "Config.h"
+#include "Globals.h"
+
+#if defined(VK6MST_TEENSY_PI3_SHIELD_I2C)
+
+#include <i2c_t3.h>   //available here https://github.com/nox771/i2c_t3 or maybe the normal wire will work #include <wire.h> justs need to test i guess
+
+#define I2C_ADDRESS   0x22
+#define I2C_SPEED     100000
+
+// Function prototypes
+void receiveEvent(size_t count);
+void requestEvent(void);
+
+#define TX_FIFO_SIZE 512U
+#define RX_FIFO_SIZE 512U
+
+volatile uint8_t  TXfifo[TX_FIFO_SIZE];
+volatile uint8_t  RXfifo[RX_FIFO_SIZE];
+volatile uint16_t TXfifohead, TXfifotail;
+volatile uint16_t RXfifohead, RXfifotail;
+
+// Init queues
+void TXfifoinit(void)
+{
+   TXfifohead = 0U;
+   TXfifotail = 0U;
+}
+
+void RXfifoinit()
+{
+   RXfifohead = 0U;
+   RXfifotail = 0U;
+}
+
+// How full is queue
+
+uint16_t TXfifolevel(void)
+{
+   uint32_t tail = TXfifotail;
+   uint32_t head = TXfifohead;
+
+   if (tail > head)
+      return TX_FIFO_SIZE + head - tail;
+   else
+      return head - tail;
+}
+
+uint16_t RXfifolevel(void)
+{
+   uint32_t tail = RXfifotail;
+   uint32_t head = RXfifohead;
+
+   if (tail > head)
+      return RX_FIFO_SIZE + head - tail;
+   else
+      return head - tail;
+}
+
+
+uint8_t TXfifoput(uint8_t next)
+{
+   if (TXfifolevel() < TX_FIFO_SIZE) {
+      TXfifo[TXfifohead] = next;
+
+      TXfifohead++;
+      if (TXfifohead >= TX_FIFO_SIZE)
+         TXfifohead = 0U;
+      return 1U;
+   } else {
+      return 0U; // signal an overflow occurred by returning a zero count
+   }
+}
+
+void I2Cbegin(void)
+{
+  // Setup for Slave mode, address 0x22, pins 18/19, external pullups, speed in hz
+  Wire.begin(I2C_SLAVE, I2C_ADDRESS, I2C_PINS_18_19, I2C_PULLUP_EXT, I2C_SPEED);
+
+    // register events
+    Wire.onReceive(receiveEvent);
+    Wire.onRequest(requestEvent);
+
+    // initialize the fifos
+    TXfifoinit();
+    RXfifoinit();
+}
+
+
+int I2Cavailable(void)
+{
+  if (RXfifolevel() > 0U)
+      return 1U;
+    else
+      return 0U;
+}
+
+
+uint8_t I2Cread(void)
+{
+  uint8_t data_c = RXfifo[RXfifotail];
+
+   RXfifotail++;
+   if (RXfifotail >= RX_FIFO_SIZE)
+      RXfifotail = 0U;
+
+   return data_c;
+}
+
+
+void I2Cwrite(const uint8_t* data, uint16_t length)
+{
+   for (uint16_t i = 0U; i < length; i++)
+      TXfifoput(data[i]);   //puts it in the fifo
+}
+
+//
+// handle Rx Event (incoming I2C data)
+//
+void receiveEvent(size_t count)
+{
+  for (uint16_t i = 0U; i < count; i++)
+  {
+    if (RXfifolevel() < RX_FIFO_SIZE) {
+      RXfifo[RXfifohead] = Wire.readByte();
+      if (RXfifo[RXfifohead] != -1){
+        RXfifohead++;
+        if (RXfifohead >= RX_FIFO_SIZE) RXfifohead = 0U;
+      }
+    } else {
+      Wire.readByte();                  // drop data if mem full.
+    }
+    
+  }
+}
+
+//
+// handle Tx Event (outgoing I2C data)
+//
+void requestEvent(void)
+{
+    if (TXfifolevel() > 0) {
+      if (Wire.write(TXfifo[TXfifotail])){  //write to i2c
+        TXfifotail++;
+        if (TXfifotail >= TX_FIFO_SIZE) TXfifotail = 0U;
+      }  
+    }
+}
+
+
+
+/************************************/
+
+void CSerialPort::beginInt(uint8_t n, int speed)
+{
+  switch (n) {
+    case 1U:
+      return I2Cbegin();
+    case 3U:
+      Serial3.begin(speed);
+      break;
+    default:
+      break;
+  }
+}
+
+int CSerialPort::availableInt(uint8_t n)
+{
+  switch (n) {
+    case 1U:
+      return I2Cavailable();
+    case 3U:
+      return Serial3.available();
+    default:
+      return false;
+  }
+}
+
+int CSerialPort::availableForWriteInt(uint8_t n)
+{
+  switch (n) {
+    case 3U:
+      return Serial3.availableForWrite();
+    default:
+      return false;
+  }
+}
+
+uint8_t CSerialPort::readInt(uint8_t n)
+{
+  switch (n) {
+    case 1U:
+      return I2Cread();
+    case 3U:
+      return Serial3.read();
+    default:
+      return 0U;
+  }
+}
+
+void CSerialPort::writeInt(uint8_t n, const uint8_t* data, uint16_t length, bool flush)
+{
+  switch (n) {
+    case 1U:
+      I2Cwrite(data, length);
+      break;
+    case 3U:
+      Serial3.write(data, length);
+      if (flush)
+        Serial3.flush();
+      break;
+    default:
+      break;
+  }
+}
+
+#endif

IO.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2015 by Jim Mclaughlin KI6ZUM
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *
@@ -18,28 +18,39 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-// #define  WANT_DEBUG
-
 #include "Config.h"
 #include "Globals.h"
 #include "IO.h"
 
-#if defined(WIDE_C4FSK_FILTERS_RX)
-// Generated using rcosdesign(0.2, 4, 5, 'sqrt') in MATLAB
-static q15_t C4FSK_FILTER[] = {688, -680, -2158, -3060, -2724, -775, 2684, 7041, 11310, 14425, 15565, 14425,
-                                   11310, 7041, 2684, -775, -2724, -3060, -2158, -680, 688, 0};
-const uint16_t C4FSK_FILTER_LEN = 22U;
-#else
+// 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
+
 // Generated using rcosdesign(0.2, 8, 5, 'sqrt') in MATLAB
-static q15_t C4FSK_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 C4FSK_FILTER_LEN = 42U;
-#endif
+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;
+
+// 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,
+                                  10134, 10731, 10935, 10731, 10134, 9184, 7946, 6502, 4946, 3376, 1886, 557, -545, -1375, -1914, -2164, -2150,
+                                  -1915, -1516, -1016, -477, 39, 483, 819, 1026, 1097, 1041, 880, 643, 364, 79, -181, -391, -533, -599, -590,
+                                  -517, -393, -240, -78, 73, 198, 284, 0};
+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;
 
 // Generated using gaussfir(0.5, 4, 5) in MATLAB
-static q15_t   GMSK_FILTER[] = {8, 104, 760, 3158, 7421, 9866, 7421, 3158, 760, 104, 8, 0};
-const uint16_t GMSK_FILTER_LEN = 12U;
+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;
+
+// One symbol boxcar filter
+static q15_t   BOXCAR_FILTER[] = {12000, 12000, 12000, 12000, 12000, 0};
+const uint16_t BOXCAR_FILTER_LEN = 6U;
 
 const uint16_t DC_OFFSET = 2048U;
 
@@ -48,10 +59,18 @@ m_started(false),
 m_rxBuffer(RX_RINGBUFFER_SIZE),
 m_txBuffer(TX_RINGBUFFER_SIZE),
 m_rssiBuffer(RX_RINGBUFFER_SIZE),
-m_C4FSKFilter(),
-m_GMSKFilter(),
-m_C4FSKState(),
-m_GMSKState(),
+m_dcFilter(),
+m_dcState(),
+m_rrcFilter(),
+m_gaussianFilter(),
+m_boxcarFilter(),
+m_nxdnFilter(),
+m_nxdnISincFilter(),
+m_rrcState(),
+m_gaussianState(),
+m_boxcarState(),
+m_nxdnState(),
+m_nxdnISincState(),
 m_pttInvert(false),
 m_rxLevel(128 * 128),
 m_cwIdTXLevel(128 * 128),
@@ -59,27 +78,136 @@ m_dstarTXLevel(128 * 128),
 m_dmrTXLevel(128 * 128),
 m_ysfTXLevel(128 * 128),
 m_p25TXLevel(128 * 128),
+m_nxdnTXLevel(128 * 128),
+m_pocsagTXLevel(128 * 128),
+m_fmTXLevel(128 * 128),
+m_rxDCOffset(DC_OFFSET),
+m_txDCOffset(DC_OFFSET),
 m_ledCount(0U),
 m_ledValue(true),
 m_detect(false),
 m_adcOverflow(0U),
 m_dacOverflow(0U),
-m_count(0U),
 m_watchdog(0U),
 m_lockout(false)
 {
-  ::memset(m_C4FSKState, 0x00U, 70U * sizeof(q15_t));
-  ::memset(m_GMSKState,  0x00U, 40U * sizeof(q15_t));
+  ::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));
 
-  m_C4FSKFilter.numTaps = C4FSK_FILTER_LEN;
-  m_C4FSKFilter.pState  = m_C4FSKState;
-  m_C4FSKFilter.pCoeffs = C4FSK_FILTER;
+  m_dcFilter.numStages = DC_FILTER_STAGES;
+  m_dcFilter.pState    = m_dcState;
+  m_dcFilter.pCoeffs   = DC_FILTER;
+  m_dcFilter.postShift = 0;
 
-  m_GMSKFilter.numTaps = GMSK_FILTER_LEN;
-  m_GMSKFilter.pState  = m_GMSKState;
-  m_GMSKFilter.pCoeffs = GMSK_FILTER;
+  m_rrcFilter.numTaps = RRC_0_2_FILTER_LEN;
+  m_rrcFilter.pState  = m_rrcState;
+  m_rrcFilter.pCoeffs = RRC_0_2_FILTER;
+
+  m_gaussianFilter.numTaps = GAUSSIAN_0_5_FILTER_LEN;
+  m_gaussianFilter.pState  = m_gaussianState;
+  m_gaussianFilter.pCoeffs = GAUSSIAN_0_5_FILTER;
+
+  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;
+  
+  m_nxdnISincFilter.numTaps = NXDN_ISINC_FILTER_LEN;
+  m_nxdnISincFilter.pState  = m_nxdnISincState;
+  m_nxdnISincFilter.pCoeffs = NXDN_ISINC_FILTER;
 
   initInt();
+  
+  selfTest();
+}
+
+void CIO::selfTest()
+{
+  bool ledValue = false;
+
+  for (uint8_t i = 0; i < 6; i++) {
+    ledValue = !ledValue;
+
+    // We exclude PTT to avoid trigger the transmitter
+    setLEDInt(ledValue);
+    setCOSInt(ledValue);
+#if defined(MODE_LEDS)
+    setDStarInt(ledValue);
+    setDMRInt(ledValue);
+    setYSFInt(ledValue);
+    setP25Int(ledValue);
+    setNXDNInt(ledValue);
+    setPOCSAGInt(ledValue);
+    setFMInt(ledValue);
+#endif
+    delayInt(250);
+  }
+
+#if defined(MODE_LEDS)
+  setDStarInt(true);
+  setDMRInt(false);
+  setYSFInt(false);
+  setP25Int(false);
+  setNXDNInt(false);
+  setPOCSAGInt(false);
+  setFMInt(false);
+
+  delayInt(250);
+  setDMRInt(true);
+
+  delayInt(250);
+  setYSFInt(true);
+
+  delayInt(250);
+  setP25Int(true);
+
+#if !defined(USE_ALTERNATE_NXDN_LEDS)
+  delayInt(250);
+  setNXDNInt(true);
+#endif
+
+#if !defined(USE_ALTERNATE_POCSAG_LEDS)
+  delayInt(250);
+  setPOCSAGInt(true);
+#endif
+
+#if !defined(USE_ALTERNATE_FM_LEDS)
+  delayInt(250);
+  setFMInt(true);
+
+  delayInt(250);
+  setFMInt(false);
+#endif
+
+#if !defined(USE_ALTERNATE_POCSAG_LEDS)
+  delayInt(250);
+  setPOCSAGInt(false);
+#endif
+
+#if !defined(USE_ALTERNATE_NXDN_LEDS)
+  delayInt(250);
+  setNXDNInt(false);
+#endif
+
+  delayInt(250);
+  setP25Int(false);
+
+  delayInt(250);
+  setYSFInt(false);
+
+  delayInt(250);
+  setDMRInt(false);
+
+  delayInt(250);
+  setDStarInt(false);
+#endif
 }
 
 void CIO::start()
@@ -89,7 +217,6 @@ void CIO::start()
 
   startInt();
 
-  m_count   = 0U;
   m_started = true;
 
   setMode();
@@ -101,7 +228,7 @@ void CIO::process()
   if (m_started) {
     // Two seconds timeout
     if (m_watchdog >= 48000U) {
-      if (m_modemState == STATE_DSTAR || m_modemState == STATE_DMR || m_modemState == STATE_YSF) {
+      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 (m_modemState == STATE_DMR && m_tx)
           dmrTX.setStart(false);
         m_modemState = STATE_IDLE;
@@ -111,11 +238,15 @@ void CIO::process()
       m_watchdog = 0U;
     }
 
+#if defined(CONSTANT_SRV_LED)
+    setLEDInt(true);
+#else
     if (m_ledCount >= 24000U) {
       m_ledCount = 0U;
       m_ledValue = !m_ledValue;
       setLEDInt(m_ledValue);
     }
+#endif
   } else {
     if (m_ledCount >= 240000U) {
       m_ledCount = 0U;
@@ -133,118 +264,180 @@ void CIO::process()
   if (m_txBuffer.getData() == 0U && m_tx) {
     m_tx = false;
     setPTTInt(m_pttInvert ? true : false);
+    DEBUG1("TX OFF");
   }
 
   if (m_rxBuffer.getData() >= RX_BLOCK_SIZE) {
-    q15_t    samples[RX_BLOCK_SIZE + 1U];
-    uint8_t  control[RX_BLOCK_SIZE + 1U];
-    uint16_t rssi[RX_BLOCK_SIZE + 1U];
-
-    uint8_t blockSize = RX_BLOCK_SIZE;
+    q15_t    samples[RX_BLOCK_SIZE];
+    uint8_t  control[RX_BLOCK_SIZE];
+    uint16_t rssi[RX_BLOCK_SIZE];
 
     for (uint16_t i = 0U; i < RX_BLOCK_SIZE; i++) {
-      uint16_t sample;
-      m_rxBuffer.get(sample, control[i]);
+      TSample sample;
+      m_rxBuffer.get(sample);
+      control[i] = sample.control;
       m_rssiBuffer.get(rssi[i]);
 
       // Detect ADC overflow
-      if (m_detect && (sample == 0U || sample == 4095U))
+      if (m_detect && (sample.sample == 0U || sample.sample == 4095U))
         m_adcOverflow++;
 
-      q15_t res1 = q15_t(sample) - DC_OFFSET;
+      q15_t res1 = q15_t(sample.sample) - m_rxDCOffset;
       q31_t res2 = res1 * m_rxLevel;
       samples[i] = q15_t(__SSAT((res2 >> 15), 16));
     }
 
-    // Handle the case of the oscillator not being accurate enough
-    if (m_sampleCount > 0U) {
-      m_count += RX_BLOCK_SIZE;
-
-      if (m_count >= m_sampleCount) {
-        if (m_sampleInsert) {
-          blockSize++;
-          samples[RX_BLOCK_SIZE] = 0;
-          for (int8_t i = RX_BLOCK_SIZE - 1; i >= 0; i--)
-            control[i + 1] = control[i];
-        } else {
-          blockSize--;
-          for (uint8_t i = 0U; i < (RX_BLOCK_SIZE - 1U); i++)
-            control[i] = control[i + 1U];
-        }
-
-        m_count -= m_sampleCount;
-      }
-    }
-
     if (m_lockout)
       return;
 
+#if defined(USE_DCBLOCKER)
+    q31_t q31Samples[RX_BLOCK_SIZE];
+    ::arm_q15_to_q31(samples, q31Samples, RX_BLOCK_SIZE);
+
+    q31_t dcValues[RX_BLOCK_SIZE];
+    ::arm_biquad_cascade_df1_q31(&m_dcFilter, q31Samples, dcValues, RX_BLOCK_SIZE);
+
+    q31_t dcLevel = 0;
+    for (uint8_t i = 0U; i < RX_BLOCK_SIZE; i++)
+      dcLevel += dcValues[i];
+    dcLevel /= RX_BLOCK_SIZE;
+
+    q15_t offset = q15_t(__SSAT((dcLevel >> 16), 16));;
+
+    q15_t dcSamples[RX_BLOCK_SIZE];
+    for (uint8_t i = 0U; i < RX_BLOCK_SIZE; i++)
+      dcSamples[i] = samples[i] - offset;
+#endif
+
     if (m_modemState == STATE_IDLE) {
       if (m_dstarEnable) {
-        q15_t GMSKVals[RX_BLOCK_SIZE + 1U];
-        ::arm_fir_fast_q15(&m_GMSKFilter, samples, GMSKVals, blockSize);
-
-        dstarRX.samples(GMSKVals, blockSize);
+        q15_t GMSKVals[RX_BLOCK_SIZE];
+#if defined(USE_DCBLOCKER)
+        ::arm_fir_fast_q15(&m_gaussianFilter, dcSamples, GMSKVals, RX_BLOCK_SIZE);
+#else
+        ::arm_fir_fast_q15(&m_gaussianFilter, samples, GMSKVals, RX_BLOCK_SIZE);
+#endif
+        dstarRX.samples(GMSKVals, rssi, RX_BLOCK_SIZE);
       }
 
-      if (m_dmrEnable || m_ysfEnable || m_p25Enable) {
-        q15_t C4FSKVals[RX_BLOCK_SIZE + 1U];
-        ::arm_fir_fast_q15(&m_C4FSKFilter, samples, C4FSKVals, blockSize);
+      if (m_p25Enable) {
+        q15_t P25Vals[RX_BLOCK_SIZE];
+#if defined(USE_DCBLOCKER)
+        ::arm_fir_fast_q15(&m_boxcarFilter, dcSamples, P25Vals, RX_BLOCK_SIZE);
+#else
+        ::arm_fir_fast_q15(&m_boxcarFilter, samples, P25Vals, RX_BLOCK_SIZE);
+#endif
+        p25RX.samples(P25Vals, rssi, RX_BLOCK_SIZE);
+      }
+
+      if (m_nxdnEnable) {
+        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);
+
+        nxdnRX.samples(NXDNVals, rssi, RX_BLOCK_SIZE);
+      }
+
+      if (m_dmrEnable || m_ysfEnable) {
+        q15_t RRCVals[RX_BLOCK_SIZE];
+        ::arm_fir_fast_q15(&m_rrcFilter, samples, RRCVals, RX_BLOCK_SIZE);
+
+        if (m_ysfEnable)
+          ysfRX.samples(RRCVals, rssi, RX_BLOCK_SIZE);
 
         if (m_dmrEnable) {
           if (m_duplex)
-            dmrIdleRX.samples(C4FSKVals, blockSize);
+            dmrIdleRX.samples(RRCVals, RX_BLOCK_SIZE);
           else
-            dmrDMORX.samples(C4FSKVals, rssi, blockSize);
+            dmrDMORX.samples(RRCVals, rssi, RX_BLOCK_SIZE);
         }
+      }
 
-        if (m_ysfEnable)
-          ysfRX.samples(C4FSKVals, blockSize);
-
-        if (m_p25Enable)
-          p25RX.samples(C4FSKVals, blockSize);
+      if (m_fmEnable) {
+        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_DSTAR) {
       if (m_dstarEnable) {
-        q15_t GMSKVals[RX_BLOCK_SIZE + 1U];
-        ::arm_fir_fast_q15(&m_GMSKFilter, samples, GMSKVals, blockSize);
-
-        dstarRX.samples(GMSKVals, blockSize);
+        q15_t GMSKVals[RX_BLOCK_SIZE];
+#if defined(USE_DCBLOCKER)
+        ::arm_fir_fast_q15(&m_gaussianFilter, dcSamples, GMSKVals, RX_BLOCK_SIZE);
+#else
+        ::arm_fir_fast_q15(&m_gaussianFilter, samples, GMSKVals, RX_BLOCK_SIZE);
+#endif
+        dstarRX.samples(GMSKVals, rssi, RX_BLOCK_SIZE);
       }
     } else if (m_modemState == STATE_DMR) {
       if (m_dmrEnable) {
-        q15_t C4FSKVals[RX_BLOCK_SIZE + 1U];
-        ::arm_fir_fast_q15(&m_C4FSKFilter, samples, C4FSKVals, blockSize);
+        q15_t DMRVals[RX_BLOCK_SIZE];
+        ::arm_fir_fast_q15(&m_rrcFilter, samples, DMRVals, RX_BLOCK_SIZE);
 
         if (m_duplex) {
           // If the transmitter isn't on, use the DMR idle RX to detect the wakeup CSBKs
           if (m_tx)
-            dmrRX.samples(C4FSKVals, rssi, control, blockSize);
+            dmrRX.samples(DMRVals, rssi, control, RX_BLOCK_SIZE);
           else
-            dmrIdleRX.samples(C4FSKVals, blockSize);
+            dmrIdleRX.samples(DMRVals, RX_BLOCK_SIZE);
         } else {
-          dmrDMORX.samples(C4FSKVals, rssi, blockSize);
+          dmrDMORX.samples(DMRVals, rssi, RX_BLOCK_SIZE);
         }
       }
     } else if (m_modemState == STATE_YSF) {
       if (m_ysfEnable) {
-        q15_t C4FSKVals[RX_BLOCK_SIZE + 1U];
-        ::arm_fir_fast_q15(&m_C4FSKFilter, samples, C4FSKVals, blockSize);
-
-        ysfRX.samples(C4FSKVals, blockSize);
+        q15_t YSFVals[RX_BLOCK_SIZE];
+#if defined(USE_DCBLOCKER)
+        ::arm_fir_fast_q15(&m_rrcFilter, dcSamples, YSFVals, RX_BLOCK_SIZE);
+#else
+        ::arm_fir_fast_q15(&m_rrcFilter, samples, YSFVals, RX_BLOCK_SIZE);
+#endif
+        ysfRX.samples(YSFVals, rssi, RX_BLOCK_SIZE);
       }
     } else if (m_modemState == STATE_P25) {
       if (m_p25Enable) {
-        q15_t C4FSKVals[RX_BLOCK_SIZE + 1U];
-        ::arm_fir_fast_q15(&m_C4FSKFilter, samples, C4FSKVals, blockSize);
-
-        p25RX.samples(C4FSKVals, blockSize);
+        q15_t P25Vals[RX_BLOCK_SIZE];
+#if defined(USE_DCBLOCKER)
+        ::arm_fir_fast_q15(&m_boxcarFilter, dcSamples, P25Vals, RX_BLOCK_SIZE);
+#else
+        ::arm_fir_fast_q15(&m_boxcarFilter, samples, P25Vals, RX_BLOCK_SIZE);
+#endif
+        p25RX.samples(P25Vals, rssi, RX_BLOCK_SIZE);
       }
-    } else if (m_modemState == STATE_DSTARCAL) {
-      q15_t GMSKVals[RX_BLOCK_SIZE + 1U];
-      ::arm_fir_fast_q15(&m_GMSKFilter, samples, GMSKVals, blockSize);
+    } else if (m_modemState == STATE_NXDN) {
+      if (m_nxdnEnable) {
+        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);
 
-      calDStarRX.samples(GMSKVals, blockSize);
+        nxdnRX.samples(NXDNVals, rssi, RX_BLOCK_SIZE);
+      }
+    } 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) {
+      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) {
+      calRSSI.samples(rssi, RX_BLOCK_SIZE);
     }
   }
 }
@@ -261,6 +454,7 @@ void CIO::write(MMDVM_STATE mode, q15_t* samples, uint16_t length, const uint8_t
   if (!m_tx) {
     m_tx = true;
     setPTTInt(m_pttInvert ? false : true);
+    DEBUG1("TX ON");
   }
 
   q15_t txLevel = 0;
@@ -277,6 +471,15 @@ void CIO::write(MMDVM_STATE mode, q15_t* samples, uint16_t length, const uint8_t
     case STATE_P25:
       txLevel = m_p25TXLevel;
       break;
+    case STATE_NXDN:
+      txLevel = m_nxdnTXLevel;
+      break;
+    case STATE_POCSAG:
+      txLevel = m_pocsagTXLevel;
+      break;
+    case STATE_FM:
+      txLevel = m_fmTXLevel;
+      break;
     default:
       txLevel = m_cwIdTXLevel;
       break;
@@ -285,16 +488,16 @@ void CIO::write(MMDVM_STATE mode, q15_t* samples, uint16_t length, const uint8_t
   for (uint16_t i = 0U; i < length; i++) {
     q31_t res1 = samples[i] * txLevel;
     q15_t res2 = q15_t(__SSAT((res1 >> 15), 16));
-    uint16_t res3 = uint16_t(res2 + DC_OFFSET);
+    uint16_t res3 = uint16_t(res2 + m_txDCOffset);
 
     // Detect DAC overflow
     if (res3 > 4095U)
       m_dacOverflow++;
 
     if (control == NULL)
-      m_txBuffer.put(res3, MARK_NONE);
+      m_txBuffer.put({res3, MARK_NONE});
     else
-      m_txBuffer.put(res3, control[i]);
+      m_txBuffer.put({res3, control[i]});
   }
 }
 
@@ -318,33 +521,44 @@ void CIO::setADCDetection(bool detect)
 
 void CIO::setMode()
 {
-#if defined(ARDUINO_MODE_PINS)
+#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);
 #endif
 }
 
-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)
+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)
 {
   m_pttInvert = pttInvert;
 
-  m_rxLevel      = q15_t(rxLevel * 128);
-  m_cwIdTXLevel  = q15_t(cwIdTXLevel * 128);
-  m_dstarTXLevel = q15_t(dstarTXLevel * 128);
-  m_dmrTXLevel   = q15_t(dmrTXLevel * 128);
-  m_ysfTXLevel   = q15_t(ysfTXLevel * 128);
-  m_p25TXLevel   = q15_t(p25TXLevel * 128);
+  m_rxLevel       = q15_t(rxLevel * 128);
+  m_cwIdTXLevel   = q15_t(cwIdTXLevel * 128);
+  m_dstarTXLevel  = q15_t(dstarTXLevel * 128);
+  m_dmrTXLevel    = q15_t(dmrTXLevel * 128);
+  m_ysfTXLevel    = q15_t(ysfTXLevel * 128);
+  m_p25TXLevel    = q15_t(p25TXLevel * 128);
+  m_nxdnTXLevel   = q15_t(nxdnTXLevel * 128);
+  m_pocsagTXLevel = q15_t(pocsagTXLevel * 128);
+  m_fmTXLevel     = q15_t(fmTXLevel * 128);
+
+  m_rxDCOffset   = DC_OFFSET + rxDCOffset;
+  m_txDCOffset   = DC_OFFSET + txDCOffset;
   
   if (rxInvert)
     m_rxLevel = -m_rxLevel;
   
   if (txInvert) {
-    m_dstarTXLevel = -m_dstarTXLevel;
-    m_dmrTXLevel   = -m_dmrTXLevel;
-    m_ysfTXLevel   = -m_ysfTXLevel;
-    m_p25TXLevel   = -m_p25TXLevel;
+    m_dstarTXLevel  = -m_dstarTXLevel;
+    m_dmrTXLevel    = -m_dmrTXLevel;
+    m_ysfTXLevel    = -m_ysfTXLevel;
+    m_p25TXLevel    = -m_p25TXLevel;
+    m_nxdnTXLevel   = -m_nxdnTXLevel;
+    m_pocsagTXLevel = -m_pocsagTXLevel;
   }
 }
 
@@ -353,11 +567,6 @@ void CIO::getOverflow(bool& adcOverflow, bool& dacOverflow)
   adcOverflow = m_adcOverflow > 0U;
   dacOverflow = m_dacOverflow > 0U;
 
-#if defined(WANT_DEBUG)
-  if (m_adcOverflow > 0U || m_dacOverflow > 0U)
-    DEBUG3("IO: adc/dac", m_adcOverflow, m_dacOverflow);
-#endif
-
   m_adcOverflow = 0U;
   m_dacOverflow = 0U;
 }
@@ -377,8 +586,12 @@ void CIO::resetWatchdog()
   m_watchdog = 0U;
 }
 
+uint32_t CIO::getWatchdog()
+{
+  return m_watchdog;
+}
+
 bool CIO::hasLockout() const
 {
   return m_lockout;
 }
-

IO.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016 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
@@ -21,8 +21,12 @@
 
 #include "Globals.h"
 
-#include "SampleRB.h"
-#include "RSSIRB.h"
+#include "RingBuffer.h"
+
+struct TSample {
+  volatile uint16_t sample;
+  volatile uint8_t control;
+};
 
 class CIO {
 public:
@@ -40,9 +44,9 @@ public:
   void setADCDetection(bool detect);
   void setMode();
   
-  void interrupt(uint8_t source);
+  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);
+  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 getOverflow(bool& adcOverflow, bool& dacOverflow);
 
@@ -52,18 +56,30 @@ public:
   bool hasLockout() const;
 
   void resetWatchdog();
+  uint32_t getWatchdog();
+  
+  void selfTest();
 
 private:
-  bool                 m_started;
+  bool                  m_started;
 
-  CSampleRB            m_rxBuffer;
-  CSampleRB            m_txBuffer;
-  CRSSIRB              m_rssiBuffer;
+  CRingBuffer<TSample>  m_rxBuffer;
+  CRingBuffer<TSample>  m_txBuffer;
+  CRingBuffer<uint16_t> m_rssiBuffer;
 
-  arm_fir_instance_q15 m_C4FSKFilter;
-  arm_fir_instance_q15 m_GMSKFilter;
-  q15_t                m_C4FSKState[70U];    // NoTaps + BlockSize - 1, 42 + 20 - 1 plus some spare
-  q15_t                m_GMSKState[40U];     // NoTaps + BlockSize - 1, 12 + 20 - 1 plus some spare
+  arm_biquad_casd_df1_inst_q31 m_dcFilter;
+  q31_t                        m_dcState[4];
+
+  arm_fir_instance_q15 m_rrcFilter;
+  arm_fir_instance_q15 m_gaussianFilter;
+  arm_fir_instance_q15 m_boxcarFilter;
+  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
 
   bool                 m_pttInvert;
   q15_t                m_rxLevel;
@@ -72,6 +88,12 @@ private:
   q15_t                m_dmrTXLevel;
   q15_t                m_ysfTXLevel;
   q15_t                m_p25TXLevel;
+  q15_t                m_nxdnTXLevel;
+  q15_t                m_pocsagTXLevel;
+  q15_t                m_fmTXLevel;
+
+  uint16_t             m_rxDCOffset;
+  uint16_t             m_txDCOffset;
 
   uint32_t             m_ledCount;
   bool                 m_ledValue;
@@ -81,8 +103,6 @@ private:
   uint16_t             m_adcOverflow;
   uint16_t             m_dacOverflow;
 
-  uint32_t             m_count;
-
   volatile uint32_t    m_watchdog;
 
   bool                 m_lockout;
@@ -101,7 +121,11 @@ private:
   void setDMRInt(bool on);
   void setYSFInt(bool on);
   void setP25Int(bool on);
+  void setNXDNInt(bool on);
+  void setPOCSAGInt(bool on);
+  void setFMInt(bool on);
+  
+  void delayInt(unsigned int dly);
 };
 
 #endif
-

IODue.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2015 by Jim Mclaughlin KI6ZUM
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *
@@ -33,6 +33,9 @@
 #define PIN_DMR                17
 #define PIN_YSF                18
 #define PIN_P25                19
+#define PIN_NXDN               20
+#define PIN_POCSAG             4
+#define PIN_FM                 5
 #define ADC_CHER_Chan          (1<<7)                 // ADC on Due pin A0  - Due AD7 - (1 << 7)
 #define ADC_ISR_EOC_Chan       ADC_ISR_EOC7
 #define ADC_CDR_Chan           7
@@ -46,11 +49,16 @@
 #define PIN_DMR                8
 #define PIN_YSF                7
 #define PIN_P25                6
+#define PIN_NXDN               5
+#define PIN_POCSAG             4
+#define PIN_FM                 3
 #define ADC_CHER_Chan          (1<<13)                // ADC on Due pin A11 - Due AD13 - (1 << 13)
 #define ADC_ISR_EOC_Chan       ADC_ISR_EOC13
 #define ADC_CDR_Chan           13
 #define DACC_MR_USER_SEL_Chan  DACC_MR_USER_SEL_CHANNEL1 // DAC on Due DAC1
 #define DACC_CHER_Chan         DACC_CHER_CH1
+#define RSSI_CHER_Chan         (1<<1)                 // ADC on Due pin A6  - Due AD1 - (1 << 1)
+#define RSSI_CDR_Chan          1
 #elif defined(ARDUINO_DUE_NTH)
 #define PIN_COS                A7
 #define PIN_PTT                A8
@@ -59,11 +67,16 @@
 #define PIN_DMR                8
 #define PIN_YSF                7
 #define PIN_P25                6
+#define PIN_NXDN               5
+#define PIN_POCSAG             4
+#define PIN_FM                 3
 #define ADC_CHER_Chan          (1<<7)                 // ADC on Due pin A0  - Due AD7 - (1 << 7)
 #define ADC_ISR_EOC_Chan       ADC_ISR_EOC7
 #define ADC_CDR_Chan           7
 #define DACC_MR_USER_SEL_Chan  DACC_MR_USER_SEL_CHANNEL0 // DAC on Due DAC0
 #define DACC_CHER_Chan         DACC_CHER_CH0
+#define RSSI_CHER_Chan         (1<<1)                 // ADC on Due pin A6  - Due AD1 - (1 << 1)
+#define RSSI_CDR_Chan          1
 #else
 #error "Either ARDUINO_DUE_PAPA, ARDUINO_DUE_ZUM_V10, or ARDUINO_DUE_NTH need to be defined"
 #endif
@@ -73,7 +86,7 @@ const uint16_t DC_OFFSET = 2048U;
 extern "C" {
   void ADC_Handler()
   {
-    io.interrupt(0U);
+    io.interrupt();
   }
 }
 
@@ -85,26 +98,38 @@ void CIO::initInt()
   pinMode(PIN_LED,    OUTPUT);
   pinMode(PIN_COS,    INPUT);
 
-#if defined(ARDUINO_MODE_PINS)
+#if defined(MODE_LEDS)
   // Set up the mode output pins
   pinMode(PIN_DSTAR,  OUTPUT);
   pinMode(PIN_DMR,    OUTPUT);
   pinMode(PIN_YSF,    OUTPUT);
   pinMode(PIN_P25,    OUTPUT);
+#if !defined(USE_ALTERNATE_NXDN_LEDS)
+  pinMode(PIN_NXDN,   OUTPUT);
+#endif
+#if !defined(USE_ALTERNATE_POCSAG_LEDS)
+  pinMode(PIN_POCSAG, OUTPUT);
+#endif
+#if !defined(USE_ALTERNATE_POCSAG_LEDS)
+  pinMode(PIN_FM,     OUTPUT);
+#endif
 #endif
 }
 
 void CIO::startInt()
 {
   if (ADC->ADC_ISR & ADC_ISR_EOC_Chan)        // Ensure there was an End-of-Conversion and we read the ISR reg
-    io.interrupt(0U);
+    io.interrupt();
 
   // Set up the ADC
   NVIC_EnableIRQ(ADC_IRQn);                   // Enable ADC interrupt vector
   ADC->ADC_IDR  = 0xFFFFFFFF;                 // Disable interrupts
   ADC->ADC_IER  = ADC_CHER_Chan;              // Enable End-Of-Conv interrupt
   ADC->ADC_CHDR = 0xFFFF;                     // Disable all channels
-  ADC->ADC_CHER = ADC_CHER_Chan;              // Enable just one channel
+  ADC->ADC_CHER = ADC_CHER_Chan;              // Enable rx input channel
+#if defined(SEND_RSSI_DATA)
+  ADC->ADC_CHER |= RSSI_CHER_Chan;            // and RSSI input
+#endif
   ADC->ADC_CGR  = 0x15555555;                 // All gains set to x1
   ADC->ADC_COR  = 0x00000000;                 // All offsets off
   ADC->ADC_MR   = (ADC->ADC_MR & 0xFFFFFFF0) | (1 << 1) | ADC_MR_TRGEN;  // 1 = trig source TIO from TC0
@@ -157,19 +182,22 @@ void CIO::startInt()
   digitalWrite(PIN_LED,    HIGH);
 }
 
-void CIO::interrupt(uint8_t source)
+void CIO::interrupt()
 {
   if ((ADC->ADC_ISR & ADC_ISR_EOC_Chan) == ADC_ISR_EOC_Chan) {    // Ensure there was an End-of-Conversion and we read the ISR reg
-    uint8_t control = MARK_NONE;
-    uint16_t sample = DC_OFFSET;
+    TSample sample = {DC_OFFSET, MARK_NONE};
 
-    m_txBuffer.get(sample, control);
-    DACC->DACC_CDR = sample;
+    m_txBuffer.get(sample);
+    DACC->DACC_CDR = sample.sample;
 
-    sample = ADC->ADC_CDR[ADC_CDR_Chan];
-    m_rxBuffer.put(sample, control);
+    sample.sample = ADC->ADC_CDR[ADC_CDR_Chan];
+    m_rxBuffer.put(sample);
 
+#if defined(SEND_RSSI_DATA)
+    m_rssiBuffer.put(ADC->ADC_CDR[RSSI_CDR_Chan]);
+#else
     m_rssiBuffer.put(0U);
+#endif
 
     m_watchdog++;
   }
@@ -200,7 +228,7 @@ void CIO::setDStarInt(bool on)
   digitalWrite(PIN_DSTAR, on ? HIGH : LOW);
 }
 
-void CIO::setDMRInt(bool on) 
+void CIO::setDMRInt(bool on)
 {
   digitalWrite(PIN_DMR, on ? HIGH : LOW);
 }
@@ -210,10 +238,44 @@ void CIO::setYSFInt(bool on)
   digitalWrite(PIN_YSF, on ? HIGH : LOW);
 }
 
-void CIO::setP25Int(bool on) 
+void CIO::setP25Int(bool on)
 {
   digitalWrite(PIN_P25, on ? HIGH : LOW);
 }
 
+void CIO::setNXDNInt(bool on)
+{
+#if defined(USE_ALTERNATE_NXDN_LEDS)
+  digitalWrite(PIN_YSF, on ? HIGH : LOW);
+  digitalWrite(PIN_P25, on ? HIGH : LOW);
+#else
+  digitalWrite(PIN_NXDN, on ? HIGH : LOW);
 #endif
+}
 
+void CIO::setPOCSAGInt(bool on)
+{
+#if defined(USE_ALTERNATE_POCSAG_LEDS)
+  digitalWrite(PIN_DSTAR, on ? HIGH : LOW);
+  digitalWrite(PIN_DMR,   on ? HIGH : LOW);
+#else
+  digitalWrite(PIN_POCSAG, on ? HIGH : LOW);
+#endif
+}
+
+void CIO::setFMInt(bool on)
+{
+#if defined(USE_ALTERNATE_FM_LEDS)
+  digitalWrite(PIN_DSTAR, on ? HIGH : LOW);
+  digitalWrite(PIN_YSF,   on ? HIGH : LOW);
+#else
+  digitalWrite(PIN_FM, on ? HIGH : LOW);
+#endif
+}
+
+void CIO::delayInt(unsigned int dly)
+{
+  delay(dly);
+}
+
+#endif

IOPins.h

@@ -0,0 +1,70 @@
+/*
+ *   Copyright (C) 2019,2020 by BG5HHP
+ *
+ *   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.
+ */
+
+#ifndef _IO_PINS_H
+#define _IO_PINS_H
+
+#if !defined(CONFIG_H)
+#error "Requires Config.h to be included first!"
+#endif
+
+#if defined(STM32F4_RPT_HAT_TGO)
+    #include "pins/pins_f4_rpt_tgo.h"
+
+#elif defined(STM32F4_DISCOVERY)
+    #include "pins/pins_f4_discovery.h"
+
+#elif defined(STM32F4_PI)
+    #include "pins/pins_f4_pi.h"
+
+#elif defined(STM32F722_PI)
+    #include "pins/pins_f7_pi.h"
+
+#elif defined(STM32F4_F4M)
+    #include "pins/pins_f4_f4m.h"
+
+#elif defined(STM32F722_F7M)
+    #include "pins/pins_f7_f7m.h"
+
+#elif defined(STM32F722_RPT_HAT)
+    #include "pins/pins_f7_rpt_hat.h"
+
+#elif defined(STM32F4_NUCLEO)
+    #if defined(STM32F4_NUCLEO_MORPHO_HEADER)
+        #include "pins/pins_f4_nucleo_morpho.h"
+    #elif defined(STM32F4_NUCLEO_ARDUINO_HEADER)
+        #include "pins/pins_f4_nucleo_arduino.h"
+    #else
+        #error "Either STM32F4_NUCLEO_MORPHO_HEADER or STM32F4_NUCLEO_ARDUINO_HEADER need to be defined"
+    #endif
+
+#elif defined(STM32F7_NUCLEO)
+    #include "pins/pins_f7_nucleo.h"
+
+#elif defined(STM32F4_DVM)
+    #include "pins/pins_f4_stm32dvm_v3.h"
+
+#elif defined(DRCC_DVM_NQF)
+    #include "pins/pins_f4_drcc_nqf.h"
+
+#else
+    #error "A valid board type macro need to be defined."
+
+#endif
+
+#endif  //#ifndef _IO_PINS_H

IOSTM.cpp

@@ -1,6 +1,8 @@
 /*
  *   Copyright (C) 2016 by Jim McLaughlin KI6ZUM
- *   Copyright (C) 2016 by Andy Uribe CA6JAU
+ *   Copyright (C) 2016,2017,2018 by Andy Uribe CA6JAU
+ *   Copyright (C) 2017,2018,2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2019,2020 by BG5HHP
  *
  *   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
@@ -21,477 +23,489 @@
 #include "Globals.h"
 #include "IO.h"
 
-#if defined(STM32F4XX) || defined(STM32F4)
+#if defined(STM32F4XX) || defined(STM32F7XX)
+#include "IOPins.h"
 
-#if defined(STM32F4_DISCOVERY)
-/*
-Pin definitions for STM32F4 Discovery Board:
-
-PTT      PB13   output
-COSLED   PA7   output
-LED      PD15  output
-COS      PA5   input
-
-DSTAR	 PD12   output
-DMR		 PD13   output
-YSF		 PD14   output
-P25		 PD11   output
-
-RX		 PA0   analog input
-RSSI     PA1   analog input
-TX       PA4   analog output
-
-EXT_CLK  PA15   input
-*/
-
-#define PIN_COS				GPIO_Pin_5
-#define PORT_COS			GPIOA
-#define RCC_Per_COS			RCC_AHB1Periph_GPIOA
-
-#define PIN_PTT				GPIO_Pin_13
-#define PORT_PTT			GPIOB
-#define RCC_Per_PTT			RCC_AHB1Periph_GPIOB
-
-#define PIN_COSLED			GPIO_Pin_7
-#define PORT_COSLED			GPIOA
-#define RCC_Per_COSLED		RCC_AHB1Periph_GPIOA
-
-#define PIN_LED				GPIO_Pin_15
-#define PORT_LED			GPIOD
-#define RCC_Per_LED			RCC_AHB1Periph_GPIOD
-
-#define PIN_P25				GPIO_Pin_11
-#define PORT_P25			GPIOD
-#define RCC_Per_P25			RCC_AHB1Periph_GPIOD
-
-#define PIN_DSTAR			GPIO_Pin_12
-#define PORT_DSTAR			GPIOD
-#define RCC_Per_DSTAR		RCC_AHB1Periph_GPIOD
-
-#define PIN_DMR				GPIO_Pin_13
-#define PORT_DMR			GPIOD
-#define RCC_Per_DMR			RCC_AHB1Periph_GPIOD
-
-#define PIN_YSF				GPIO_Pin_14
-#define PORT_YSF			GPIOD
-#define RCC_Per_YSF			RCC_AHB1Periph_GPIOD
-
-#define PIN_RX				GPIO_Pin_0
-#define PIN_RX_CH			ADC_Channel_0
-
-#define PIN_RSSI			GPIO_Pin_1
-#define PIN_RSSI_CH			ADC_Channel_1
-
-#elif defined(STM32F4_PI)
-/*
-Pin definitions for STM32F4 Pi Board:
-
-PTT      PB13   output
-COSLED   PB14   output
-LED      PB15  output
-COS      PC0   input
-
-DSTAR	 PC7   output
-DMR		 PC8   output
-YSF		 PA8   output
-P25		 PC9   output
-
-RX		 PA0   analog input
-RSSI     PA7   analog input
-TX       PA4   analog output
-
-EXT_CLK  PA15   input
-*/
-
-#define PIN_COS				GPIO_Pin_0
-#define PORT_COS			GPIOC
-#define RCC_Per_COS			RCC_AHB1Periph_GPIOC
-
-#define PIN_PTT				GPIO_Pin_13
-#define PORT_PTT			GPIOB
-#define RCC_Per_PTT			RCC_AHB1Periph_GPIOB
-
-#define PIN_COSLED			GPIO_Pin_14
-#define PORT_COSLED			GPIOB
-#define RCC_Per_COSLED		RCC_AHB1Periph_GPIOB
-
-#define PIN_LED				GPIO_Pin_15
-#define PORT_LED			GPIOB
-#define RCC_Per_LED			RCC_AHB1Periph_GPIOB
-
-#define PIN_P25				GPIO_Pin_9
-#define PORT_P25			GPIOC
-#define RCC_Per_P25			RCC_AHB1Periph_GPIOC
-
-#define PIN_DSTAR			GPIO_Pin_7
-#define PORT_DSTAR			GPIOC
-#define RCC_Per_DSTAR		RCC_AHB1Periph_GPIOC
-
-#define PIN_DMR				GPIO_Pin_8
-#define PORT_DMR			GPIOC
-#define RCC_Per_DMR			RCC_AHB1Periph_GPIOC
-
-#define PIN_YSF				GPIO_Pin_8
-#define PORT_YSF			GPIOA
-#define RCC_Per_YSF			RCC_AHB1Periph_GPIOA
-
-#define PIN_RX				GPIO_Pin_0
-#define PIN_RX_CH			ADC_Channel_0
-
-#define PIN_RSSI			GPIO_Pin_7
-#define PIN_RSSI_CH			ADC_Channel_7
-
-#elif defined(STM32F4_NUCLEO)
-/*
-Pin definitions for STM32F4 Nucleo boards:
-
-PTT      PB13  output
-COSLED   PB14  output
-LED      PA5   output
-COS      PB15  input
-
-DSTAR	 PB10  output
-DMR		 PB4   output
-YSF		 PB5   output
-P25		 PB3   output
-
-RX		 PA0   analog input
-RSSI     PA1   analog input
-TX       PA4   analog output
-
-EXT_CLK  PA15  input
-*/
-
-#define PIN_COS				GPIO_Pin_15
-#define PORT_COS			GPIOB
-#define RCC_Per_COS			RCC_AHB1Periph_GPIOB
-
-#define PIN_PTT				GPIO_Pin_13
-#define PORT_PTT			GPIOB
-#define RCC_Per_PTT			RCC_AHB1Periph_GPIOB
-
-#define PIN_COSLED			GPIO_Pin_14
-#define PORT_COSLED			GPIOB
-#define RCC_Per_COSLED		RCC_AHB1Periph_GPIOB
-
-#define PIN_LED				GPIO_Pin_5
-#define PORT_LED			GPIOA
-#define RCC_Per_LED			RCC_AHB1Periph_GPIOA
-
-#define PIN_P25				GPIO_Pin_3
-#define PORT_P25			GPIOB
-#define RCC_Per_P25			RCC_AHB1Periph_GPIOB
-
-#define PIN_DSTAR			GPIO_Pin_10
-#define PORT_DSTAR			GPIOB
-#define RCC_Per_DSTAR		RCC_AHB1Periph_GPIOB
-
-#define PIN_DMR				GPIO_Pin_4
-#define PORT_DMR			GPIOB
-#define RCC_Per_DMR			RCC_AHB1Periph_GPIOB
-
-#define PIN_YSF				GPIO_Pin_5
-#define PORT_YSF			GPIOB
-#define RCC_Per_YSF			RCC_AHB1Periph_GPIOB
-
-#define PIN_RX				GPIO_Pin_0
-#define PIN_RX_CH			ADC_Channel_0
-
-#define PIN_RSSI			GPIO_Pin_1
-#define PIN_RSSI_CH			ADC_Channel_1
-
-#else
-#error "Either STM32F4_DISCOVERY, STM32F4_PI or STM32F4_NUCLEO need to be defined"
-#endif
 
 const uint16_t DC_OFFSET = 2048U;
 
-// Sampling frequency 
-#define SAMP_FREQ	24000
+// Sampling frequency
+#define SAMP_FREQ   24000
 
 extern "C" {
-  void TIM2_IRQHandler() {
-     if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET) {
-        TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
-	      io.interrupt(0U);
-     }
-  }
+   void TIM2_IRQHandler() {
+      if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET) {
+         TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
+         io.interrupt();
+      }
+   }
 }
 
 void CIO::initInt()
-{  
-  GPIO_InitTypeDef GPIO_InitStruct;
-  GPIO_StructInit(&GPIO_InitStruct);
-  GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
-  GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
-  GPIO_InitStruct.GPIO_PuPd  = GPIO_PuPd_DOWN;
-  
-  // PTT pin
-  RCC_AHB1PeriphClockCmd(RCC_Per_PTT, ENABLE);
-  GPIO_InitStruct.GPIO_Pin   = PIN_PTT;
-  GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
-  GPIO_Init(PORT_PTT, &GPIO_InitStruct);
+{
+   GPIO_InitTypeDef GPIO_InitStruct;
+   GPIO_StructInit(&GPIO_InitStruct);
+   GPIO_InitStruct.GPIO_Speed = GPIO_Fast_Speed;
+   GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
+   GPIO_InitStruct.GPIO_PuPd  = GPIO_PuPd_DOWN;
 
-  // COSLED pin
-  RCC_AHB1PeriphClockCmd(RCC_Per_COSLED, ENABLE);
-  GPIO_InitStruct.GPIO_Pin   = PIN_COSLED;
-  GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
-  GPIO_Init(PORT_COSLED, &GPIO_InitStruct);
+   // PTT pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_PTT, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_PTT;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_PTT, &GPIO_InitStruct);
 
-  // LED pin
-  RCC_AHB1PeriphClockCmd(RCC_Per_LED, ENABLE);
-  GPIO_InitStruct.GPIO_Pin   = PIN_LED;
-  GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
-  GPIO_Init(PORT_LED, &GPIO_InitStruct);
+   // COSLED pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_COSLED, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_COSLED;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_COSLED, &GPIO_InitStruct);
 
-  // Init the input pins PIN_COS
-  RCC_AHB1PeriphClockCmd(RCC_Per_COS, ENABLE);
-  GPIO_InitStruct.GPIO_Pin   = PIN_COS;
-  GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_IN;
-  GPIO_Init(PORT_COS, &GPIO_InitStruct);
+   // LED pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_LED, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_LED;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_LED, &GPIO_InitStruct);
 
-#if defined(ARDUINO_MODE_PINS)
-  // DSTAR pin
-  RCC_AHB1PeriphClockCmd(RCC_Per_DSTAR, ENABLE);
-  GPIO_InitStruct.GPIO_Pin   = PIN_DSTAR;
-  GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
-  GPIO_Init(PORT_DSTAR, &GPIO_InitStruct);
+   // Init the input pins PIN_COS
+   RCC_AHB1PeriphClockCmd(RCC_Per_COS, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_COS;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_IN;
+   GPIO_Init(PORT_COS, &GPIO_InitStruct);
 
-  // DMR pin
-  RCC_AHB1PeriphClockCmd(RCC_Per_DMR, ENABLE);
-  GPIO_InitStruct.GPIO_Pin   = PIN_DMR;
-  GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
-  GPIO_Init(PORT_DMR, &GPIO_InitStruct);
+#if defined(MODE_LEDS)
+   // DSTAR pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_DSTAR, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_DSTAR;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_DSTAR, &GPIO_InitStruct);
 
-  // YSF pin
-  RCC_AHB1PeriphClockCmd(RCC_Per_YSF, ENABLE);
-  GPIO_InitStruct.GPIO_Pin   = PIN_YSF;
-  GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
-  GPIO_Init(PORT_YSF, &GPIO_InitStruct);
+   // DMR pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_DMR, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_DMR;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_DMR, &GPIO_InitStruct);
+
+   // YSF pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_YSF, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_YSF;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_YSF, &GPIO_InitStruct);
+
+   // P25 pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_P25, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_P25;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_P25, &GPIO_InitStruct);
+
+#if !defined(USE_ALTERNATE_NXDN_LEDS)
+   // NXDN pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_NXDN, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_NXDN;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_NXDN, &GPIO_InitStruct);
+#endif
+
+#if !defined(USE_ALTERNATE_POCSAG_LEDS)
+   // POCSAG pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_POCSAG, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_POCSAG;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_POCSAG, &GPIO_InitStruct);
+#endif
+
+#if !defined(USE_ALTERNATE_FM_LEDS)
+   // FM pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_FM, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_FM;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_FM, &GPIO_InitStruct);
+#endif
+
+#endif
+
+#if defined(MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && (defined(STM32F4_NUCLEO) || defined(STM32F722_RPT_HAT))
+   // DSTAR mode pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_MDSTAR, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_MDSTAR;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_MDSTAR, &GPIO_InitStruct);
+
+   // DMR mode pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_MDMR, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_MDMR;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_MDMR, &GPIO_InitStruct);
+
+   // YSF mode pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_MYSF, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_MYSF;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_MYSF, &GPIO_InitStruct);
+
+   // P25 mode pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_MP25, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_MP25;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_MP25, &GPIO_InitStruct);
+
+#if !defined(USE_ALTERNATE_NXDN_LEDS)
+   // NXDN mode pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_MNXDN, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_MNXDN;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_MNXDN, &GPIO_InitStruct);
+#endif
+
+#if !defined(USE_ALTERNATE_POCSAG_LEDS)
+   // POCSAG mode pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_MPOCSAG, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_MPOCSAG;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_MPOCSAG, &GPIO_InitStruct);
+#endif
+
+#if !defined(USE_ALTERNATE_FM_LEDS)
+   // FM mode pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_MFM, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_MFM;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_MFM, &GPIO_InitStruct);
+#endif
 
-  // P25 pin
-  RCC_AHB1PeriphClockCmd(RCC_Per_P25, ENABLE);
-  GPIO_InitStruct.GPIO_Pin   = PIN_P25;
-  GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
-  GPIO_Init(PORT_P25, &GPIO_InitStruct);
 #endif
 }
 
 void CIO::startInt()
 {
-  if ((ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) != RESET))
-    io.interrupt(0U);
-  
-  // Init the ADC
-  GPIO_InitTypeDef        GPIO_InitStruct;
-  ADC_InitTypeDef         ADC_InitStructure;
-  ADC_CommonInitTypeDef   ADC_CommonInitStructure;
+   if ((ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) != RESET))
+      io.interrupt();
 
-  GPIO_StructInit(&GPIO_InitStruct);
-  ADC_CommonStructInit(&ADC_CommonInitStructure);
-  ADC_StructInit(&ADC_InitStructure);
+   // Init the ADC
+   GPIO_InitTypeDef        GPIO_InitStruct;
+   ADC_InitTypeDef         ADC_InitStructure;
+   ADC_CommonInitTypeDef   ADC_CommonInitStructure;
 
-  // Enable ADC clock
-  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
-#if defined(SEND_RSSI_DATA)
-  RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_ADC2, ENABLE);
-#else
-  RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);
-#endif
-  
-#if defined(SEND_RSSI_DATA)
-  GPIO_InitStruct.GPIO_Pin  = PIN_RX | PIN_RSSI;
-#else
-  GPIO_InitStruct.GPIO_Pin  = PIN_RX;
-#endif
-  GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AN;
-  GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL ;
-  GPIO_Init(GPIOA, &GPIO_InitStruct);
+   GPIO_StructInit(&GPIO_InitStruct);
+   ADC_CommonStructInit(&ADC_CommonInitStructure);
+   ADC_StructInit(&ADC_InitStructure);
 
-  // Init ADCs in dual mode (RSSI), div clock by two
-#if defined(SEND_RSSI_DATA)
-  ADC_CommonInitStructure.ADC_Mode             = ADC_DualMode_RegSimult;
-#else
-  ADC_CommonInitStructure.ADC_Mode             = ADC_Mode_Independent;
-#endif
-  ADC_CommonInitStructure.ADC_Prescaler        = ADC_Prescaler_Div2;
-  ADC_CommonInitStructure.ADC_DMAAccessMode    = ADC_DMAAccessMode_Disabled;
-  ADC_CommonInitStructure.ADC_TwoSamplingDelay = ADC_TwoSamplingDelay_5Cycles;
-  ADC_CommonInit(&ADC_CommonInitStructure);
-
-  // Init ADC1 and ADC2: 12bit, single-conversion
-  ADC_InitStructure.ADC_Resolution           = ADC_Resolution_12b;
-  ADC_InitStructure.ADC_ScanConvMode         = DISABLE;
-  ADC_InitStructure.ADC_ContinuousConvMode   = DISABLE;
-  ADC_InitStructure.ADC_ExternalTrigConvEdge = 0;
-  ADC_InitStructure.ADC_ExternalTrigConv     = 0;
-  ADC_InitStructure.ADC_DataAlign            = ADC_DataAlign_Right;
-  ADC_InitStructure.ADC_NbrOfConversion      = 1;
-
-  ADC_Init(ADC1, &ADC_InitStructure);
-
-  ADC_EOCOnEachRegularChannelCmd(ADC1, ENABLE);
-  ADC_RegularChannelConfig(ADC1, PIN_RX_CH, 1, ADC_SampleTime_3Cycles);
-
-  // Enable ADC1
-  ADC_Cmd(ADC1, ENABLE);
+   // Enable ADC1 clock
+   RCC_AHB1PeriphClockCmd(RCC_Per_RX, ENABLE);
+   RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);
+   // Enable ADC1 GPIO
+   GPIO_InitStruct.GPIO_Pin  = PIN_RX;
+   GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AN;
+   GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL ;
+   GPIO_Init(PORT_RX, &GPIO_InitStruct);
 
 #if defined(SEND_RSSI_DATA)
-  ADC_Init(ADC2, &ADC_InitStructure);
-
-  ADC_EOCOnEachRegularChannelCmd(ADC2, ENABLE);
-  ADC_RegularChannelConfig(ADC2, PIN_RSSI_CH, 1, ADC_SampleTime_3Cycles);
-
-  // Enable ADC2
-  ADC_Cmd(ADC2, ENABLE);
+   // Enable ADC2 clock
+   RCC_AHB1PeriphClockCmd(RCC_Per_RSSI, ENABLE);
+   RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC2, ENABLE);
+   // Enable ADC2 GPIO
+   GPIO_InitStruct.GPIO_Pin  = PIN_RSSI;
+   GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AN;
+   GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL ;
+   GPIO_Init(PORT_RSSI, &GPIO_InitStruct);
 #endif
 
-  // Init the DAC
-  DAC_InitTypeDef DAC_InitStructure;
-
-  GPIO_StructInit(&GPIO_InitStruct);
-  DAC_StructInit(&DAC_InitStructure);
-
-  // GPIOA clock enable
-  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
-
-  // DAC Periph clock enable
-  RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC, ENABLE);
-
-  // GPIO CONFIGURATION of DAC Pins (PA4)
-  GPIO_InitStruct.GPIO_Pin   = GPIO_Pin_4;
-  GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_AN;
-  GPIO_InitStruct.GPIO_PuPd  = GPIO_PuPd_NOPULL;
-  GPIO_Init(GPIOA, &GPIO_InitStruct);
-
-  DAC_InitStructure.DAC_Trigger = DAC_Trigger_None;
-  DAC_InitStructure.DAC_WaveGeneration = DAC_WaveGeneration_None;
-  DAC_InitStructure.DAC_OutputBuffer = DAC_OutputBuffer_Enable;
-  DAC_Init(DAC_Channel_1, &DAC_InitStructure);
-  DAC_Cmd(DAC_Channel_1, ENABLE);
-
-  // Init the timer
-  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
-  
-#if defined(EXTERNAL_OSC)
-  // Configure GPIO PA15 as external TIM2 clock source
-  GPIO_PinAFConfig(GPIOA, GPIO_PinSource15, GPIO_AF_TIM2);
-  GPIO_InitStruct.GPIO_Pin = GPIO_Pin_15;
-  GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
-  GPIO_Init(GPIOA, &GPIO_InitStruct);
-#endif
-  
-  TIM_TimeBaseInitTypeDef timerInitStructure;
-  TIM_TimeBaseStructInit (&timerInitStructure);
-  
-  // TIM2 output frequency
-#if defined(EXTERNAL_OSC)
-  timerInitStructure.TIM_Prescaler = (uint16_t) ((EXTERNAL_OSC/(2*SAMP_FREQ)) - 1);
-#else 
-  timerInitStructure.TIM_Prescaler = (uint16_t) ((SystemCoreClock/(4*SAMP_FREQ)) - 1);
-#endif
-
-  timerInitStructure.TIM_CounterMode       = TIM_CounterMode_Up;
-  timerInitStructure.TIM_Period            = 1;
-  timerInitStructure.TIM_ClockDivision     = TIM_CKD_DIV1;
-  timerInitStructure.TIM_RepetitionCounter = 0;
-  TIM_TimeBaseInit(TIM2, &timerInitStructure);
-
-#if defined(EXTERNAL_OSC)
-  // Enable external clock (PA15)
-  TIM_ETRClockMode2Config(TIM2, TIM_ExtTRGPSC_OFF, TIM_ExtTRGPolarity_NonInverted, 0x00);
+   // Init ADCs in dual mode (RSSI), div clock by two
+#if defined(SEND_RSSI_DATA)
+   ADC_CommonInitStructure.ADC_Mode             = ADC_DualMode_RegSimult;
 #else
-  // Enable internal clock
-  TIM_InternalClockConfig(TIM2);
+   ADC_CommonInitStructure.ADC_Mode             = ADC_Mode_Independent;
+#endif
+   ADC_CommonInitStructure.ADC_Prescaler        = ADC_Prescaler_Div2;
+   ADC_CommonInitStructure.ADC_DMAAccessMode    = ADC_DMAAccessMode_Disabled;
+   ADC_CommonInitStructure.ADC_TwoSamplingDelay = ADC_TwoSamplingDelay_5Cycles;
+   ADC_CommonInit(&ADC_CommonInitStructure);
+
+   // Init ADC1 and ADC2: 12bit, single-conversion
+   ADC_InitStructure.ADC_Resolution           = ADC_Resolution_12b;
+   ADC_InitStructure.ADC_ScanConvMode         = DISABLE;
+   ADC_InitStructure.ADC_ContinuousConvMode   = DISABLE;
+   ADC_InitStructure.ADC_ExternalTrigConvEdge = 0;
+   ADC_InitStructure.ADC_ExternalTrigConv     = 0;
+   ADC_InitStructure.ADC_DataAlign            = ADC_DataAlign_Right;
+   ADC_InitStructure.ADC_NbrOfConversion      = 1;
+
+   ADC_Init(ADC1, &ADC_InitStructure);
+
+   ADC_EOCOnEachRegularChannelCmd(ADC1, ENABLE);
+   ADC_RegularChannelConfig(ADC1, PIN_RX_CH, 1, ADC_SampleTime_3Cycles);
+
+   // Enable ADC1
+   ADC_Cmd(ADC1, ENABLE);
+
+#if defined(SEND_RSSI_DATA)
+   ADC_Init(ADC2, &ADC_InitStructure);
+
+   ADC_EOCOnEachRegularChannelCmd(ADC2, ENABLE);
+   ADC_RegularChannelConfig(ADC2, PIN_RSSI_CH, 1, ADC_SampleTime_3Cycles);
+
+   // Enable ADC2
+   ADC_Cmd(ADC2, ENABLE);
 #endif
 
-  // Enable TIM2
-  TIM_Cmd(TIM2, ENABLE);
-  // Enable TIM2 interrupt
-  TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);
+   // Init the DAC
+   DAC_InitTypeDef DAC_InitStructure;
 
-  NVIC_InitTypeDef nvicStructure;
-  nvicStructure.NVIC_IRQChannel                   = TIM2_IRQn;
-  nvicStructure.NVIC_IRQChannelPreemptionPriority = 0;
-  nvicStructure.NVIC_IRQChannelSubPriority        = 1;
-  nvicStructure.NVIC_IRQChannelCmd                = ENABLE;
-  NVIC_Init(&nvicStructure);
+   GPIO_StructInit(&GPIO_InitStruct);
+   DAC_StructInit(&DAC_InitStructure);
 
-  GPIO_ResetBits(PORT_COSLED, PIN_COSLED);
-  GPIO_SetBits(PORT_LED, PIN_LED);
+   // GPIOA clock enable
+   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
+
+   // DAC Periph clock enable
+   RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC, ENABLE);
+
+   // GPIO CONFIGURATION of DAC Pin
+   GPIO_InitStruct.GPIO_Pin   = PIN_TX;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_AN;
+   GPIO_InitStruct.GPIO_PuPd  = GPIO_PuPd_NOPULL;
+   GPIO_Init(GPIOA, &GPIO_InitStruct);
+
+   DAC_InitStructure.DAC_Trigger = DAC_Trigger_None;
+   DAC_InitStructure.DAC_WaveGeneration = DAC_WaveGeneration_None;
+   DAC_InitStructure.DAC_OutputBuffer = DAC_OutputBuffer_Enable;
+   DAC_Init(PIN_TX_CH, &DAC_InitStructure);
+   DAC_Cmd(PIN_TX_CH, ENABLE);
+
+   // Init the timer
+   RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
+
+#if defined(EXTERNAL_OSC) && !(defined(STM32F4_PI) || defined(STM32F722_PI))
+   // Configure a GPIO as external TIM2 clock source
+   GPIO_PinAFConfig(PORT_EXT_CLK, SRC_EXT_CLK, GPIO_AF_TIM2);
+   GPIO_InitStruct.GPIO_Pin = PIN_EXT_CLK;
+   GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
+   GPIO_Init(PORT_EXT_CLK, &GPIO_InitStruct);
+#endif
+
+   TIM_TimeBaseInitTypeDef timerInitStructure;
+   TIM_TimeBaseStructInit (&timerInitStructure);
+
+   // TIM2 output frequency
+#if defined(EXTERNAL_OSC) && !(defined(STM32F4_PI) || defined(STM32F722_PI))
+   timerInitStructure.TIM_Prescaler = (uint16_t) ((EXTERNAL_OSC/(2*SAMP_FREQ)) - 1);
+   timerInitStructure.TIM_Period = 1;
+#else
+   timerInitStructure.TIM_Prescaler = (uint16_t) ((SystemCoreClock/(6*SAMP_FREQ)) - 1);
+   timerInitStructure.TIM_Period = 2;
+#endif
+
+   timerInitStructure.TIM_CounterMode       = TIM_CounterMode_Up;
+   timerInitStructure.TIM_ClockDivision     = TIM_CKD_DIV1;
+   timerInitStructure.TIM_RepetitionCounter = 0;
+   TIM_TimeBaseInit(TIM2, &timerInitStructure);
+
+#if defined(EXTERNAL_OSC) && !(defined(STM32F4_PI) || defined(STM32F722_PI))
+   // Enable external clock
+   TIM_ETRClockMode2Config(TIM2, TIM_ExtTRGPSC_OFF, TIM_ExtTRGPolarity_NonInverted, 0x00);
+#else
+   // Enable internal clock
+   TIM_InternalClockConfig(TIM2);
+#endif
+
+   // Enable TIM2
+   TIM_Cmd(TIM2, ENABLE);
+   // Enable TIM2 interrupt
+   TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);
+
+   NVIC_InitTypeDef nvicStructure;
+   nvicStructure.NVIC_IRQChannel                   = TIM2_IRQn;
+   nvicStructure.NVIC_IRQChannelPreemptionPriority = 0;
+   nvicStructure.NVIC_IRQChannelSubPriority        = 1;
+   nvicStructure.NVIC_IRQChannelCmd                = ENABLE;
+   NVIC_Init(&nvicStructure);
+
+   GPIO_ResetBits(PORT_COSLED, PIN_COSLED);
+   GPIO_SetBits(PORT_LED, PIN_LED);
 }
 
-void CIO::interrupt(uint8_t source)
+void CIO::interrupt()
 {
-  uint8_t control  = MARK_NONE;
-  uint16_t sample  = DC_OFFSET;
-  uint16_t rawRSSI = 0U;
+   TSample sample = {DC_OFFSET, MARK_NONE};
+   uint16_t rawRSSI = 0U;
 
-  m_txBuffer.get(sample, control);
+   m_txBuffer.get(sample);
 
-  // Send the value to the DAC
-  DAC_SetChannel1Data(DAC_Align_12b_R, sample);
-
-  // Read value from ADC1 and ADC2
-  if ((ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET)) {
-    // shouldn't be still in reset at this point so null the sample value?
-    sample  = 0U;
-  } else {
-    sample  = ADC_GetConversionValue(ADC1);
-#if defined(SEND_RSSI_DATA)
-    rawRSSI = ADC_GetConversionValue(ADC2);
+   // Send the value to the DAC
+#if defined(STM32F4_NUCLEO) && defined(STM32F4_NUCLEO_ARDUINO_HEADER)
+   DAC_SetChannel2Data(DAC_Align_12b_R, sample.sample);
+#else
+   DAC_SetChannel1Data(DAC_Align_12b_R, sample.sample);
 #endif
-  }
 
-  // trigger next ADC1
-  ADC_ClearFlag(ADC1, ADC_FLAG_EOC);
-  ADC_SoftwareStartConv(ADC1);
+   // Read value from ADC1 and ADC2
+   if ((ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET)) {
+      // shouldn't be still in reset at this point so null the sample value?
+      sample.sample  = 0U;
+   } else {
+      sample.sample  = ADC_GetConversionValue(ADC1);
+#if defined(SEND_RSSI_DATA)
+      rawRSSI = ADC_GetConversionValue(ADC2);
+#endif
+   }
 
-  m_rxBuffer.put(sample, control);
-  m_rssiBuffer.put(rawRSSI);
+   // trigger next ADC1
+   ADC_ClearFlag(ADC1, ADC_FLAG_EOC);
+   ADC_SoftwareStartConv(ADC1);
 
-  m_watchdog++;
+   m_rxBuffer.put(sample);
+   m_rssiBuffer.put(rawRSSI);
+
+   m_watchdog++;
 }
 
 bool CIO::getCOSInt()
 {
-  return GPIO_ReadOutputDataBit(PORT_COS, PIN_COS) == Bit_SET;
+   return GPIO_ReadInputDataBit(PORT_COS, PIN_COS) == Bit_SET;
 }
 
 void CIO::setLEDInt(bool on)
 {
-  GPIO_WriteBit(PORT_LED, PIN_LED, on ? Bit_SET : Bit_RESET);
+   GPIO_WriteBit(PORT_LED, PIN_LED, on ? Bit_SET : Bit_RESET);
 }
 
 void CIO::setPTTInt(bool on)
 {
-  GPIO_WriteBit(PORT_PTT, PIN_PTT, on ? Bit_SET : Bit_RESET);
+   GPIO_WriteBit(PORT_PTT, PIN_PTT, on ? Bit_SET : Bit_RESET);
 }
 
 void CIO::setCOSInt(bool on)
 {
-  GPIO_WriteBit(PORT_COSLED, PIN_COSLED, on ? Bit_SET : Bit_RESET);
+   GPIO_WriteBit(PORT_COSLED, PIN_COSLED, on ? Bit_SET : Bit_RESET);
 }
 
 void CIO::setDStarInt(bool on)
 {
-  GPIO_WriteBit(PORT_DSTAR, PIN_DSTAR, on ? Bit_SET : Bit_RESET);
+#if defined(MODE_LEDS)
+   GPIO_WriteBit(PORT_DSTAR, PIN_DSTAR, on ? Bit_SET : Bit_RESET);
+#endif
+#if defined(MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && (defined(STM32F4_NUCLEO) || defined(STM32F722_RPT_HAT))
+   GPIO_WriteBit(PORT_MDSTAR, PIN_MDSTAR, on ? Bit_SET : Bit_RESET);
+#endif
 }
 
-void CIO::setDMRInt(bool on) 
+void CIO::setDMRInt(bool on)
 {
-  GPIO_WriteBit(PORT_DMR, PIN_DMR, on ? Bit_SET : Bit_RESET);
+#if defined(MODE_LEDS)
+   GPIO_WriteBit(PORT_DMR, PIN_DMR, on ? Bit_SET : Bit_RESET);
+#endif
+#if defined(MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && (defined(STM32F4_NUCLEO) || defined(STM32F722_RPT_HAT))
+   GPIO_WriteBit(PORT_MDMR, PIN_MDMR, on ? Bit_SET : Bit_RESET);
+#endif
 }
 
 void CIO::setYSFInt(bool on)
 {
-  GPIO_WriteBit(PORT_YSF, PIN_YSF, on ? Bit_SET : Bit_RESET);
+#if defined(MODE_LEDS)
+   GPIO_WriteBit(PORT_YSF, PIN_YSF, on ? Bit_SET : Bit_RESET);
+#endif
+#if defined(MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && (defined(STM32F4_NUCLEO) || defined(STM32F722_RPT_HAT))
+   GPIO_WriteBit(PORT_MYSF, PIN_MYSF, on ? Bit_SET : Bit_RESET);
+#endif
 }
 
-void CIO::setP25Int(bool on) 
+void CIO::setP25Int(bool on)
 {
-  GPIO_WriteBit(PORT_P25, PIN_P25, on ? Bit_SET : Bit_RESET);
+#if defined(MODE_LEDS)
+   GPIO_WriteBit(PORT_P25, PIN_P25, on ? Bit_SET : Bit_RESET);
+#endif
+#if defined(MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && (defined(STM32F4_NUCLEO) || defined(STM32F722_RPT_HAT))
+   GPIO_WriteBit(PORT_MP25, PIN_MP25, on ? Bit_SET : Bit_RESET);
+#endif
+}
+
+void CIO::setNXDNInt(bool on)
+{
+#if defined(MODE_LEDS)
+#if defined(USE_ALTERNATE_NXDN_LEDS)
+   GPIO_WriteBit(PORT_YSF, PIN_YSF, on ? Bit_SET : Bit_RESET);
+   GPIO_WriteBit(PORT_P25, PIN_P25, on ? Bit_SET : Bit_RESET);
+#else
+   GPIO_WriteBit(PORT_NXDN, PIN_NXDN, on ? Bit_SET : Bit_RESET);
+#endif
+#endif
+
+#if defined(MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && (defined(STM32F4_NUCLEO) || defined(STM32F722_RPT_HAT))
+#if defined(USE_ALTERNATE_NXDN_LEDS)
+   GPIO_WriteBit(PORT_MYSF, PIN_MYSF, on ? Bit_SET : Bit_RESET);
+   GPIO_WriteBit(PORT_MP25, PIN_MP25, on ? Bit_SET : Bit_RESET);
+#else
+   GPIO_WriteBit(PORT_MNXDN, PIN_MNXDN, on ? Bit_SET : Bit_RESET);
+#endif
+#endif
+}
+
+void CIO::setPOCSAGInt(bool on)
+{
+#if defined(MODE_LEDS)
+#if defined(USE_ALTERNATE_POCSAG_LEDS)
+   GPIO_WriteBit(PORT_DSTAR, PIN_DSTAR, on ? Bit_SET : Bit_RESET);
+   GPIO_WriteBit(PORT_DMR,   PIN_DMR,   on ? Bit_SET : Bit_RESET);
+#else
+   GPIO_WriteBit(PORT_POCSAG,  PIN_POCSAG, on ? Bit_SET : Bit_RESET);
+#endif
+#endif
+
+#if defined(MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && (defined(STM32F4_NUCLEO) || defined(STM32F722_RPT_HAT))
+#if defined(USE_ALTERNATE_POCSAG_LEDS)
+   GPIO_WriteBit(PORT_MDSTAR, PIN_MDSTAR, on ? Bit_SET : Bit_RESET);
+   GPIO_WriteBit(PORT_MDMR,   PIN_MDMR,   on ? Bit_SET : Bit_RESET);
+#else
+   GPIO_WriteBit(PORT_MPOCSAG, PIN_MPOCSAG, on ? Bit_SET : Bit_RESET);
+#endif
+#endif
+}
+
+void CIO::setFMInt(bool on)
+{
+#if defined(MODE_LEDS)
+#if defined(USE_ALTERNATE_FM_LEDS)
+   GPIO_WriteBit(PORT_DSTAR, PIN_DSTAR, on ? Bit_SET : Bit_RESET);
+   GPIO_WriteBit(PORT_YSF,   PIN_YSF,   on ? Bit_SET : Bit_RESET);
+#else
+   GPIO_WriteBit(PORT_FM,  PIN_FM, on ? Bit_SET : Bit_RESET);
+#endif
+#endif
+
+#if defined(MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && (defined(STM32F4_NUCLEO) || defined(STM32F722_RPT_HAT))
+#if defined(USE_ALTERNATE_FM_LEDS)
+   GPIO_WriteBit(PORT_MDSTAR, PIN_MDSTAR, on ? Bit_SET : Bit_RESET);
+   GPIO_WriteBit(PORT_MYSF,   PIN_MYSF,   on ? Bit_SET : Bit_RESET);
+#else
+   GPIO_WriteBit(PORT_MFM, PIN_MFM, on ? Bit_SET : Bit_RESET);
+#endif
+#endif
+}
+
+// Simple delay function for STM32
+// Example from: http://thehackerworkshop.com/?p=1209
+void CIO::delayInt(unsigned int dly)
+{
+#if defined(STM32F7XX)
+  unsigned int loopsPerMillisecond = (SystemCoreClock/1000);
+#else
+  unsigned int loopsPerMillisecond = (SystemCoreClock/1000) / 3;
+#endif
+
+  for (; dly > 0; dly--)
+  {
+    asm volatile //this routine waits (approximately) one millisecond
+    (
+      "mov r3, %[loopsPerMillisecond] \n\t" //load the initial loop counter
+      "loop: \n\t"
+        "subs r3, #1 \n\t"
+        "bne loop \n\t"
+
+      : //empty output list
+      : [loopsPerMillisecond] "r" (loopsPerMillisecond) //input to the asm routine
+      : "r3", "cc" //clobber list
+    );
+  }
 }
 
 #endif
-

IOSTM_CMSIS.cpp

@@ -0,0 +1,507 @@
+/*
+ *   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 by Jonathan Naylor G4KLX
+ *   Copyright (C) 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
@@ -34,8 +34,17 @@
 #define PIN_DMR                10
 #define PIN_YSF                11
 #define PIN_P25                12
-#define PIN_ADC                5        // A0, Pin 14
-#define PIN_RSSI               8        // A2, Pin 16
+#if defined(__MK20DX256__)
+#define PIN_NXDN               2
+#define PIN_POCSAG             3
+#define PIN_FM                 4
+#else
+#define PIN_NXDN               24
+#define PIN_POCSAG             25
+#define PIN_FM                 26
+#endif
+#define PIN_ADC                5        // A0,  Pin 14
+#define PIN_RSSI               4        // Teensy 3.5/3.6, A16, Pin 35. Teensy 3.1/3.2, A17, Pin 28
 
 #define PDB_CHnC1_TOS 0x0100
 #define PDB_CHnC1_EN  0x0001
@@ -45,15 +54,8 @@ const uint16_t DC_OFFSET = 2048U;
 extern "C" {
   void adc0_isr()
   {
-    io.interrupt(0U);
+    io.interrupt();
   }
-
-#if defined(SEND_RSSI_DATA)
-  void adc1_isr()
-  {
-    io.interrupt(1U);
-  }
-#endif
 }
 
 void CIO::initInt()
@@ -64,12 +66,21 @@ void CIO::initInt()
   pinMode(PIN_LED,    OUTPUT);
   pinMode(PIN_COS,    INPUT);
 
-#if defined(ARDUINO_MODE_PINS)
+#if defined(MODE_LEDS)
   // Set up the mode output pins
   pinMode(PIN_DSTAR,  OUTPUT);
   pinMode(PIN_DMR,    OUTPUT);
   pinMode(PIN_YSF,    OUTPUT);
   pinMode(PIN_P25,    OUTPUT);
+#if !defined(USE_ALTERNATE_NXDN_LEDS)
+  pinMode(PIN_NXDN,   OUTPUT);
+#endif
+#if !defined(USE_ALTERNATE_POCSAG_LEDS)
+  pinMode(PIN_POCSAG, OUTPUT);
+#endif
+#if !defined(USE_ALTERNATE_FM_LEDS)
+  pinMode(PIN_FM,     OUTPUT);
+#endif
 #endif
 }
 
@@ -77,17 +88,17 @@ void CIO::startInt()
 {
   // Initialise the DAC
   SIM_SCGC2 |= SIM_SCGC2_DAC0;
-  DAC0_C0    = DAC_C0_DACEN | DAC_C0_DACRFS;                          // 1.2V VDDA is DACREF_2
+  DAC0_C0    = DAC_C0_DACEN | DAC_C0_DACRFS;                          // 3.3V VDDA is DACREF_2
 
   // Initialise ADC0
   SIM_SCGC6 |= SIM_SCGC6_ADC0;
   ADC0_CFG1  = ADC_CFG1_ADIV(1) | ADC_CFG1_ADICLK(1) |                // Single-ended 12 bits, long sample time
                ADC_CFG1_MODE(1) | ADC_CFG1_ADLSMP;
   ADC0_CFG2  = ADC_CFG2_MUXSEL | ADC_CFG2_ADLSTS(2);                  // Select channels ADxxxb
-  ADC0_SC2   = ADC_SC2_REFSEL(1) | ADC_SC2_ADTRG;                     // Voltage ref internal, hardware trigger
+  ADC0_SC2   = ADC_SC2_REFSEL(0) | ADC_SC2_ADTRG;                     // Voltage ref external, hardware trigger
   ADC0_SC3   = ADC_SC3_AVGE | ADC_SC3_AVGS(0);                        // Enable averaging, 4 samples
 
-  ADC0_SC3   = ADC_SC3_CAL;
+  ADC0_SC3  |= ADC_SC3_CAL;
   while (ADC0_SC3 & ADC_SC3_CAL)                                      // Wait for calibration
     ;
 
@@ -105,10 +116,10 @@ void CIO::startInt()
   ADC1_CFG1  = ADC_CFG1_ADIV(1) | ADC_CFG1_ADICLK(1) |                // Single-ended 12 bits, long sample time
                ADC_CFG1_MODE(1) | ADC_CFG1_ADLSMP;
   ADC1_CFG2  = ADC_CFG2_MUXSEL | ADC_CFG2_ADLSTS(2);                  // Select channels ADxxxb
-  ADC1_SC2   = ADC_SC2_REFSEL(1);                                     // Voltage ref internal, software trigger
+  ADC1_SC2   = ADC_SC2_REFSEL(0);                                     // Voltage ref external, software trigger
   ADC1_SC3   = ADC_SC3_AVGE | ADC_SC3_AVGS(0);                        // Enable averaging, 4 samples
 
-  ADC1_SC3   = ADC_SC3_CAL;
+  ADC1_SC3  |= ADC_SC3_CAL;
   while (ADC1_SC3 & ADC_SC3_CAL)                                      // Wait for calibration
     ;
 
@@ -116,14 +127,11 @@ void CIO::startInt()
                   ADC1_CLP2 + ADC1_CLP1 + ADC1_CLP0;
   sum1 = (sum1 / 2U) | 0x8000U;
   ADC1_PG    = sum1;
-
-  NVIC_ENABLE_IRQ(IRQ_ADC1);
 #endif
 
 #if defined(EXTERNAL_OSC)
   // Set ADC0 to trigger from the LPTMR at 24 kHz
   SIM_SOPT7   = SIM_SOPT7_ADC0ALTTRGEN |                              // Enable ADC0 alternate trigger
-                SIM_SOPT7_ADC0PRETRGSEL |                             // Enable ADC0 pre-trigger
                 SIM_SOPT7_ADC0TRGSEL(14);                             // Trigger ADC0 by LPTMR0
 
   CORE_PIN13_CONFIG = PORT_PCR_MUX(3);
@@ -151,37 +159,32 @@ void CIO::startInt()
   digitalWrite(PIN_LED,    HIGH);
 }
 
-void CIO::interrupt(uint8_t source)
+void CIO::interrupt()
 {
-  if (source == 0U) {  // ADC0
-    uint8_t control = MARK_NONE;
-    uint16_t sample = DC_OFFSET;
+   TSample sample = {DC_OFFSET, MARK_NONE};
 
-    m_txBuffer.get(sample, control);
-    *(int16_t *)&(DAC0_DAT0L) = sample;
-
-    if ((ADC0_SC1A & ADC_SC1_COCO) == ADC_SC1_COCO) {
-      sample = ADC0_RA;
-      m_rxBuffer.put(sample, control);
+  m_txBuffer.get(sample);
+  *(int16_t *)&(DAC0_DAT0L) = sample.sample;
 
+  if ((ADC0_SC1A & ADC_SC1_COCO) == ADC_SC1_COCO) {
+    sample.sample = ADC0_RA;
+    m_rxBuffer.put(sample);
+  }
+    
 #if defined(SEND_RSSI_DATA)
-      ADC1_SC1A  = ADC_SC1_AIEN | PIN_RSSI;
+  if ((ADC1_SC1A & ADC_SC1_COCO) == ADC_SC1_COCO) {
+    uint16_t rssi = ADC1_RA;
+    m_rssiBuffer.put(rssi);
+  } else {
+    m_rssiBuffer.put(0U);
+  }
+
+  ADC1_SC1A  = PIN_RSSI;         				    // Start the next RSSI conversion
 #else
-      m_rssiBuffer.put(0U);
+  m_rssiBuffer.put(0U);
 #endif
-    }
 
-    m_watchdog++;
-  }
-
-#if defined(SEND_RSSI_DATA)
-  if (source == 1U) {  // ADC1
-    if ((ADC1_SC1A & ADC_SC1_COCO) == ADC_SC1_COCO) {
-      uint16_t rssi = ADC1_RA;
-      m_rssiBuffer.put(rssi);
-    }
-  }
-#endif
+  m_watchdog++;
 }
 
 bool CIO::getCOSInt()
@@ -224,4 +227,39 @@ void CIO::setP25Int(bool on)
   digitalWrite(PIN_P25, on ? HIGH : LOW);
 }
 
+void CIO::setNXDNInt(bool on)
+{
+#if defined(USE_ALTERNATE_NXDN_LEDS)
+  digitalWrite(PIN_YSF, on ? HIGH : LOW);
+  digitalWrite(PIN_P25, on ? HIGH : LOW);
+#else
+  digitalWrite(PIN_NXDN, on ? HIGH : LOW);
+#endif
+}
+
+void CIO::setPOCSAGInt(bool on)
+{
+#if defined(USE_ALTERNATE_POCSAG_LEDS)
+  digitalWrite(PIN_DSTAR, on ? HIGH : LOW);
+  digitalWrite(PIN_DMR,   on ? HIGH : LOW);
+#else
+  digitalWrite(PIN_POCSAG, on ? HIGH : LOW);
+#endif
+}
+
+void CIO::setFMInt(bool on)
+{
+#if defined(USE_ALTERNATE_FM_LEDS)
+  digitalWrite(PIN_DSTAR, on ? HIGH : LOW);
+  digitalWrite(PIN_YSF,   on ? HIGH : LOW);
+#else
+  digitalWrite(PIN_FM, on ? HIGH : LOW);
+#endif
+}
+
+void CIO::delayInt(unsigned int dly)
+{
+  delay(dly);
+}
+
 #endif

MMDVM.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020 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(STM32F4)
+#if defined(STM32F4XX) || defined(STM32F7XX) || defined(STM32F105xC)
 
 #include "Config.h"
 #include "Globals.h"
@@ -26,19 +26,19 @@
 // Global variables
 MMDVM_STATE m_modemState = STATE_IDLE;
 
-bool m_dstarEnable = true;
-bool m_dmrEnable   = true;
-bool m_ysfEnable   = true;
-bool m_p25Enable   = true;
+bool m_dstarEnable  = true;
+bool m_dmrEnable    = true;
+bool m_ysfEnable    = true;
+bool m_p25Enable    = true;
+bool m_nxdnEnable   = true;
+bool m_pocsagEnable = true;
+bool m_fmEnable     = true;
 
 bool m_duplex = true;
 
 bool m_tx  = false;
 bool m_dcd = false;
 
-uint32_t m_sampleCount = 0U;
-bool    m_sampleInsert = false;
-
 CDStarRX   dstarRX;
 CDStarTX   dstarTX;
 
@@ -55,9 +55,21 @@ CYSFTX     ysfTX;
 CP25RX     p25RX;
 CP25TX     p25TX;
 
+CNXDNRX    nxdnRX;
+CNXDNTX    nxdnTX;
+
+CPOCSAGTX  pocsagTX;
+
+CFM        fm;
+
 CCalDStarRX calDStarRX;
 CCalDStarTX calDStarTX;
 CCalDMR     calDMR;
+CCalP25     calP25;
+CCalNXDN    calNXDN;
+CCalFM      calFM;
+CCalPOCSAG  calPOCSAG;
+CCalRSSI    calRSSI;
 
 CCWIdTX cwIdTX;
 
@@ -92,14 +104,35 @@ void loop()
   if (m_p25Enable && m_modemState == STATE_P25)
     p25TX.process();
 
+  if (m_nxdnEnable && m_modemState == STATE_NXDN)
+    nxdnTX.process();
+
+  if (m_pocsagEnable && (m_modemState == STATE_POCSAG || pocsagTX.busy()))
+    pocsagTX.process();
+
+  if (m_fmEnable && m_modemState == STATE_FM)
+    fm.process();
+
   if (m_modemState == STATE_DSTARCAL)
     calDStarTX.process();
 
-  if (m_modemState == STATE_DMRCAL)
+  if (m_modemState == STATE_DMRCAL || m_modemState == STATE_LFCAL || m_modemState == STATE_DMRCAL1K || m_modemState == STATE_DMRDMO1K)
     calDMR.process();
 
-	if (m_modemState == STATE_IDLE)
-		cwIdTX.process();
+  if (m_modemState == STATE_P25CAL1K)
+    calP25.process();
+
+  if (m_modemState == STATE_NXDNCAL1K)
+    calNXDN.process();
+
+  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();
+
+  if (m_modemState == STATE_IDLE)
+    cwIdTX.process();
 }
 
 int main()
@@ -111,4 +144,3 @@ int main()
 }
 
 #endif
-

MMDVM.ino

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -23,19 +23,19 @@
 // Global variables
 MMDVM_STATE m_modemState = STATE_IDLE;
 
-bool m_dstarEnable = true;
-bool m_dmrEnable   = true;
-bool m_ysfEnable   = true;
-bool m_p25Enable   = true;
+bool m_dstarEnable  = true;
+bool m_dmrEnable    = true;
+bool m_ysfEnable    = true;
+bool m_p25Enable    = true;
+bool m_nxdnEnable   = true;
+bool m_pocsagEnable = true;
+bool m_fmEnable     = true;
 
 bool m_duplex = true;
 
 bool m_tx  = false;
 bool m_dcd = false;
 
-uint32_t m_sampleCount = 0U;
-bool    m_sampleInsert = false;
-
 CDStarRX   dstarRX;
 CDStarTX   dstarTX;
 
@@ -52,9 +52,21 @@ CYSFTX     ysfTX;
 CP25RX     p25RX;
 CP25TX     p25TX;
 
+CNXDNRX    nxdnRX;
+CNXDNTX    nxdnTX;
+
+CPOCSAGTX  pocsagTX;
+
+CFM        fm;
+
 CCalDStarRX calDStarRX;
 CCalDStarTX calDStarTX;
 CCalDMR     calDMR;
+CCalFM      calFM;
+CCalP25     calP25;
+CCalNXDN    calNXDN;
+CCalPOCSAG  calPOCSAG;
+CCalRSSI    calRSSI;
 
 CCWIdTX cwIdTX;
 
@@ -89,13 +101,33 @@ void loop()
   if (m_p25Enable && m_modemState == STATE_P25)
     p25TX.process();
 
+  if (m_nxdnEnable && m_modemState == STATE_NXDN)
+    nxdnTX.process();
+
+  if (m_pocsagEnable && (m_modemState == STATE_POCSAG || pocsagTX.busy()))
+    pocsagTX.process();
+
+  if (m_fmEnable && m_modemState == STATE_FM)
+    fm.process();
+
   if (m_modemState == STATE_DSTARCAL)
     calDStarTX.process();
 
-  if (m_modemState == STATE_DMRCAL)
+  if (m_modemState == STATE_DMRCAL || m_modemState == STATE_LFCAL || m_modemState == STATE_DMRCAL1K || m_modemState == STATE_DMRDMO1K)
     calDMR.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();
+
+  if (m_modemState == STATE_P25CAL1K)
+    calP25.process();
+
+  if (m_modemState == STATE_NXDNCAL1K)
+    calNXDN.process();
+
+  if (m_modemState == STATE_POCSAGCAL)
+    calPOCSAG.process();
+
   if (m_modemState == STATE_IDLE)
     cwIdTX.process();
 }
-

MMDVM_STM32F4xx.coproj

@@ -1,338 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<Project version="2G - 1.7.8" name="MMDVM_STM32F4xx">
-  <Target name="MMDVM_Discovery_407" isCurrent="1">
-    <Device manufacturerId="9" manufacturerName="ST" chipId="344" chipName="STM32F407VG" boardId="" boardName=""/>
-    <BuildOption>
-      <Compile>
-        <Option name="OptimizationLevel" value="4"/>
-        <Option name="UseFPU" value="0"/>
-        <Option name="UserEditCompiler" value=""/>
-        <Option name="SupportCPlusplus" value="1"/>
-        <Option name="FPU" value="2"/>
-        <Includepaths>
-          <Includepath path="."/>
-        </Includepaths>
-        <DefinedSymbols>
-          <Define name="STM32F4XX"/>
-          <Define name="USE_STDPERIPH_DRIVER"/>
-          <Define name="__ASSEMBLY__"/>
-          <Define name="SUPPORT_CPLUSPLUS"/>
-          <Define name="STM32F40_41xxx"/>
-          <Define name="HSE_VALUE=8000000"/>
-          <Define name="STM32F4_DISCOVERY"/>
-          <Define name="__FPU_USED"/>
-        </DefinedSymbols>
-      </Compile>
-      <Link useDefault="0">
-        <Option name="DiscardUnusedSection" value="0"/>
-        <Option name="UserEditLinkder" value=""/>
-        <Option name="UseMemoryLayout" value="0"/>
-        <Option name="nostartfiles" value="1"/>
-        <Option name="LTO" value="0"/>
-        <Option name="IsNewStartupCode" value="1"/>
-        <Option name="Library" value="Semihosting"/>
-        <Option name="UserEditLinker" value="-lstdc++; --specs=nano.specs;"/>
-        <LinkedLibraries>
-          <Libset dir="stm32f4xx_lib\cmsis\lib\gcc\" libs="arm_cortexm4lf_math"/>
-        </LinkedLibraries>
-        <MemoryAreas debugInFlashNotRAM="1">
-          <Memory name="IROM1" type="ReadOnly" size="0x00100000" startValue="0x08000000"/>
-          <Memory name="IRAM1" type="ReadWrite" size="0x00020000" startValue="0x20000000"/>
-          <Memory name="IROM2" type="ReadOnly" size="" startValue=""/>
-          <Memory name="IRAM2" type="ReadWrite" size="0x00010000" startValue="0x10000000"/>
-        </MemoryAreas>
-        <LocateLinkFile path="./stm32f4xx_link.ld" type="0"/>
-      </Link>
-      <Output>
-        <Option name="OutputFileType" value="0"/>
-        <Option name="Path" value="./"/>
-        <Option name="Name" value="MMDVM_DIS"/>
-        <Option name="HEX" value="1"/>
-        <Option name="BIN" value="1"/>
-      </Output>
-      <User>
-        <UserRun name="Run#1" type="Before" checked="0" value=""/>
-        <UserRun name="Run#1" type="After" checked="0" value=""/>
-      </User>
-    </BuildOption>
-    <DebugOption>
-      <Option name="org.coocox.codebugger.gdbjtag.core.adapter" value="ST-Link"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.debugMode" value="SWD"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.clockDiv" value="1M"/>
-      <Option name="org.coocox.codebugger.gdbjtag.corerunToMain" value="1"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.jlinkgdbserver" value=""/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.userDefineGDBScript" value=""/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.targetEndianess" value="0"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.jlinkResetMode" value="Type 0: Normal"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.resetMode" value="SYSRESETREQ"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.ifSemihost" value="0"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.ifCacheRom" value="1"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.ipAddress" value="127.0.0.1"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.portNumber" value="2009"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.autoDownload" value="1"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.verify" value="1"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.downloadFuction" value="Erase Effected"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.defaultAlgorithm" value="STM32F4xx_1024.elf"/>
-    </DebugOption>
-    <ExcludeFile/>
-  </Target>
-  <Target name="MMDVM_Pi_446" isCurrent="0">
-    <Device manufacturerId="9" manufacturerName="ST" chipId="344" chipName="STM32F407VG" boardId="" boardName=""/>
-    <BuildOption>
-      <Compile>
-        <Option name="OptimizationLevel" value="4"/>
-        <Option name="UseFPU" value="0"/>
-        <Option name="UserEditCompiler" value=""/>
-        <Option name="SupportCPlusplus" value="1"/>
-        <Option name="FPU" value="2"/>
-        <Includepaths>
-          <Includepath path="."/>
-        </Includepaths>
-        <DefinedSymbols>
-          <Define name="STM32F4XX"/>
-          <Define name="USE_STDPERIPH_DRIVER"/>
-          <Define name="__ASSEMBLY__"/>
-          <Define name="SUPPORT_CPLUSPLUS"/>
-          <Define name="__FPU_USED"/>
-          <Define name="STM32F446xx"/>
-          <Define name="HSE_VALUE=12000000"/>
-          <Define name="STM32F4_PI"/>
-          <Define name="ARDUINO_MODE_PINS"/>
-          <Define name="SEND_RSSI_DATA"/>
-          <Define name="SERIAL_REPEATER"/>
-        </DefinedSymbols>
-      </Compile>
-      <Link useDefault="0">
-        <Option name="DiscardUnusedSection" value="0"/>
-        <Option name="UserEditLinkder" value=""/>
-        <Option name="UseMemoryLayout" value="0"/>
-        <Option name="nostartfiles" value="1"/>
-        <Option name="LTO" value="0"/>
-        <Option name="IsNewStartupCode" value="1"/>
-        <Option name="Library" value="Semihosting"/>
-        <Option name="UserEditLinker" value="-lstdc++; --specs=nano.specs;"/>
-        <LinkedLibraries>
-          <Libset dir="stm32f4xx_lib\cmsis\lib\gcc\" libs="arm_cortexm4lf_math"/>
-        </LinkedLibraries>
-        <MemoryAreas debugInFlashNotRAM="1">
-          <Memory name="IROM1" type="ReadOnly" size="0x00100000" startValue="0x08000000"/>
-          <Memory name="IRAM1" type="ReadWrite" size="0x00020000" startValue="0x20000000"/>
-          <Memory name="IROM2" type="ReadOnly" size="" startValue=""/>
-          <Memory name="IRAM2" type="ReadWrite" size="0x00010000" startValue="0x10000000"/>
-        </MemoryAreas>
-        <LocateLinkFile path="./stm32f4xx_link.ld" type="0"/>
-      </Link>
-      <Output>
-        <Option name="OutputFileType" value="0"/>
-        <Option name="Path" value="./"/>
-        <Option name="Name" value="MMDVM_PI"/>
-        <Option name="HEX" value="1"/>
-        <Option name="BIN" value="1"/>
-      </Output>
-      <User>
-        <UserRun name="Run#1" type="Before" checked="0" value=""/>
-        <UserRun name="Run#1" type="After" checked="0" value=""/>
-      </User>
-    </BuildOption>
-    <DebugOption>
-      <Option name="org.coocox.codebugger.gdbjtag.core.adapter" value="ST-Link"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.debugMode" value="SWD"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.clockDiv" value="1M"/>
-      <Option name="org.coocox.codebugger.gdbjtag.corerunToMain" value="1"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.jlinkgdbserver" value=""/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.userDefineGDBScript" value=""/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.targetEndianess" value="0"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.jlinkResetMode" value="Type 0: Normal"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.resetMode" value="SYSRESETREQ"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.ifSemihost" value="0"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.ifCacheRom" value="1"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.ipAddress" value="127.0.0.1"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.portNumber" value="2009"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.autoDownload" value="1"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.verify" value="1"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.downloadFuction" value="Erase Effected"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.defaultAlgorithm" value="STM32F4xx_1024.elf"/>
-    </DebugOption>
-    <ExcludeFile/>
-  </Target>
-  <Target name="MMDVM_Nucleo_446" isCurrent="0">
-    <Device manufacturerId="9" manufacturerName="ST" chipId="344" chipName="STM32F407VG" boardId="" boardName=""/>
-    <BuildOption>
-      <Compile>
-        <Option name="OptimizationLevel" value="4"/>
-        <Option name="UseFPU" value="0"/>
-        <Option name="UserEditCompiler" value=""/>
-        <Option name="SupportCPlusplus" value="1"/>
-        <Option name="FPU" value="2"/>
-        <Includepaths>
-          <Includepath path="."/>
-        </Includepaths>
-        <DefinedSymbols>
-          <Define name="STM32F4XX"/>
-          <Define name="USE_STDPERIPH_DRIVER"/>
-          <Define name="__ASSEMBLY__"/>
-          <Define name="SUPPORT_CPLUSPLUS"/>
-          <Define name="HSE_VALUE=8000000"/>
-          <Define name="__FPU_USED"/>
-          <Define name="STM32F4_NUCLEO"/>
-          <Define name="STM32F446xx"/>
-        </DefinedSymbols>
-      </Compile>
-      <Link useDefault="0">
-        <Option name="DiscardUnusedSection" value="0"/>
-        <Option name="UserEditLinkder" value=""/>
-        <Option name="UseMemoryLayout" value="0"/>
-        <Option name="nostartfiles" value="1"/>
-        <Option name="LTO" value="0"/>
-        <Option name="IsNewStartupCode" value="1"/>
-        <Option name="Library" value="Semihosting"/>
-        <Option name="UserEditLinker" value="-lstdc++; --specs=nano.specs;"/>
-        <LinkedLibraries>
-          <Libset dir="stm32f4xx_lib\cmsis\lib\gcc\" libs="arm_cortexm4lf_math"/>
-        </LinkedLibraries>
-        <MemoryAreas debugInFlashNotRAM="1">
-          <Memory name="IROM1" type="ReadOnly" size="0x00100000" startValue="0x08000000"/>
-          <Memory name="IRAM1" type="ReadWrite" size="0x00020000" startValue="0x20000000"/>
-          <Memory name="IROM2" type="ReadOnly" size="" startValue=""/>
-          <Memory name="IRAM2" type="ReadWrite" size="0x00010000" startValue="0x10000000"/>
-        </MemoryAreas>
-        <LocateLinkFile path="./stm32f4xx_link.ld" type="0"/>
-      </Link>
-      <Output>
-        <Option name="OutputFileType" value="0"/>
-        <Option name="Path" value="./"/>
-        <Option name="Name" value="MMDVM_NUCLEO"/>
-        <Option name="HEX" value="1"/>
-        <Option name="BIN" value="1"/>
-      </Output>
-      <User>
-        <UserRun name="Run#1" type="Before" checked="0" value=""/>
-        <UserRun name="Run#1" type="After" checked="0" value=""/>
-      </User>
-    </BuildOption>
-    <DebugOption>
-      <Option name="org.coocox.codebugger.gdbjtag.core.adapter" value="ST-Link"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.debugMode" value="SWD"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.clockDiv" value="1M"/>
-      <Option name="org.coocox.codebugger.gdbjtag.corerunToMain" value="1"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.jlinkgdbserver" value=""/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.userDefineGDBScript" value=""/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.targetEndianess" value="0"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.jlinkResetMode" value="Type 0: Normal"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.resetMode" value="SYSRESETREQ"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.ifSemihost" value="0"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.ifCacheRom" value="1"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.ipAddress" value="127.0.0.1"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.portNumber" value="2009"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.autoDownload" value="1"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.verify" value="1"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.downloadFuction" value="Erase Effected"/>
-      <Option name="org.coocox.codebugger.gdbjtag.core.defaultAlgorithm" value="STM32F4xx_1024.elf"/>
-    </DebugOption>
-    <ExcludeFile/>
-  </Target>
-  <Components path="./">
-  </Components>
-  <Files>
-    <File name="DMRIdleRX.h" path="DMRIdleRX.h" type="1"/>
-    <File name="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/source/stm32f4xx_dac.c" path="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/source/stm32f4xx_dac.c" type="1"/>
-    <File name="DMRDMOTX.cpp" path="DMRDMOTX.cpp" type="1"/>
-    <File name="DMRRX.cpp" path="DMRRX.cpp" type="1"/>
-    <File name="YSFRX.cpp" path="YSFRX.cpp" type="1"/>
-    <File name="STM32F4XX_Lib/Device/stm32f4xx.h" path="STM32F4XX_Lib/Device/stm32f4xx.h" type="1"/>
-    <File name="SampleRB.cpp" path="SampleRB.cpp" type="1"/>
-    <File name="CalDStarTX.h" path="CalDStarTX.h" type="1"/>
-    <File name="STM32F4XX_Lib/CMSIS/Include/core_cm4.h" path="STM32F4XX_Lib/CMSIS/Include/core_cm4.h" type="1"/>
-    <File name="DMRSlotRX.h" path="DMRSlotRX.h" type="1"/>
-    <File name="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/source/stm32f4xx_tim.c" path="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/source/stm32f4xx_tim.c" type="1"/>
-    <File name="YSFRX.h" path="YSFRX.h" type="1"/>
-    <File name="STM32F4XX_Lib/CMSIS/Include" path="" type="2"/>
-    <File name="IO.cpp" path="IO.cpp" type="1"/>
-    <File name="DMRDMORX.cpp" path="DMRDMORX.cpp" type="1"/>
-    <File name="P25RX.h" path="P25RX.h" type="1"/>
-    <File name="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/source/misc.c" path="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/source/misc.c" type="1"/>
-    <File name="STM32F4XX_Lib/CMSIS" path="" type="2"/>
-    <File name="SerialArduino.cpp" path="SerialArduino.cpp" type="1"/>
-    <File name="SerialPort.cpp" path="SerialPort.cpp" type="1"/>
-    <File name="STM32F4XX_Lib/Device/stm32f4xx_conf.h" path="STM32F4XX_Lib/Device/stm32f4xx_conf.h" type="1"/>
-    <File name="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/source/stm32f4xx_adc.c" path="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/source/stm32f4xx_adc.c" type="1"/>
-    <File name="DStarTX.cpp" path="DStarTX.cpp" type="1"/>
-    <File name="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/source/stm32f4xx_usart.c" path="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/source/stm32f4xx_usart.c" type="1"/>
-    <File name="SampleRB.h" path="SampleRB.h" type="1"/>
-    <File name="YSFTX.h" path="YSFTX.h" type="1"/>
-    <File name="DMRRX.h" path="DMRRX.h" type="1"/>
-    <File name="IOTeensy.cpp" path="IOTeensy.cpp" type="1"/>
-    <File name="MMDVM.cpp" path="MMDVM.cpp" type="1"/>
-    <File name="STM32F4XX_Lib/CMSIS/Include/core_cmSimd.h" path="STM32F4XX_Lib/CMSIS/Include/core_cmSimd.h" type="1"/>
-    <File name="DMRDMORX.h" path="DMRDMORX.h" type="1"/>
-    <File name="SerialPort.h" path="SerialPort.h" type="1"/>
-    <File name="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/include/stm32f4xx_dac.h" path="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/include/stm32f4xx_dac.h" type="1"/>
-    <File name="CWIdTX.h" path="CWIdTX.h" type="1"/>
-    <File name="STM32F4XX_Lib/Device/system_stm32f4xx.h" path="STM32F4XX_Lib/Device/system_stm32f4xx.h" type="1"/>
-    <File name="STM32F4XX_Lib/CMSIS/Include/core_cmFunc.h" path="STM32F4XX_Lib/CMSIS/Include/core_cmFunc.h" type="1"/>
-    <File name="CalDStarTX.cpp" path="CalDStarTX.cpp" type="1"/>
-    <File name="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/source" path="" type="2"/>
-    <File name="CalDMR.h" path="CalDMR.h" type="1"/>
-    <File name="DMRDMOTX.h" path="DMRDMOTX.h" type="1"/>
-    <File name="IODue.cpp" path="IODue.cpp" type="1"/>
-    <File name="DMRTX.cpp" path="DMRTX.cpp" type="1"/>
-    <File name="P25RX.cpp" path="P25RX.cpp" type="1"/>
-    <File name="STM32F4XX_Lib/CMSIS/Lib/GCC" path="" type="2"/>
-    <File name="STM32F4XX_Lib" path="" type="2"/>
-    <File name="STM32F4XX_Lib/CMSIS/Include/core_cmInstr.h" path="STM32F4XX_Lib/CMSIS/Include/core_cmInstr.h" type="1"/>
-    <File name="DMRTX.h" path="DMRTX.h" type="1"/>
-    <File name="STM32F4XX_Lib/Device/system_stm32f4xx.c" path="STM32F4XX_Lib/Device/system_stm32f4xx.c" type="1"/>
-    <File name="RSSIRB.h" path="RSSIRB.h" type="1"/>
-    <File name="STM32F4XX_Lib/Device/startup/startup_stm32f4xx.c" path="STM32F4XX_Lib/Device/startup/startup_stm32f4xx.c" type="1"/>
-    <File name="STM32F4XX_Lib/Device/startup" path="" type="2"/>
-    <File name="SerialRB.h" path="SerialRB.h" type="1"/>
-    <File name="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/include/stm32f4xx_gpio.h" path="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/include/stm32f4xx_gpio.h" type="1"/>
-    <File name="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver" path="" type="2"/>
-    <File name="DMRDefines.h" path="DMRDefines.h" type="1"/>
-    <File name="CalDMR.cpp" path="CalDMR.cpp" type="1"/>
-    <File name="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/include/stm32f4xx_adc.h" path="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/include/stm32f4xx_adc.h" type="1"/>
-    <File name="SerialSTM.cpp" path="SerialSTM.cpp" type="1"/>
-    <File name="STM32F4XX_Lib/CMSIS/Lib/GCC/libarm_cortexM4lf_math.a" path="STM32F4XX_Lib/CMSIS/Lib/GCC/libarm_cortexM4lf_math.a" type="1"/>
-    <File name="DStarDefines.h" path="DStarDefines.h" type="1"/>
-    <File name="DStarRX.h" path="DStarRX.h" type="1"/>
-    <File name="Config.h" path="Config.h" type="1"/>
-    <File name="DMRSlotType.cpp" path="DMRSlotType.cpp" type="1"/>
-    <File name="Globals.h" path="Globals.h" type="1"/>
-    <File name="STM32F4XX_Lib/Device" path="" type="2"/>
-    <File name="CalDStarRX.cpp" path="CalDStarRX.cpp" type="1"/>
-    <File name="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/include/stm32f4xx_tim.h" path="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/include/stm32f4xx_tim.h" type="1"/>
-    <File name="CalDStarRX.h" path="CalDStarRX.h" type="1"/>
-    <File name="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/include" path="" type="2"/>
-    <File name="IO.h" path="IO.h" type="1"/>
-    <File name="Utils.cpp" path="Utils.cpp" type="1"/>
-    <File name="STM32F4XX_Lib/CMSIS/.DS_Store" path="STM32F4XX_Lib/CMSIS/.DS_Store" type="1"/>
-    <File name="STM32F4XX_Lib/CMSIS/Lib/.DS_Store" path="STM32F4XX_Lib/CMSIS/Lib/.DS_Store" type="1"/>
-    <File name="Utils.h" path="Utils.h" type="1"/>
-    <File name="STM32F4XX_Lib/CMSIS/Lib" path="" type="2"/>
-    <File name="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/.DS_Store" path="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/.DS_Store" type="1"/>
-    <File name="STM32F4XX_Lib/CMSIS/Include/.DS_Store" path="STM32F4XX_Lib/CMSIS/Include/.DS_Store" type="1"/>
-    <File name="STM32F4XX_Lib/CMSIS/Include/arm_math.h" path="STM32F4XX_Lib/CMSIS/Include/arm_math.h" type="1"/>
-    <File name="YSFDefines.h" path="YSFDefines.h" type="1"/>
-    <File name="DStarTX.h" path="DStarTX.h" type="1"/>
-    <File name="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/source/stm32f4xx_rcc.c" path="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/source/stm32f4xx_rcc.c" type="1"/>
-    <File name="STM32F4XX_Lib/Device/.DS_Store" path="STM32F4XX_Lib/Device/.DS_Store" type="1"/>
-    <File name="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/include/stm32f4xx_rcc.h" path="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/include/stm32f4xx_rcc.h" type="1"/>
-    <File name="P25Defines.h" path="P25Defines.h" type="1"/>
-    <File name="DMRSlotType.h" path="DMRSlotType.h" type="1"/>
-    <File name="Debug.h" path="Debug.h" type="1"/>
-    <File name="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/include/misc.h" path="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/include/misc.h" type="1"/>
-    <File name="P25TX.h" path="P25TX.h" type="1"/>
-    <File name="RSSIRB.cpp" path="RSSIRB.cpp" type="1"/>
-    <File name="DStarRX.cpp" path="DStarRX.cpp" type="1"/>
-    <File name="DMRSlotRX.cpp" path="DMRSlotRX.cpp" type="1"/>
-    <File name="IOSTM.cpp" path="IOSTM.cpp" type="1"/>
-    <File name="P25TX.cpp" path="P25TX.cpp" type="1"/>
-    <File name="SerialRB.cpp" path="SerialRB.cpp" type="1"/>
-    <File name="CWIdTX.cpp" path="CWIdTX.cpp" type="1"/>
-    <File name="DMRIdleRX.cpp" path="DMRIdleRX.cpp" type="1"/>
-    <File name="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/include/stm32f4xx_usart.h" path="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/include/stm32f4xx_usart.h" type="1"/>
-    <File name="STM32F4XX_Lib/.DS_Store" path="STM32F4XX_Lib/.DS_Store" type="1"/>
-    <File name="YSFTX.cpp" path="YSFTX.cpp" type="1"/>
-    <File name="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/source/stm32f4xx_gpio.c" path="STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/source/stm32f4xx_gpio.c" type="1"/>
-  </Files>
-</Project>

Makefile

@@ -1,4 +1,4 @@
-#  Copyright (C) 2016 by Andy Uribe CA6JAU
+#  Copyright (C) 2016,2017,2018 by Andy Uribe CA6JAU
 #  Copyright (C) 2016 by Jim McLaughlin KI6ZUM
 
 #  This program is free software; you can redistribute it and/or modify
@@ -15,6 +15,55 @@
 #  along with this program; if not, write to the Free Software
 #  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
+# MMDVM source files
+MMDVM_PATH=.
+
+# STM32 library paths
+F4_LIB_PATH=./STM32F4XX_Lib
+F7_LIB_PATH=./STM32F7XX_Lib
+
+# MCU external clock frequency (Hz)
+CLK_MMDVM_PI=12000000
+CLK_NUCLEO=8000000
+CLK_12MHZ=12000000
+
+# Directory Structure
+BINDIR=bin
+OBJDIR_F4=obj_f4
+OBJDIR_F7=obj_f7
+
+# Output files
+BINELF_F4=mmdvm_f4.elf
+BINHEX_F4=mmdvm_f4.hex
+BINBIN_F4=mmdvm_f4.bin
+BINELF_F7=mmdvm_f7.elf
+BINHEX_F7=mmdvm_f7.hex
+BINBIN_F7=mmdvm_f7.bin
+
+# Header directories
+INC_F4= . $(F4_LIB_PATH)/CMSIS/Include/ $(F4_LIB_PATH)/Device/ $(F4_LIB_PATH)/STM32F4xx_StdPeriph_Driver/include/
+INCLUDES_F4=$(INC_F4:%=-I%)
+INC_F7= . $(F7_LIB_PATH)/CMSIS/Include/ $(F7_LIB_PATH)/Device/ $(F7_LIB_PATH)/STM32F7xx_StdPeriph_Driver/inc/
+INCLUDES_F7=$(INC_F7:%=-I%)
+
+# CMSIS libraries
+INCLUDES_LIBS_F4=$(F4_LIB_PATH)/CMSIS/Lib/GCC/libarm_cortexM4lf_math.a
+INCLUDES_LIBS_F7=$(F7_LIB_PATH)/CMSIS/Lib/GCC/libarm_cortexM7lfsp_math.a
+
+# STM32F4 Standard Peripheral Libraries source path
+STD_LIB_F4=$(F4_LIB_PATH)/STM32F4xx_StdPeriph_Driver/source
+
+# STM32F7 Standard Peripheral Libraries source path
+STD_LIB_F7=$(F7_LIB_PATH)/STM32F7xx_StdPeriph_Driver/src
+
+# STM32F4 system source path
+SYS_DIR_F4=$(F4_LIB_PATH)/Device
+STARTUP_DIR_F4=$(F4_LIB_PATH)/Device/startup
+
+# STM32F7 system source path
+SYS_DIR_F7=$(F7_LIB_PATH)/Device
+STARTUP_DIR_F7=$(F7_LIB_PATH)/Device/startup
+
 # GNU ARM Embedded Toolchain
 CC=arm-none-eabi-gcc
 CXX=arm-none-eabi-g++
@@ -27,147 +76,308 @@ NM=arm-none-eabi-nm
 SIZE=arm-none-eabi-size
 A2L=arm-none-eabi-addr2line
 
-# Directory Structure
-BINDIR=bin
-
-# Find source files
 # "SystemRoot" is only defined in Windows
 ifdef SYSTEMROOT
-	ASOURCES=$(shell dir /S /B *.s)
-	CSOURCES=$(shell dir /S /B *.c)
-	CXXSOURCES=$(shell dir /S /B *.cpp)
-	CLEANCMD=del /S *.o *.hex *.bin *.elf
-	MDBIN=md $@
+	CLEANCMD=del /S *.o *.hex *.bin *.elf GitVersion.h
+	MDDIRS=md $@
 else ifdef SystemRoot
-	ASOURCES=$(shell dir /S /B *.s)
-	CSOURCES=$(shell dir /S /B *.c)
-	CXXSOURCES=$(shell dir /S /B *.cpp)
-	CLEANCMD=del /S *.o *.hex *.bin *.elf
-	MDBIN=md $@
+	CLEANCMD=del /S *.o *.hex *.bin *.elf GitVersion.h
+	MDDIRS=md $@
 else
-	ASOURCES=$(shell find . -name '*.s')
-	CSOURCES=$(shell find . -name '*.c')
-	CXXSOURCES=$(shell find . -name '*.cpp')
-	CLEANCMD=rm -f $(OBJECTS) $(BINDIR)/$(BINELF) $(BINDIR)/$(BINHEX) $(BINDIR)/$(BINBIN)
-	MDBIN=mkdir $@
+	CLEANCMD=rm -f $(OBJ_F4) $(OBJ_F7) $(BINDIR)/*.hex $(BINDIR)/*.bin $(BINDIR)/*.elf GitVersion.h
+	MDDIRS=mkdir $@
 endif
 
 # Default reference oscillator frequencies
 ifndef $(OSC)
 	ifeq ($(MAKECMDGOALS),pi)
-		OSC=12000000
+		OSC=$(CLK_MMDVM_PI)
+	else ifeq ($(MAKECMDGOALS),pi-f722)
+		OSC=$(CLK_MMDVM_PI)
+	else ifeq ($(MAKECMDGOALS),drcc_nqf)
+		OSC=$(CLK_12MHZ)
 	else
-		OSC=8000000
+		OSC=$(CLK_NUCLEO)
 	endif
 endif
 
-# Find header directories
-INC= . STM32F4XX_Lib/CMSIS/Include/ STM32F4XX_Lib/Device/ STM32F4XX_Lib/STM32F4xx_StdPeriph_Driver/include/
-INCLUDES=$(INC:%=-I%)
+# Build object lists
+CXXSRC=$(wildcard $(MMDVM_PATH)/*.cpp)
+CSRC_STD_F4=$(wildcard $(STD_LIB_F4)/*.c)
+SYS_F4=$(wildcard $(SYS_DIR_F4)/*.c)
+STARTUP_F4=$(wildcard $(STARTUP_DIR_F4)/*.c)
+CSRC_STD_F7=$(wildcard $(STD_LIB_F7)/*.c)
+SYS_F7=$(wildcard $(SYS_DIR_F7)/*.c)
+STARTUP_F7=$(wildcard $(STARTUP_DIR_F7)/*.c)
+OBJ_F4=$(CXXSRC:$(MMDVM_PATH)/%.cpp=$(OBJDIR_F4)/%.o) $(CSRC_STD_F4:$(STD_LIB_F4)/%.c=$(OBJDIR_F4)/%.o) $(SYS_F4:$(SYS_DIR_F4)/%.c=$(OBJDIR_F4)/%.o) $(STARTUP_F4:$(STARTUP_DIR_F4)/%.c=$(OBJDIR_F4)/%.o)
+OBJ_F7=$(CXXSRC:$(MMDVM_PATH)/%.cpp=$(OBJDIR_F7)/%.o) $(CSRC_STD_F7:$(STD_LIB_F7)/%.c=$(OBJDIR_F7)/%.o) $(SYS_F7:$(SYS_DIR_F7)/%.c=$(OBJDIR_F7)/%.o) $(STARTUP_F7:$(STARTUP_DIR_F7)/%.c=$(OBJDIR_F7)/%.o)
 
-# Find libraries
-INCLUDES_LIBS=STM32F4XX_Lib/CMSIS/Lib/GCC/libarm_cortexM4lf_math.a
-LINK_LIBS=
+# MCU flags
+MCFLAGS_F4=-mcpu=cortex-m4 -mthumb -mlittle-endian -mfpu=fpv4-sp-d16 -mfloat-abi=hard -mthumb-interwork
+MCFLAGS_F7=-mcpu=cortex-m7 -mthumb -mlittle-endian -mfpu=fpv5-sp-d16 -mfloat-abi=hard -mthumb-interwork
 
-# Create object list
-OBJECTS=$(ASOURCES:%.s=%.o)
-OBJECTS+=$(CSOURCES:%.c=%.o)
-OBJECTS+=$(CXXSOURCES:%.cpp=%.o)
-
-# Define output files ELF & IHEX
-BINELF=outp.elf
-BINHEX=outp.hex
-BINBIN=outp.bin
-
-# MCU FLAGS
-MCFLAGS=-mcpu=cortex-m4 -mthumb -mlittle-endian \
--mfpu=fpv4-sp-d16 -mfloat-abi=hard -mthumb-interwork
-
-# COMPILE FLAGS
+# Compile flags
 # STM32F4 Discovery board:
-DEFS_DIS=-DUSE_STDPERIPH_DRIVER -DSTM32F4XX -DSTM32F40_41xxx -DSTM32F4_DISCOVERY -DHSE_VALUE=$(OSC)
-# Pi board:
-DEFS_PI=-DUSE_STDPERIPH_DRIVER -DSTM32F4XX -DSTM32F446xx -DSTM32F4_PI -DARDUINO_MODE_PINS -DSEND_RSSI_DATA -DSERIAL_REPEATER -DHSE_VALUE=$(OSC)
-# STM32F4 Nucleo 446 board:
-DEFS_NUCLEO=-DUSE_STDPERIPH_DRIVER -DSTM32F4XX -DSTM32F446xx -DSTM32F4_NUCLEO -DHSE_VALUE=$(OSC)
+DEFS_DIS=-DUSE_STDPERIPH_DRIVER -DSTM32F4XX -DSTM32F40_41xxx -DSTM32F4_DISCOVERY -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
+# MMDVM-Pi board:
+DEFS_PI=-DUSE_STDPERIPH_DRIVER -DSTM32F4XX -DSTM32F446xx -DSTM32F4_PI -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
+# MMDVM-F4M F0DEI board:
+DEFS_F4M=-DUSE_STDPERIPH_DRIVER -DSTM32F4XX -DSTM32F446xx -DSTM32F4_F4M -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
+# STM32F4 Nucleo-64 F446RE board:
+DEFS_NUCLEO=-DUSE_STDPERIPH_DRIVER -DSTM32F4XX -DSTM32F446xx -DSTM32F4_NUCLEO -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
+# STM32F7 Nucleo-144 F767ZI board:
+DEFS_NUCLEO_F767=-DUSE_HAL_DRIVER -DSTM32F767xx -DSTM32F7XX -DSTM32F7_NUCLEO -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
+# MMDVM-Pi F722 board:
+DEFS_PI_F722=-DUSE_HAL_DRIVER -DSTM32F722xx -DSTM32F7XX -DSTM32F722_PI -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
+# MMDVM-F7M F0DEI board:
+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:
+DEFS_DVM=-DUSE_STDPERIPH_DRIVER -DSTM32F4XX -DSTM32F446xx -DSTM32F4_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
 
-CFLAGS=-c $(MCFLAGS) $(INCLUDES)
-CXXFLAGS=-c $(MCFLAGS) $(INCLUDES)
 
-# LINKER FLAGS
-LDSCRIPT=stm32f4xx_link.ld
-LDFLAGS =-T $(LDSCRIPT) $(MCFLAGS) --specs=nosys.specs $(INCLUDES_LIBS) $(LINK_LIBS)
+# Build compiler flags
+CFLAGS_F4=-c $(MCFLAGS_F4) $(INCLUDES_F4)
+CXXFLAGS_F4=-c $(MCFLAGS_F4) $(INCLUDES_F4)
+CFLAGS_F7=-c $(MCFLAGS_F7) $(INCLUDES_F7)
+CXXFLAGS_F7=-c $(MCFLAGS_F7) $(INCLUDES_F7)
+
+# Linker flags
+LDFLAGS_F4 =-T stm32f4xx_link.ld $(MCFLAGS_F4) --specs=nosys.specs $(INCLUDES_LIBS_F4)
+LDFLAGS_F767 =-T stm32f767_link.ld $(MCFLAGS_F7) --specs=nosys.specs $(INCLUDES_LIBS_F7)
+LDFLAGS_F722 =-T stm32f722_link.ld $(MCFLAGS_F7) --specs=nosys.specs $(INCLUDES_LIBS_F7)
+
+# 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
 
 # Build Rules
-.PHONY: all release dis pi nucleo debug clean
+.PHONY: all release dis pi pi-f722 f4m nucleo f767 dvm drcc_nqf clean
 
-# Default target: STM32F4 Discovery board
-all: dis
+# Default target: Nucleo-64 F446RE board
+all: nucleo
 
-pi: CFLAGS+=$(DEFS_PI) -Os -ffunction-sections -fdata-sections -fno-builtin -Wno-implicit -DCUSTOM_NEW -DNO_EXCEPTIONS
-pi: CXXFLAGS+=$(DEFS_PI) -Os -fno-exceptions -ffunction-sections -fdata-sections -fno-builtin -fno-rtti -DCUSTOM_NEW -DNO_EXCEPTIONS
-pi: LDFLAGS+=-Os --specs=nano.specs
-pi: release
+pi: GitVersion.h
+pi: CFLAGS+=$(CFLAGS_F4) $(DEFS_PI)
+pi: CXXFLAGS+=$(CXXFLAGS_F4) $(DEFS_PI)
+pi: LDFLAGS+=$(LDFLAGS_F4)
+pi: release_f4
 
-nucleo: CFLAGS+=$(DEFS_NUCLEO) -Os -ffunction-sections -fdata-sections -fno-builtin -Wno-implicit -DCUSTOM_NEW -DNO_EXCEPTIONS
-nucleo: CXXFLAGS+=$(DEFS_NUCLEO) -Os -fno-exceptions -ffunction-sections -fdata-sections -fno-builtin -fno-rtti -DCUSTOM_NEW -DNO_EXCEPTIONS
-nucleo: LDFLAGS+=-Os --specs=nano.specs
-nucleo: release
+pi-f722: GitVersion.h
+pi-f722: CFLAGS+=$(CFLAGS_F7) $(DEFS_PI_F722)
+pi-f722: CXXFLAGS+=$(CXXFLAGS_F7) $(DEFS_PI_F722)
+pi-f722: LDFLAGS+=$(LDFLAGS_F722)
+pi-f722: release_f7
 
-dis: CFLAGS+=$(DEFS_DIS) -Os -ffunction-sections -fdata-sections -fno-builtin -Wno-implicit -DCUSTOM_NEW -DNO_EXCEPTIONS
-dis: CXXFLAGS+=$(DEFS_DIS) -Os -fno-exceptions -ffunction-sections -fdata-sections -fno-builtin -fno-rtti -DCUSTOM_NEW -DNO_EXCEPTIONS
-dis: LDFLAGS+=-Os --specs=nano.specs
-dis: release
+f4m: GitVersion.h
+f4m: CFLAGS+=$(CFLAGS_F4) $(DEFS_F4M)
+f4m: CXXFLAGS+=$(CXXFLAGS_F4) $(DEFS_F4M)
+f4m: LDFLAGS+=$(LDFLAGS_F4)
+f4m: release_f4
 
-debug: CFLAGS+=-g
-debug: CXXFLAGS+=-g
-debug: LDFLAGS+=-g
-debug: release
+f7m: GitVersion.h
+f7m: CFLAGS+=$(CFLAGS_F7) $(DEFS_F7M)
+f7m: CXXFLAGS+=$(CXXFLAGS_F7) $(DEFS_F7M)
+f7m: LDFLAGS+=$(LDFLAGS_F722)
+f7m: release_f7
 
-release: $(BINDIR)
-release: $(BINDIR)/$(BINHEX)
-release: $(BINDIR)/$(BINBIN)
+rpt_hat: GitVersion.h
+rpt_hat: CFLAGS+=$(CFLAGS_F7) $(DEFS_RPT_HAT)
+rpt_hat: CXXFLAGS+=$(CXXFLAGS_F7) $(DEFS_RPT_HAT)
+rpt_hat: LDFLAGS+=$(LDFLAGS_F722)
+rpt_hat: release_f7
+
+rpt_hat_tgo: GitVersion.h
+rpt_hat_tgo: CFLAGS+=$(CFLAGS_F4) $(DEFS_RPT_HAT_TGO)
+rpt_hat_tgo: CXXFLAGS+=$(CXXFLAGS_F4) $(DEFS_RPT_HAT_TGO)
+rpt_hat_tgo: LDFLAGS+=$(LDFLAGS_F4)
+rpt_hat_tgo: release_f4
+
+nucleo: GitVersion.h
+nucleo: CFLAGS+=$(CFLAGS_F4) $(DEFS_NUCLEO)
+nucleo: CXXFLAGS+=$(CXXFLAGS_F4) $(DEFS_NUCLEO)
+nucleo: LDFLAGS+=$(LDFLAGS_F4)
+nucleo: release_f4
+
+dis: GitVersion.h
+dis: CFLAGS+=$(CFLAGS_F4) $(DEFS_DIS)
+dis: CXXFLAGS+=$(CXXFLAGS_F4) $(DEFS_DIS)
+dis: LDFLAGS+=$(LDFLAGS_F4)
+dis: release_f4
+
+f767: GitVersion.h
+f767: CFLAGS+=$(CFLAGS_F7) $(DEFS_NUCLEO_F767)
+f767: CXXFLAGS+=$(CXXFLAGS_F7) $(DEFS_NUCLEO_F767)
+f767: LDFLAGS+=$(LDFLAGS_F767)
+f767: release_f7
+
+dvm: GitVersion.h
+dvm: CFLAGS+=$(CFLAGS_F4) $(DEFS_DVM)
+dvm: CXXFLAGS+=$(CXXFLAGS_F4) $(DEFS_DVM)
+dvm: LDFLAGS+=$(LDFLAGS_F4)
+dvm: release_f4
+
+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
+
+release_f4: $(BINDIR)
+release_f4: $(OBJDIR_F4)
+release_f4: $(BINDIR)/$(BINHEX_F4)
+release_f4: $(BINDIR)/$(BINBIN_F4)
+
+release_f7: $(BINDIR)
+release_f7: $(OBJDIR_F7)
+release_f7: $(BINDIR)/$(BINHEX_F7)
+release_f7: $(BINDIR)/$(BINBIN_F7)
 
 $(BINDIR):
-	$(MDBIN)
+	$(MDDIRS)
 
-$(BINDIR)/$(BINHEX): $(BINDIR)/$(BINELF)
+$(OBJDIR_F4):
+	$(MDDIRS)
+
+$(OBJDIR_F7):
+	$(MDDIRS)
+
+$(BINDIR)/$(BINHEX_F4): $(BINDIR)/$(BINELF_F4)
 	$(CP) -O ihex $< $@
 	@echo "Objcopy from ELF to IHEX complete!\n"
-	
-$(BINDIR)/$(BINBIN): $(BINDIR)/$(BINELF)
+
+$(BINDIR)/$(BINBIN_F4): $(BINDIR)/$(BINELF_F4)
 	$(CP) -O binary $< $@
 	@echo "Objcopy from ELF to BINARY complete!\n"
 
-$(BINDIR)/$(BINELF): $(OBJECTS)
-	$(CXX) $(OBJECTS) $(LDFLAGS) -o $@
+$(BINDIR)/$(BINELF_F4): $(OBJ_F4)
+	$(CXX) $(OBJ_F4) $(LDFLAGS) -o $@
 	@echo "Linking complete!\n"
-	$(SIZE) $(BINDIR)/$(BINELF)
+	$(SIZE) $(BINDIR)/$(BINELF_F4)
 
-%.o: %.cpp
+$(BINDIR)/$(BINHEX_F7): $(BINDIR)/$(BINELF_F7)
+	$(CP) -O ihex $< $@
+	@echo "Objcopy from ELF to IHEX complete!\n"
+
+$(BINDIR)/$(BINBIN_F7): $(BINDIR)/$(BINELF_F7)
+	$(CP) -O binary $< $@
+	@echo "Objcopy from ELF to BINARY complete!\n"
+
+$(BINDIR)/$(BINELF_F7): $(OBJ_F7)
+	$(CXX) $(OBJ_F7) $(LDFLAGS) -o $@
+	@echo "Linking complete!\n"
+	$(SIZE) $(BINDIR)/$(BINELF_F7)
+
+$(OBJDIR_F4)/%.o: $(MMDVM_PATH)/%.cpp
 	$(CXX) $(CXXFLAGS) $< -o $@
 	@echo "Compiled "$<"!\n"
 
-%.o: %.c
+$(OBJDIR_F7)/%.o: $(MMDVM_PATH)/%.cpp
+	$(CXX) $(CXXFLAGS) $< -o $@
+	@echo "Compiled "$<"!\n"
+
+$(OBJDIR_F4)/%.o: $(STD_LIB_F4)/%.c
 	$(CC) $(CFLAGS) $< -o $@
 	@echo "Compiled "$<"!\n"
 
-%.o: %.s
+$(OBJDIR_F7)/%.o: $(STD_LIB_F7)/%.c
 	$(CC) $(CFLAGS) $< -o $@
-	@echo "Assambled "$<"!\n"
+	@echo "Compiled "$<"!\n"
+
+$(OBJDIR_F4)/%.o: $(SYS_DIR_F4)/%.c
+	$(CC) $(CFLAGS) $< -o $@
+	@echo "Compiled "$<"!\n"
+
+$(OBJDIR_F4)/%.o: $(STARTUP_DIR_F4)/%.c
+	$(CC) $(CFLAGS) $< -o $@
+	@echo "Compiled "$<"!\n"
+
+$(OBJDIR_F7)/%.o: $(SYS_DIR_F7)/%.c
+	$(CC) $(CFLAGS) $< -o $@
+	@echo "Compiled "$<"!\n"
+
+$(OBJDIR_F7)/%.o: $(STARTUP_DIR_F7)/%.c
+	$(CC) $(CFLAGS) $< -o $@
+	@echo "Compiled "$<"!\n"
 
 clean:
 	$(CLEANCMD)
-	
+
 deploy:
 ifneq ($(wildcard /usr/bin/openocd),)
-	/usr/bin/openocd -f /usr/share/openocd/scripts/board/stm32f4discovery.cfg -c "program bin/$(BINELF) verify reset exit"
+	/usr/bin/openocd -f /usr/share/openocd/scripts/interface/stlink-v2-1.cfg -f /usr/share/openocd/scripts/target/stm32f4x.cfg -c "program bin/$(BINELF_F4) verify reset exit"
 endif
 
 ifneq ($(wildcard /usr/local/bin/openocd),)
-	/usr/local/bin/openocd -f /usr/local/share/openocd/scripts/board/stm32f4discovery.cfg -c "program bin/$(BINELF) verify reset exit"
+	/usr/local/bin/openocd -f /usr/local/share/openocd/scripts/interface/stlink-v2-1.cfg -f /usr/local/share/openocd/scripts/target/stm32f4x.cfg -c "program bin/$(BINELF_F4) verify reset exit"
 endif
 
 ifneq ($(wildcard /opt/openocd/bin/openocd),)
-	/opt/openocd/bin/openocd -f /opt/openocd/share/openocd/scripts/board/stm32f4discovery.cfg -c "program bin/$(BINELF) verify reset exit"
+	/opt/openocd/bin/openocd -f /opt/openocd/share/openocd/scripts/interface/stlink-v2-1.cfg -f /opt/openocd/share/openocd/scripts/target/stm32f4x.cfg -c "program bin/$(BINELF_F4) verify reset exit"
 endif
+
+deploy-f7:
+ifneq ($(wildcard /usr/bin/openocd),)
+	/usr/bin/openocd -f /usr/share/openocd/scripts/interface/stlink-v2-1.cfg -f /usr/share/openocd/scripts/target/stm32f7x.cfg -c "program bin/$(BINELF_F7) verify reset exit"
+endif
+
+ifneq ($(wildcard /usr/local/bin/openocd),)
+	/usr/local/bin/openocd -f /usr/local/share/openocd/scripts/interface/stlink-v2-1.cfg -f /usr/local/share/openocd/scripts/target/stm32f7x.cfg -c "program bin/$(BINELF_F7) verify reset exit"
+endif
+
+ifneq ($(wildcard /opt/openocd/bin/openocd),)
+	/opt/openocd/bin/openocd -f /opt/openocd/share/openocd/scripts/interface/stlink-v2-1.cfg -f /opt/openocd/share/openocd/scripts/target/stm32f7x.cfg -c "program bin/$(BINELF_F7) verify reset exit"
+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
+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
+endif
+
+deploy-f4m: deploy-pi
+deploy-dvm: 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
+
+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
+endif
+
+deploy-f7m:   deploy-pi-f7
+deploy-rpt_hat: deploy-pi-f7
+
+# 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
+
+flash_f4:
+	@echo "flashing firmware..."
+	st-flash write bin/$(BINBIN_F4) 0x8000000

Makefile.Arduino

@@ -0,0 +1,189 @@
+#!/usr/bin/make
+# makefile for the arduino due (works with arduino IDE 1.6.12)
+#
+# The original file can be found at https://github.com/pauldreik/arduino-due-makefile
+#
+# USAGE: put this file in the same dir as your .ino file is.
+# configure the PORT variable and ADIR at the top of the file
+# to match your local configuration.
+# Type make upload to compile and upload.
+#
+
+#user specific settings:
+#where to find the IDE
+ADIR:=$(HOME)/.arduino15
+#which serial port to use (add a file with SUBSYSTEMS=="usb",
+#ATTRS{product}=="Arduino Due Prog. Port", ATTRS{idProduct}=="003d",
+#ATTRS{idVendor}=="2341", SYMLINK+="arduino_due" in /etc/udev/rules.d/
+#to get this working). Do not prefix the port with /dev/, just take
+#the basename.
+PORT:=ttyACM0
+#if you want to verify the bossac upload, define this to -v
+VERIFY:=-v
+
+
+#end of user configuration.
+
+
+#then some general settings. They should not be necessary to modify.
+#CXX:=$(ADIR)/tools/g++_arm_none_eabi/bin/arm-none-eabi-g++
+CXX:=$(ADIR)/packages/arduino/tools/arm-none-eabi-gcc/4.8.3-2014q1/bin/arm-none-eabi-g++
+#CC:=$(ADIR)/tools/g++_arm_none_eabi/bin/arm-none-eabi-gcc
+CC:=$(ADIR)/packages/arduino/tools/arm-none-eabi-gcc/4.8.3-2014q1/bin/arm-none-eabi-gcc
+OBJCOPY:=$(ADIR)/packages/arduino/tools/arm-none-eabi-gcc/4.8.3-2014q1/bin/arm-none-eabi-objcopy
+
+C:=$(CC)
+#SAM:=arduino/sam/
+SAM:=$(ADIR)/packages/arduino/hardware/sam/1.6.12
+#CMSIS:=arduino/sam/system/CMSIS/
+#LIBSAM:=arduino/sam/system/libsam
+TMPDIR:=$(PWD)/build
+AR:=$(ADIR)/tools/g++_arm_none_eabi/bin/arm-none-eabi-ar 
+AR:=$(ADIR)/packages/arduino/tools/arm-none-eabi-gcc/4.8.3-2014q1/bin/arm-none-eabi-ar
+
+
+#all these values are hard coded and should maybe be configured somehow else,
+#like olikraus does in his makefile.
+DEFINES:=-Dprintf=iprintf -DF_CPU=84000000  -DARDUINO=10611 -D__SAM3X8E__ -DUSB_PID=0x003e -DUSB_VID=0x2341 -DUSBCON \
+         -DARDUINO_SAM_DUE -DARDUINO_ARCH_SAM '-DUSB_MANUFACTURER="Arduino LLC"' '-DUSB_PRODUCT="Arduino Due"' \
+         -DMADEBYMAKEFILE
+
+INCLUDES:=-I$(SAM)/system/libsam -I$(SAM)/system/CMSIS/CMSIS/Include/ \
+          -I$(SAM)/system/CMSIS/Device/ATMEL/ -I$(SAM)/cores/arduino \
+          -I$(SAM)/variants/arduino_due_x
+
+#also include the current dir for convenience
+INCLUDES += -I.
+
+#compilation flags common to both c and c++ 
+COMMON_FLAGS:=-g -Os -w -ffunction-sections -fdata-sections -nostdlib \
+              --param max-inline-insns-single=500 -mcpu=cortex-m3 -mthumb \
+               -fno-threadsafe-statics
+#for compiling c (do not warn, this is not our code)
+CFLAGS:=$(COMMON_FLAGS) -std=gnu11
+#for compiling c++
+CXXFLAGS:=$(COMMON_FLAGS) -fno-rtti -fno-exceptions -std=gnu++11 -Wall -Wextra
+
+#let the results be named after the project
+PROJNAME:=$(shell basename *.ino .ino)
+
+#we will make a new mainfile from the ino file.
+NEWMAINFILE:=$(TMPDIR)/$(PROJNAME).ino.cpp
+
+#our own sourcefiles is the (converted) ino file and any local cpp files
+MYSRCFILES:=$(NEWMAINFILE) $(shell ls *.cpp 2>/dev/null)
+MYOBJFILES:=$(addsuffix .o,$(addprefix $(TMPDIR)/,$(notdir $(MYSRCFILES))))
+
+#These source files are the ones forming core.a
+CORESRCXX:=$(shell ls ${SAM}/cores/arduino/*.cpp ${SAM}/cores/arduino/USB/*.cpp  ${SAM}/variants/arduino_due_x/variant.cpp)
+CORESRC:=$(shell ls ${SAM}/cores/arduino/*.c)
+
+#hey this one is needed too: $(SAM)/cores/arduino/wiring_pulse_asm.S" add -x assembler-with-cpp
+#and this one: /1.6.11/cores/arduino/avr/dtostrf.c but it seems to work
+#anyway, probably because I do not use that functionality.
+
+#convert the core source files to object files. assume no clashes.
+COREOBJSXX:=$(addprefix $(TMPDIR)/core/,$(notdir $(CORESRCXX)) )
+COREOBJSXX:=$(addsuffix .o,$(COREOBJSXX))
+COREOBJS:=$(addprefix $(TMPDIR)/core/,$(notdir $(CORESRC)) )
+COREOBJS:=$(addsuffix .o,$(COREOBJS))
+
+default:
+	@echo default rule, does nothing. Try make compile or make upload.
+
+#This rule is good to just make sure stuff compiles, without having to wait
+#for bossac.
+compile: GitVersion.h $(TMPDIR)/$(PROJNAME).elf $(TMPDIR)/$(PROJNAME).bin
+
+#This is a make rule template to create object files from the source files.
+# arg 1=src file
+# arg 2=object file
+# arg 3= XX if c++, empty if c
+define OBJ_template
+$(2): $(1)
+	$(C$(3)) -MD -c $(C$(3)FLAGS) $(DEFINES) $(INCLUDES) $(1) -o $(2)
+endef
+#now invoke the template both for c++ sources
+$(foreach src,$(CORESRCXX), $(eval $(call OBJ_template,$(src),$(addsuffix .o,$(addprefix $(TMPDIR)/core/,$(notdir $(src)))),XX) ) )
+#...and for c sources:
+$(foreach src,$(CORESRC), $(eval $(call OBJ_template,$(src),$(addsuffix .o,$(addprefix $(TMPDIR)/core/,$(notdir $(src)))),) ) )
+
+#and our own c++ sources
+$(foreach src,$(MYSRCFILES), $(eval $(call OBJ_template,$(src),$(addsuffix .o,$(addprefix $(TMPDIR)/,$(notdir $(src)))),XX) ) )
+
+
+clean:
+	test ! -d $(TMPDIR) || rm -rf $(TMPDIR)
+	$(RM) GitVersion.h
+
+.PHONY: .FORCE upload default
+
+$(TMPDIR):
+	mkdir -p $(TMPDIR)
+
+$(TMPDIR)/core:
+	mkdir -p $(TMPDIR)/core
+
+#creates the cpp file from the .ino file
+$(NEWMAINFILE): $(PROJNAME).ino
+	cat $(SAM)/cores/arduino/main.cpp > $(NEWMAINFILE)
+	cat $(PROJNAME).ino >> $(NEWMAINFILE)
+	echo 'extern "C" void __cxa_pure_virtual() {while (true);}' >> $(NEWMAINFILE)
+
+#include the dependencies for our own files
+-include $(MYOBJFILES:.o=.d)
+
+#create the core library from the core objects. Do this EXACTLY as the
+#arduino IDE does it, seems *really* picky about this.
+#Sorry for the hard coding.
+$(TMPDIR)/core.a: $(TMPDIR)/core $(COREOBJS) $(COREOBJSXX)
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/wiring_shift.c.o 
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/wiring_analog.c.o 
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/itoa.c.o 
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/cortex_handlers.c.o 
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/hooks.c.o 
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/wiring.c.o 
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/WInterrupts.c.o 
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/syscalls_sam3.c.o 
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/iar_calls_sam3.c.o 
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/wiring_digital.c.o 
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/Print.cpp.o 
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/USARTClass.cpp.o 
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/WString.cpp.o
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/PluggableUSB.cpp.o 
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/USBCore.cpp.o 
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/CDC.cpp.o 
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/wiring_pulse.cpp.o 
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/UARTClass.cpp.o 
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/main.cpp.o
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/new.cpp.o
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/watchdog.cpp.o
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/Stream.cpp.o 
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/RingBuffer.cpp.o 
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/IPAddress.cpp.o 
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/Reset.cpp.o 
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/WMath.cpp.o 
+	$(AR) rcs $(TMPDIR)/core.a $(TMPDIR)/core/variant.cpp.o
+
+#link our own object files with core to form the elf file
+$(TMPDIR)/$(PROJNAME).elf: $(TMPDIR)/core.a $(TMPDIR)/core/syscalls_sam3.c.o $(MYOBJFILES) 
+	$(CC) -mcpu=cortex-m3 -mthumb -Os -Wl,--gc-sections -T$(SAM)/variants/arduino_due_x/linker_scripts/gcc/flash.ld -Wl,-Map,$(NEWMAINFILE).map -o $@ -L$(TMPDIR) -Wl,--cref -Wl,--check-sections -Wl,--gc-sections -Wl,--entry=Reset_Handler -Wl,--unresolved-symbols=report-all -Wl,--warn-common -Wl,--warn-section-align -Wl,--start-group -u _sbrk -u link -u _close -u _fstat -u _isatty -u _lseek -u _read -u _write -u _exit -u kill -u _getpid $(MYOBJFILES) $(TMPDIR)/core/variant.cpp.o $(SAM)/variants/arduino_due_x/libsam_sam3x8e_gcc_rel.a $(SAM)/system/CMSIS/CMSIS/Lib/GCC/libarm_cortexM3l_math.a $(TMPDIR)/core.a -Wl,--end-group -lm -gcc
+
+#copy from the hex to our bin file (why?)
+$(TMPDIR)/$(PROJNAME).bin: $(TMPDIR)/$(PROJNAME).elf 
+	$(OBJCOPY) -O binary $< $@
+
+#upload to the arduino by first resetting it (stty) and the running bossac
+upload: compile
+	stty -F /dev/$(PORT) cs8 1200 hupcl
+	$(ADIR)/packages/arduino/tools/bossac/1.6.1-arduino/bossac -i --port=$(PORT) -U false -e -w $(VERIFY) -b $(TMPDIR)/$(PROJNAME).bin -R
+
+# Export the current git version if the index file exists, else 000...
+GitVersion.h: .FORCE
+ifneq ("$(wildcard .git/index)","")
+	echo "#define GITVERSION \"$(shell git rev-parse --short HEAD)\"" > $@
+else
+	echo "#define GITVERSION \"0000000\"" > $@
+endif
+
+.FORCE:

Makefile.CMSIS

@@ -0,0 +1,165 @@
+# 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

NXDNDefines.h

@@ -0,0 +1,50 @@
+/*
+ *   Copyright (C) 2016,2017,2018 by Jonathan Naylor G4KLX
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#if !defined(NXDNDEFINES_H)
+#define  NXDNDEFINES_H
+
+const unsigned int NXDN_RADIO_SYMBOL_LENGTH = 10U;      // At 24 kHz sample rate
+
+const unsigned int NXDN_FRAME_LENGTH_BITS    = 384U;
+const unsigned int NXDN_FRAME_LENGTH_BYTES   = NXDN_FRAME_LENGTH_BITS / 8U;
+const unsigned int NXDN_FRAME_LENGTH_SYMBOLS = NXDN_FRAME_LENGTH_BITS / 2U;
+const unsigned int NXDN_FRAME_LENGTH_SAMPLES = NXDN_FRAME_LENGTH_SYMBOLS * NXDN_RADIO_SYMBOL_LENGTH;
+
+const unsigned int NXDN_FSW_LENGTH_BITS    = 20U;
+const unsigned int NXDN_FSW_LENGTH_SYMBOLS = NXDN_FSW_LENGTH_BITS / 2U;
+const unsigned int NXDN_FSW_LENGTH_SAMPLES = NXDN_FSW_LENGTH_SYMBOLS * NXDN_RADIO_SYMBOL_LENGTH;
+
+const uint8_t NXDN_FSW_BYTES[]      = {0xCDU, 0xF5U, 0x90U};
+const uint8_t NXDN_FSW_BYTES_MASK[] = {0xFFU, 0xFFU, 0xF0U};
+const uint8_t NXDN_FSW_BYTES_LENGTH = 3U;
+
+const uint32_t NXDN_FSW_BITS      = 0x000CDF59U;
+const uint32_t NXDN_FSW_BITS_MASK = 0x000FFFFFU;
+
+// C     D      F     5      9
+// 11 00 11 01  11 11 01 01  10 01
+// -3 +1 -3 +3  -3 -3 +3 +3  -1 +3
+
+const int8_t NXDN_FSW_SYMBOLS_VALUES[] = {-3, +1, -3, +3, -3, -3, +3, +3, -1, +3};
+
+const uint16_t NXDN_FSW_SYMBOLS      = 0x014DU;
+const uint16_t NXDN_FSW_SYMBOLS_MASK = 0x03FFU;
+
+#endif
+

NXDNRX.cpp

@@ -0,0 +1,405 @@
+/*
+ *   Copyright (C) 2009-2018 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"
+#include "Globals.h"
+#include "NXDNRX.h"
+#include "Utils.h"
+
+const q15_t SCALING_FACTOR = 18750;      // Q15(0.55)
+
+const uint8_t MAX_FSW_BIT_START_ERRS = 1U;
+const uint8_t MAX_FSW_BIT_RUN_ERRS   = 3U;
+
+const uint8_t MAX_FSW_SYMBOLS_ERRS = 2U;
+
+const uint8_t BIT_MASK_TABLE[] = {0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02U, 0x01U};
+
+#define WRITE_BIT1(p,i,b) p[(i)>>3] = (b) ? (p[(i)>>3] | BIT_MASK_TABLE[(i)&7]) : (p[(i)>>3] & ~BIT_MASK_TABLE[(i)&7])
+
+const uint8_t NOAVEPTR = 99U;
+
+const uint16_t NOENDPTR = 9999U;
+
+const unsigned int MAX_FSW_FRAMES = 5U + 1U;
+
+CNXDNRX::CNXDNRX() :
+m_state(NXDNRXS_NONE),
+m_bitBuffer(),
+m_buffer(),
+m_bitPtr(0U),
+m_dataPtr(0U),
+m_startPtr(NOENDPTR),
+m_endPtr(NOENDPTR),
+m_fswPtr(NOENDPTR),
+m_minFSWPtr(NOENDPTR),
+m_maxFSWPtr(NOENDPTR),
+m_maxCorr(0),
+m_lostCount(0U),
+m_countdown(0U),
+m_centre(),
+m_centreVal(0),
+m_threshold(),
+m_thresholdVal(0),
+m_averagePtr(NOAVEPTR),
+m_rssiAccum(0U),
+m_rssiCount(0U)
+{
+}
+
+void CNXDNRX::reset()
+{
+  m_state        = NXDNRXS_NONE;
+  m_dataPtr      = 0U;
+  m_bitPtr       = 0U;
+  m_maxCorr      = 0;
+  m_averagePtr   = NOAVEPTR;
+  m_startPtr     = NOENDPTR;
+  m_endPtr       = NOENDPTR;
+  m_fswPtr       = NOENDPTR;
+  m_minFSWPtr    = NOENDPTR;
+  m_maxFSWPtr    = NOENDPTR;
+  m_centreVal    = 0;
+  m_thresholdVal = 0;
+  m_lostCount    = 0U;
+  m_countdown    = 0U;
+  m_rssiAccum    = 0U;
+  m_rssiCount    = 0U;
+}
+
+void CNXDNRX::samples(const q15_t* samples, uint16_t* rssi, uint8_t length)
+{
+  for (uint8_t i = 0U; i < length; i++) {
+    q15_t sample = samples[i];
+
+    m_rssiAccum += rssi[i];
+    m_rssiCount++;
+
+    m_bitBuffer[m_bitPtr] <<= 1;
+    if (sample < 0)
+      m_bitBuffer[m_bitPtr] |= 0x01U;
+
+    m_buffer[m_dataPtr] = sample;
+
+    switch (m_state) {
+    case NXDNRXS_DATA:
+      processData(sample);
+      break;
+    default:
+      processNone(sample);
+      break;
+    }
+
+    m_dataPtr++;
+    if (m_dataPtr >= NXDN_FRAME_LENGTH_SAMPLES)
+      m_dataPtr = 0U;
+
+    m_bitPtr++;
+    if (m_bitPtr >= NXDN_RADIO_SYMBOL_LENGTH)
+      m_bitPtr = 0U;
+  }
+}
+
+void CNXDNRX::processNone(q15_t sample)
+{
+  bool ret = correlateFSW();
+  if (ret) {
+    // On the first sync, start the countdown to the state change
+    if (m_countdown == 0U) {
+      m_rssiAccum = 0U;
+      m_rssiCount = 0U;
+
+      io.setDecode(true);
+      io.setADCDetection(true);
+
+      m_averagePtr = NOAVEPTR;
+
+      m_countdown = 5U;
+    }
+  }
+
+  if (m_countdown > 0U)
+    m_countdown--;
+
+  if (m_countdown == 1U) {
+    m_minFSWPtr = m_fswPtr + NXDN_FRAME_LENGTH_SAMPLES - 1U;
+    if (m_minFSWPtr >= NXDN_FRAME_LENGTH_SAMPLES)
+      m_minFSWPtr -= NXDN_FRAME_LENGTH_SAMPLES;
+
+    m_maxFSWPtr = m_fswPtr + 1U;
+    if (m_maxFSWPtr >= NXDN_FRAME_LENGTH_SAMPLES)
+      m_maxFSWPtr -= NXDN_FRAME_LENGTH_SAMPLES;
+
+    m_state      = NXDNRXS_DATA;
+    m_countdown  = 0U;
+  }
+}
+
+void CNXDNRX::processData(q15_t sample)
+{
+  if (m_minFSWPtr < m_maxFSWPtr) {
+    if (m_dataPtr >= m_minFSWPtr && m_dataPtr <= m_maxFSWPtr)
+      correlateFSW();
+  } else {
+    if (m_dataPtr >= m_minFSWPtr || m_dataPtr <= m_maxFSWPtr)
+      correlateFSW();
+  }
+
+  if (m_dataPtr == m_endPtr) {
+    // Only update the centre and threshold if they are from a good sync
+    if (m_lostCount == MAX_FSW_FRAMES) {
+      m_minFSWPtr = m_fswPtr + NXDN_FRAME_LENGTH_SAMPLES - 1U;
+      if (m_minFSWPtr >= NXDN_FRAME_LENGTH_SAMPLES)
+        m_minFSWPtr -= NXDN_FRAME_LENGTH_SAMPLES;
+
+      m_maxFSWPtr = m_fswPtr + 1U;
+      if (m_maxFSWPtr >= NXDN_FRAME_LENGTH_SAMPLES)
+        m_maxFSWPtr -= NXDN_FRAME_LENGTH_SAMPLES;
+    }
+
+    calculateLevels(m_startPtr, NXDN_FRAME_LENGTH_SYMBOLS);
+
+    DEBUG4("NXDNRX: sync found pos/centre/threshold", m_fswPtr, m_centreVal, m_thresholdVal);
+
+    uint8_t frame[NXDN_FRAME_LENGTH_BYTES + 3U];
+    samplesToBits(m_startPtr, NXDN_FRAME_LENGTH_SYMBOLS, frame, 8U, m_centreVal, m_thresholdVal);
+
+    // We've not seen a data sync for too long, signal RXLOST and change to RX_NONE
+    m_lostCount--;
+    if (m_lostCount == 0U) {
+      DEBUG1("NXDNRX: sync timed out, lost lock");
+
+      io.setDecode(false);
+      io.setADCDetection(false);
+
+      serial.writeNXDNLost();
+
+      m_state      = NXDNRXS_NONE;
+      m_endPtr     = NOENDPTR;
+      m_averagePtr = NOAVEPTR;
+      m_countdown  = 0U;
+      m_maxCorr    = 0;
+    } else {
+      frame[0U] = m_lostCount == (MAX_FSW_FRAMES - 1U) ? 0x01U : 0x00U;
+      writeRSSIData(frame);
+      m_maxCorr = 0;
+    }
+  }
+}
+
+bool CNXDNRX::correlateFSW()
+{
+  if (countBits32((m_bitBuffer[m_bitPtr] & NXDN_FSW_SYMBOLS_MASK) ^ NXDN_FSW_SYMBOLS) <= MAX_FSW_SYMBOLS_ERRS) {
+    uint16_t ptr = m_dataPtr + NXDN_FRAME_LENGTH_SAMPLES - NXDN_FSW_LENGTH_SAMPLES + NXDN_RADIO_SYMBOL_LENGTH;
+    if (ptr >= NXDN_FRAME_LENGTH_SAMPLES)
+      ptr -= NXDN_FRAME_LENGTH_SAMPLES;
+
+    q31_t corr = 0;
+    q15_t min =  16000;
+    q15_t max = -16000;
+
+    for (uint8_t i = 0U; i < NXDN_FSW_LENGTH_SYMBOLS; i++) {
+      q15_t val = m_buffer[ptr];
+
+      if (val > max)
+        max = val;
+      if (val < min)
+        min = val;
+
+      switch (NXDN_FSW_SYMBOLS_VALUES[i]) {
+      case +3:
+        corr -= (val + val + val);
+        break;
+      case +1:
+        corr -= val;
+        break;
+      case -1:
+        corr += val;
+        break;
+      default:  // -3
+        corr += (val + val + val);
+        break;
+      }
+
+      ptr += NXDN_RADIO_SYMBOL_LENGTH;
+      if (ptr >= NXDN_FRAME_LENGTH_SAMPLES)
+        ptr -= NXDN_FRAME_LENGTH_SAMPLES;
+    }
+
+    if (corr > m_maxCorr) {
+      if (m_averagePtr == NOAVEPTR) {
+        m_centreVal = (max + min) >> 1;
+
+        q31_t v1 = (max - m_centreVal) * SCALING_FACTOR;
+        m_thresholdVal = q15_t(v1 >> 15);
+      }
+
+      uint16_t startPtr = m_dataPtr + NXDN_FRAME_LENGTH_SAMPLES - NXDN_FSW_LENGTH_SAMPLES + NXDN_RADIO_SYMBOL_LENGTH;
+      if (startPtr >= NXDN_FRAME_LENGTH_SAMPLES)
+        startPtr -= NXDN_FRAME_LENGTH_SAMPLES;
+
+      uint8_t sync[NXDN_FSW_BYTES_LENGTH];
+      samplesToBits(startPtr, NXDN_FSW_LENGTH_SYMBOLS, sync, 0U, m_centreVal, m_thresholdVal);
+
+      uint8_t maxErrs;
+      if (m_state == NXDNRXS_NONE)
+        maxErrs = MAX_FSW_BIT_START_ERRS;
+      else
+        maxErrs = MAX_FSW_BIT_RUN_ERRS;
+
+     uint8_t errs = 0U;
+      for (uint8_t i = 0U; i < NXDN_FSW_BYTES_LENGTH; i++)
+        errs += countBits8((sync[i] & NXDN_FSW_BYTES_MASK[i]) ^ NXDN_FSW_BYTES[i]);
+
+      if (errs <= maxErrs) {
+        m_maxCorr   = corr;
+        m_lostCount = MAX_FSW_FRAMES;
+        m_fswPtr    = m_dataPtr;
+
+        m_startPtr = startPtr;
+
+        m_endPtr = m_dataPtr + NXDN_FRAME_LENGTH_SAMPLES - NXDN_FSW_LENGTH_SAMPLES - 1U;
+        if (m_endPtr >= NXDN_FRAME_LENGTH_SAMPLES)
+          m_endPtr -= NXDN_FRAME_LENGTH_SAMPLES;
+
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+void CNXDNRX::calculateLevels(uint16_t start, uint16_t count)
+{
+  q15_t maxPos = -16000;
+  q15_t minPos =  16000;
+  q15_t maxNeg =  16000;
+  q15_t minNeg = -16000;
+
+  for (uint16_t i = 0U; i < count; i++) {
+    q15_t sample = m_buffer[start];
+
+    if (sample > 0) {
+      if (sample > maxPos)
+        maxPos = sample;
+      if (sample < minPos)
+        minPos = sample;
+    } else {
+      if (sample < maxNeg)
+        maxNeg = sample;
+      if (sample > minNeg)
+        minNeg = sample;
+    }
+
+    start += NXDN_RADIO_SYMBOL_LENGTH;
+    if (start >= NXDN_FRAME_LENGTH_SAMPLES)
+      start -= NXDN_FRAME_LENGTH_SAMPLES;
+  }
+
+  q15_t posThresh = (maxPos + minPos) >> 1;
+  q15_t negThresh = (maxNeg + minNeg) >> 1;
+
+  q15_t centre = (posThresh + negThresh) >> 1;
+
+  q15_t threshold = posThresh - centre;
+
+  DEBUG5("NXDNRX: pos/neg/centre/threshold", posThresh, negThresh, centre, threshold);
+
+  if (m_averagePtr == NOAVEPTR) {
+    for (uint8_t i = 0U; i < 16U; i++) {
+      m_centre[i] = centre;
+      m_threshold[i] = threshold;
+    }
+
+    m_averagePtr = 0U;
+  } else {
+    m_centre[m_averagePtr] = centre;
+    m_threshold[m_averagePtr] = threshold;
+
+    m_averagePtr++;
+    if (m_averagePtr >= 16U)
+      m_averagePtr = 0U;
+  }
+
+  m_centreVal = 0;
+  m_thresholdVal = 0;
+
+  for (uint8_t i = 0U; i < 16U; i++) {
+    m_centreVal += m_centre[i];
+    m_thresholdVal += m_threshold[i];
+  }
+
+  m_centreVal >>= 4;
+  m_thresholdVal >>= 4;
+}
+
+void CNXDNRX::samplesToBits(uint16_t start, uint16_t count, uint8_t* buffer, uint16_t offset, q15_t centre, q15_t threshold)
+{
+  for (uint16_t i = 0U; i < count; i++) {
+    q15_t sample = m_buffer[start] - centre;
+
+    if (sample < -threshold) {
+      WRITE_BIT1(buffer, offset, false);
+      offset++;
+      WRITE_BIT1(buffer, offset, true);
+      offset++;
+    } else if (sample < 0) {
+      WRITE_BIT1(buffer, offset, false);
+      offset++;
+      WRITE_BIT1(buffer, offset, false);
+      offset++;
+    } else if (sample < threshold) {
+      WRITE_BIT1(buffer, offset, true);
+      offset++;
+      WRITE_BIT1(buffer, offset, false);
+      offset++;
+    } else {
+      WRITE_BIT1(buffer, offset, true);
+      offset++;
+      WRITE_BIT1(buffer, offset, true);
+      offset++;
+    }
+
+    start += NXDN_RADIO_SYMBOL_LENGTH;
+    if (start >= NXDN_FRAME_LENGTH_SAMPLES)
+      start -= NXDN_FRAME_LENGTH_SAMPLES;
+  }
+}
+
+void CNXDNRX::writeRSSIData(uint8_t* data)
+{
+#if defined(SEND_RSSI_DATA)
+  if (m_rssiCount > 0U) {
+    uint16_t rssi = m_rssiAccum / m_rssiCount;
+
+    data[49U] = (rssi >> 8) & 0xFFU;
+    data[50U] = (rssi >> 0) & 0xFFU;
+
+    serial.writeNXDNData(data, NXDN_FRAME_LENGTH_BYTES + 3U);
+  } else {
+    serial.writeNXDNData(data, NXDN_FRAME_LENGTH_BYTES + 1U);
+  }
+#else
+  serial.writeNXDNData(data, NXDN_FRAME_LENGTH_BYTES + 1U);
+#endif
+
+  m_rssiAccum = 0U;
+  m_rssiCount = 0U;
+}
+

NXDNRX.h

@@ -0,0 +1,69 @@
+/*
+ *   Copyright (C) 2015,2016,2017,2018 by Jonathan Naylor G4KLX
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#if !defined(NXDNRX_H)
+#define  NXDNRX_H
+
+#include "Config.h"
+#include "NXDNDefines.h"
+
+enum NXDNRX_STATE {
+  NXDNRXS_NONE,
+  NXDNRXS_DATA
+};
+
+class CNXDNRX {
+public:
+  CNXDNRX();
+
+  void samples(const q15_t* samples, uint16_t* rssi, uint8_t length);
+
+  void reset();
+
+private:
+  NXDNRX_STATE m_state;
+  uint16_t     m_bitBuffer[NXDN_RADIO_SYMBOL_LENGTH];
+  q15_t        m_buffer[NXDN_FRAME_LENGTH_SAMPLES];
+  uint16_t     m_bitPtr;
+  uint16_t     m_dataPtr;
+  uint16_t     m_startPtr;
+  uint16_t     m_endPtr;
+  uint16_t     m_fswPtr;
+  uint16_t     m_minFSWPtr;
+  uint16_t     m_maxFSWPtr;
+  q31_t        m_maxCorr;
+  uint16_t     m_lostCount;
+  uint8_t      m_countdown;
+  q15_t        m_centre[16U];
+  q15_t        m_centreVal;
+  q15_t        m_threshold[16U];
+  q15_t        m_thresholdVal;
+  uint8_t      m_averagePtr;
+  uint32_t     m_rssiAccum;
+  uint16_t     m_rssiCount;
+
+  void processNone(q15_t sample);
+  void processData(q15_t sample);
+  bool correlateFSW();
+  void calculateLevels(uint16_t start, uint16_t count);
+  void samplesToBits(uint16_t start, uint16_t count, uint8_t* buffer, uint16_t offset, q15_t centre, q15_t threshold);
+  void writeRSSIData(uint8_t* data);
+};
+
+#endif
+

NXDNTX.cpp

@@ -0,0 +1,202 @@
+/*
+ *   Copyright (C) 2009-2018,2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2017 by Andy Uribe CA6JAU
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "Config.h"
+#include "Globals.h"
+#include "NXDNTX.h"
+
+#include "NXDNDefines.h"
+
+// Generated using rcosdesign(0.2, 8, 10, 'sqrt') in MATLAB
+static q15_t RRC_0_2_FILTER[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 850, 592, 219, -234, -720, -1179, -1548, -1769, -1795, -1597, -1172,
+                                 -544, 237, 1092, 1927, 2637, 3120, 3286, 3073, 2454, 1447, 116, -1431, -3043, -4544, -5739, -6442,
+                                 -6483, -5735, -4121, -1633, 1669, 5651, 10118, 14822, 19484, 23810, 27520, 30367, 32156, 32767,
+                                 32156, 30367, 27520, 23810, 19484, 14822, 10118, 5651, 1669, -1633, -4121, -5735, -6483, -6442,
+                                 -5739, -4544, -3043, -1431, 116, 1447, 2454, 3073, 3286, 3120, 2637, 1927, 1092, 237, -544, -1172,
+                                 -1597, -1795, -1769, -1548, -1179, -720, -234, 219, 592, 850}; // numTaps = 90, L = 10
+const uint16_t RRC_0_2_FILTER_PHASE_LEN = 9U; // phaseLength = numTaps/L
+
+static q15_t NXDN_SINC_FILTER[] = {572, -1003, -253, 254, 740, 1290, 1902, 2527, 3090, 3517, 3747, 3747, 3517, 3090, 2527, 1902,
+                                   1290, 740, 254, -253, -1003, 572};
+const uint16_t NXDN_SINC_FILTER_LEN = 22U;
+
+const q15_t NXDN_LEVELA =  735;
+const q15_t NXDN_LEVELB =  245;
+const q15_t NXDN_LEVELC = -245;
+const q15_t NXDN_LEVELD = -735;
+
+const uint8_t NXDN_PREAMBLE[] = {0x57U, 0x75U, 0xFDU};
+const uint8_t NXDN_SYNC = 0x5FU;
+
+CNXDNTX::CNXDNTX() :
+m_buffer(TX_BUFFER_LEN),
+m_modFilter(),
+m_sincFilter(),
+m_modState(),
+m_sincState(),
+m_poBuffer(),
+m_poLen(0U),
+m_poPtr(0U),
+m_txDelay(240U),     // 200ms
+m_txHang(3000U),     // 5s
+m_txCount(0U)
+{
+  ::memset(m_modState, 0x00U, 16U * sizeof(q15_t));
+  ::memset(m_sincState,  0x00U, 70U * sizeof(q15_t));
+
+  m_modFilter.L           = NXDN_RADIO_SYMBOL_LENGTH;
+  m_modFilter.phaseLength = RRC_0_2_FILTER_PHASE_LEN;
+  m_modFilter.pCoeffs     = RRC_0_2_FILTER;
+  m_modFilter.pState      = m_modState;
+
+  m_sincFilter.numTaps = NXDN_SINC_FILTER_LEN;
+  m_sincFilter.pState  = m_sincState;
+  m_sincFilter.pCoeffs = NXDN_SINC_FILTER;
+}
+
+void CNXDNTX::process()
+{
+  if (m_poLen == 0U && m_buffer.getData() > 0U) {
+    if (!m_tx) {
+      for (uint16_t i = 0U; i < m_txDelay; i++)
+        m_poBuffer[m_poLen++] = NXDN_SYNC;
+      m_poBuffer[m_poLen++] = NXDN_PREAMBLE[0U];
+      m_poBuffer[m_poLen++] = NXDN_PREAMBLE[1U];
+      m_poBuffer[m_poLen++] = NXDN_PREAMBLE[2U];
+    } else {
+      for (uint8_t i = 0U; i < NXDN_FRAME_LENGTH_BYTES; i++) {
+        uint8_t c = 0U;
+        m_buffer.get(c);
+        m_poBuffer[m_poLen++] = c;
+      }
+    }
+
+    m_poPtr = 0U;
+  }
+
+  if (m_poLen > 0U) {
+    uint16_t space = io.getSpace();
+    
+    while (space > (4U * NXDN_RADIO_SYMBOL_LENGTH)) {
+      uint8_t c = m_poBuffer[m_poPtr++];
+      writeByte(c);
+
+      space -= 4U * NXDN_RADIO_SYMBOL_LENGTH;
+      if (m_duplex)
+        m_txCount = m_txHang;
+      
+      if (m_poPtr >= m_poLen) {
+        m_poPtr = 0U;
+        m_poLen = 0U;
+        return;
+      }
+    }
+  } else if (m_txCount > 0U) {
+    // Transmit silence until the hang timer has expired.
+    uint16_t space = io.getSpace();
+
+    while (space > (4U * NXDN_RADIO_SYMBOL_LENGTH)) {
+      writeSilence();
+
+      space -= 4U * NXDN_RADIO_SYMBOL_LENGTH;
+      m_txCount--;
+
+      if (m_txCount == 0U)
+        return;
+    }
+  }
+}
+
+uint8_t CNXDNTX::writeData(const uint8_t* data, uint8_t length)
+{
+  if (length != (NXDN_FRAME_LENGTH_BYTES + 1U))
+    return 4U;
+
+  uint16_t space = m_buffer.getSpace();
+  if (space < NXDN_FRAME_LENGTH_BYTES)
+    return 5U;
+
+  for (uint8_t i = 0U; i < NXDN_FRAME_LENGTH_BYTES; i++)
+    m_buffer.put(data[i + 1U]);
+
+  return 0U;
+}
+
+void CNXDNTX::writeByte(uint8_t c)
+{
+  q15_t inBuffer[4U];
+  q15_t intBuffer[NXDN_RADIO_SYMBOL_LENGTH * 4U];
+  q15_t outBuffer[NXDN_RADIO_SYMBOL_LENGTH * 4U];
+
+  const uint8_t MASK = 0xC0U;
+
+  for (uint8_t i = 0U; i < 4U; i++, c <<= 2) {
+    switch (c & MASK) {
+      case 0xC0U:
+        inBuffer[i] = NXDN_LEVELA;
+        break;
+      case 0x80U:
+        inBuffer[i] = NXDN_LEVELB;
+        break;
+      case 0x00U:
+        inBuffer[i] = NXDN_LEVELC;
+        break;
+      default:
+        inBuffer[i] = NXDN_LEVELD;
+        break;
+    }
+  }
+
+  ::arm_fir_interpolate_q15(&m_modFilter, inBuffer, intBuffer, 4U);
+
+  ::arm_fir_fast_q15(&m_sincFilter, intBuffer, outBuffer, NXDN_RADIO_SYMBOL_LENGTH * 4U);
+
+  io.write(STATE_NXDN, outBuffer, NXDN_RADIO_SYMBOL_LENGTH * 4U);
+}
+
+void CNXDNTX::writeSilence()
+{
+  q15_t inBuffer[4U] = {0x00U, 0x00U, 0x00U, 0x00U};
+  q15_t intBuffer[NXDN_RADIO_SYMBOL_LENGTH * 4U];
+  q15_t outBuffer[NXDN_RADIO_SYMBOL_LENGTH * 4U];
+
+  ::arm_fir_interpolate_q15(&m_modFilter, inBuffer, intBuffer, 4U);
+
+  ::arm_fir_fast_q15(&m_sincFilter, intBuffer, outBuffer, NXDN_RADIO_SYMBOL_LENGTH * 4U);
+
+  io.write(STATE_NXDN, outBuffer, NXDN_RADIO_SYMBOL_LENGTH * 4U);
+}
+
+void CNXDNTX::setTXDelay(uint8_t delay)
+{
+  m_txDelay = 300U + uint16_t(delay) * 6U;        // 500ms + tx delay
+
+  if (m_txDelay > 1200U)
+    m_txDelay = 1200U;
+}
+
+uint8_t CNXDNTX::getSpace() const
+{
+  return m_buffer.getSpace() / NXDN_FRAME_LENGTH_BYTES;
+}
+
+void CNXDNTX::setParams(uint8_t txHang)
+{
+  m_txHang = txHang * 600U;
+}

NXDNTX.h

@@ -0,0 +1,57 @@
+/*
+ *   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
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#if !defined(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);
+
+  void process();
+
+  void setTXDelay(uint8_t delay);
+
+  uint8_t getSpace() const;
+
+  void setParams(uint8_t txHang);
+
+private:
+  CRingBuffer<uint8_t>                        m_buffer;
+  arm_fir_interpolate_instance_q15 m_modFilter;
+  arm_fir_instance_q15             m_sincFilter;
+  q15_t                            m_modState[16U];    // blockSize + phaseLength - 1, 4 + 9 - 1 plus some spare
+  q15_t                            m_sincState[70U];   // NoTaps + BlockSize - 1, 22 + 40 - 1 plus some spare
+  uint8_t                          m_poBuffer[1200U];
+  uint16_t                         m_poLen;
+  uint16_t                         m_poPtr;
+  uint16_t                         m_txDelay;
+  uint32_t                         m_txHang;
+  uint32_t                         m_txCount;
+
+  void writeByte(uint8_t c);
+  void writeSilence();
+};
+
+#endif

P25Defines.h

@@ -1,5 +1,6 @@
 /*
- *   Copyright (C) 2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2016,2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2018 by Bryan Biedenkapp <[email protected]>
  *
  *   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
@@ -24,25 +25,42 @@ const unsigned int P25_RADIO_SYMBOL_LENGTH = 5U;      // At 24 kHz sample rate
 const unsigned int P25_HDR_FRAME_LENGTH_BYTES      = 99U;
 const unsigned int P25_HDR_FRAME_LENGTH_BITS       = P25_HDR_FRAME_LENGTH_BYTES * 8U;
 const unsigned int P25_HDR_FRAME_LENGTH_SYMBOLS    = P25_HDR_FRAME_LENGTH_BYTES * 4U;
+const unsigned int P25_HDR_FRAME_LENGTH_SAMPLES    = P25_HDR_FRAME_LENGTH_SYMBOLS * P25_RADIO_SYMBOL_LENGTH;
 
 const unsigned int P25_LDU_FRAME_LENGTH_BYTES      = 216U;
 const unsigned int P25_LDU_FRAME_LENGTH_BITS       = P25_LDU_FRAME_LENGTH_BYTES * 8U;
 const unsigned int P25_LDU_FRAME_LENGTH_SYMBOLS    = P25_LDU_FRAME_LENGTH_BYTES * 4U;
+const unsigned int P25_LDU_FRAME_LENGTH_SAMPLES    = P25_LDU_FRAME_LENGTH_SYMBOLS * P25_RADIO_SYMBOL_LENGTH;
 
 const unsigned int P25_TERMLC_FRAME_LENGTH_BYTES   = 54U;
 const unsigned int P25_TERMLC_FRAME_LENGTH_BITS    = P25_TERMLC_FRAME_LENGTH_BYTES * 8U;
 const unsigned int P25_TERMLC_FRAME_LENGTH_SYMBOLS = P25_TERMLC_FRAME_LENGTH_BYTES * 4U;
+const unsigned int P25_TERMLC_FRAME_LENGTH_SAMPLES = P25_TERMLC_FRAME_LENGTH_SYMBOLS * P25_RADIO_SYMBOL_LENGTH;
 
 const unsigned int P25_TERM_FRAME_LENGTH_BYTES     = 18U;
 const unsigned int P25_TERM_FRAME_LENGTH_BITS      = P25_TERM_FRAME_LENGTH_BYTES * 8U;
 const unsigned int P25_TERM_FRAME_LENGTH_SYMBOLS   = P25_TERM_FRAME_LENGTH_BYTES * 4U;
+const unsigned int P25_TERM_FRAME_LENGTH_SAMPLES   = P25_TERM_FRAME_LENGTH_SYMBOLS * P25_RADIO_SYMBOL_LENGTH;
+
+const unsigned int P25_TSDU_FRAME_LENGTH_BYTES     = 45U;
+const unsigned int P25_TSDU_FRAME_LENGTH_BITS      = P25_TSDU_FRAME_LENGTH_BYTES * 8U; 
+const unsigned int P25_TSDU_FRAME_LENGTH_SYMBOLS   = P25_TSDU_FRAME_LENGTH_BYTES * 4U; 
+const unsigned int P25_TSDU_FRAME_LENGTH_SAMPLES   = P25_TSDU_FRAME_LENGTH_SYMBOLS * P25_RADIO_SYMBOL_LENGTH;
+
+const unsigned int P25_PDU_HDR_FRAME_LENGTH_BYTES = 45U;
+const unsigned int P25_PDU_HDR_FRAME_LENGTH_BITS = P25_PDU_HDR_FRAME_LENGTH_BYTES * 8U;
+const unsigned int P25_PDU_HDR_FRAME_LENGTH_SYMBOLS = P25_PDU_HDR_FRAME_LENGTH_BYTES * 4U;
+const unsigned int P25_PDU_HDR_FRAME_LENGTH_SAMPLES = P25_PDU_HDR_FRAME_LENGTH_SYMBOLS * P25_RADIO_SYMBOL_LENGTH;
 
 const unsigned int P25_SYNC_LENGTH_BYTES   = 6U;
 const unsigned int P25_SYNC_LENGTH_BITS    = P25_SYNC_LENGTH_BYTES * 8U;
 const unsigned int P25_SYNC_LENGTH_SYMBOLS = P25_SYNC_LENGTH_BYTES * 4U;
+const unsigned int P25_SYNC_LENGTH_SAMPLES = P25_SYNC_LENGTH_SYMBOLS * P25_RADIO_SYMBOL_LENGTH;
 
-const unsigned int P25_NID_LENGTH_BITS    = 64U;
-const unsigned int P25_NID_LENGTH_SYMBOLS = 32U;
+const unsigned int P25_NID_LENGTH_BYTES    = 8U;
+const unsigned int P25_NID_LENGTH_BITS     = P25_NID_LENGTH_BYTES * 8U;
+const unsigned int P25_NID_LENGTH_SYMBOLS  = P25_NID_LENGTH_BYTES * 4U; 
+const unsigned int P25_NID_LENGTH_SAMPLES  = P25_NID_LENGTH_SYMBOLS * P25_RADIO_SYMBOL_LENGTH;
 
 const uint8_t P25_SYNC_BYTES[] = {0x55U, 0x75U, 0xF5U, 0xFFU, 0x77U, 0xFFU};
 const uint8_t P25_SYNC_BYTES_LENGTH  = 6U;
@@ -54,8 +72,18 @@ const uint64_t P25_SYNC_BITS_MASK = 0x0000FFFFFFFFFFFFU;
 // 01 01 01 01  01 11 01 01  11 11 01 01  11 11 11 11  01 11 01 11  11 11 11 11
 // +3 +3 +3 +3  +3 -3 +3 +3  -3 -3 +3 +3  -3 -3 -3 -3  +3 -3 +3 -3  -3 -3 -3 -3
 
+const int8_t P25_SYNC_SYMBOLS_VALUES[] = {+3, +3, +3, +3, +3, -3, +3, +3, -3, -3, +3, +3, -3, -3, -3, -3, +3, -3, +3, -3, -3, -3, -3, -3};
+
 const uint32_t P25_SYNC_SYMBOLS      = 0x00FB30A0U;
 const uint32_t P25_SYNC_SYMBOLS_MASK = 0x00FFFFFFU;
 
+const uint8_t P25_DUID_HDU = 0x00U;             // Header Data Unit
+const uint8_t P25_DUID_TDU = 0x03U;             // Simple Terminator Data Unit
+const uint8_t P25_DUID_LDU1 = 0x05U;            // Logical Link Data Unit 1
+const uint8_t P25_DUID_TSDU = 0x07U;            // Trunking System Data Unit
+const uint8_t P25_DUID_LDU2 = 0x0AU;            // Logical Link Data Unit 2
+const uint8_t P25_DUID_PDU = 0x0CU;             // Packet Data Unit 
+const uint8_t P25_DUID_TDULC = 0x0FU;           // Terminator Data Unit with Link Control
+
 #endif
 

P25RX.cpp

@@ -1,5 +1,6 @@
 /*
- *   Copyright (C) 2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2018 by Bryan Biedenkapp <[email protected]>
  *
  *   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,227 +17,282 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-// #define  WANT_DEBUG
-
 #include "Config.h"
 #include "Globals.h"
 #include "P25RX.h"
 #include "Utils.h"
 
-const unsigned int BUFFER_LENGTH = 200U;
+const q15_t SCALING_FACTOR = 18750;      // Q15(0.57)
 
-const q15_t SCALING_FACTOR = 18750;      // Q15(0.55)
+const uint8_t CORRELATION_COUNTDOWN = 10U;//5U;
 
-const uint32_t PLLMAX = 0x10000U;
-const uint32_t PLLINC = PLLMAX / P25_RADIO_SYMBOL_LENGTH;
-const uint32_t INC    = PLLINC / 32U;
+const uint8_t MAX_SYNC_BIT_START_ERRS = 2U;
+const uint8_t MAX_SYNC_BIT_RUN_ERRS   = 4U;
 
-const uint8_t SYNC_SYMBOL_ERRS = 0U;
+const uint8_t MAX_SYNC_SYMBOLS_ERRS = 2U;
 
-const uint8_t SYNC_BIT_START_ERRS = 2U;
-const uint8_t SYNC_BIT_RUN_ERRS   = 4U;
-
-const unsigned int MAX_SYNC_FRAMES = 3U + 1U;
-
-const uint8_t BIT_MASK_TABLE[] = {0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02U, 0x01U};
+const uint8_t BIT_MASK_TABLE[] = { 0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02U, 0x01U };
 
 #define WRITE_BIT1(p,i,b) p[(i)>>3] = (b) ? (p[(i)>>3] | BIT_MASK_TABLE[(i)&7]) : (p[(i)>>3] & ~BIT_MASK_TABLE[(i)&7])
-#define READ_BIT1(p,i)    (p[(i)>>3] & BIT_MASK_TABLE[(i)&7])
+
+const uint8_t NOAVEPTR = 99U;
+
+const uint16_t NOENDPTR = 9999U;
+
+const unsigned int MAX_SYNC_FRAMES = 4U + 1U;
 
 CP25RX::CP25RX() :
-m_pll(0U),
-m_prev(false),
 m_state(P25RXS_NONE),
-m_bitBuffer(0x00U),
-m_symbols(),
-m_outBuffer(),
-m_buffer(NULL),
-m_bufferPtr(0U),
-m_symbolPtr(0U),
+m_bitBuffer(),
+m_buffer(),
+m_bitPtr(0U),
+m_dataPtr(0U),
+m_hdrStartPtr(NOENDPTR),
+m_lduStartPtr(NOENDPTR),
+m_lduEndPtr(NOENDPTR),
+m_minSyncPtr(NOENDPTR),
+m_maxSyncPtr(NOENDPTR),
+m_hdrSyncPtr(NOENDPTR),
+m_lduSyncPtr(NOENDPTR),
+m_maxCorr(0),
 m_lostCount(0U),
-m_centre(0),
-m_threshold(0)
+m_countdown(0U),
+m_centre(),
+m_centreVal(0),
+m_threshold(),
+m_thresholdVal(0),
+m_averagePtr(NOAVEPTR),
+m_rssiAccum(0U),
+m_rssiCount(0U),
+m_duid(0U)
 {
-  m_buffer = m_outBuffer + 1U;
 }
 
 void CP25RX::reset()
 {
-  m_pll       = 0U;
-  m_prev      = false;
-  m_state     = P25RXS_NONE;
-  m_bitBuffer = 0x00U;
-  m_bufferPtr = 0U;
-  m_symbolPtr = 0U;
-  m_lostCount = 0U;
-  m_centre    = 0;
-  m_threshold = 0;
+  m_state         = P25RXS_NONE;
+  m_dataPtr       = 0U;
+  m_bitPtr        = 0U;
+  m_maxCorr       = 0;
+  m_averagePtr    = NOAVEPTR;
+  m_hdrStartPtr   = NOENDPTR;
+  m_lduStartPtr   = NOENDPTR;
+  m_lduEndPtr     = NOENDPTR;
+  m_hdrSyncPtr    = NOENDPTR;
+  m_lduSyncPtr    = NOENDPTR;
+  m_minSyncPtr    = NOENDPTR;
+  m_maxSyncPtr    = NOENDPTR;
+  m_centreVal     = 0;
+  m_thresholdVal  = 0;
+  m_lostCount     = 0U;
+  m_countdown     = 0U;
+  m_rssiAccum     = 0U;
+  m_rssiCount     = 0U;
+  m_duid          = 0U;
 }
 
-void CP25RX::samples(const q15_t* samples, uint8_t length)
+void CP25RX::samples(const q15_t* samples, uint16_t* rssi, uint8_t length)
 {
-  for (uint16_t i = 0U; i < length; i++) {
-    bool bit = samples[i] < 0;
+  for (uint8_t i = 0U; i < length; i++) {
+    q15_t sample = samples[i];
 
-    if (bit != m_prev) {
-      if (m_pll < (PLLMAX / 2U))
-        m_pll += INC;
-      else
-        m_pll -= INC;
+    m_rssiAccum += rssi[i];
+    m_rssiCount++;
+
+    m_bitBuffer[m_bitPtr] <<= 1;
+    if (sample < 0)
+      m_bitBuffer[m_bitPtr] |= 0x01U;
+
+    m_buffer[m_dataPtr] = sample;
+
+    switch (m_state) {
+    case P25RXS_HDR:
+      processHdr(sample);
+      break;
+    case P25RXS_LDU:
+      processLdu(sample);
+      break;
+    default:
+      processNone(sample);
+      break;
     }
 
-    m_prev = bit;
-
-    m_pll += PLLINC;
-
-    if (m_pll >= PLLMAX) {
-      m_pll -= PLLMAX;
-
-      if (m_state == P25RXS_NONE)
-        processNone(samples[i]);
-      else
-        processData(samples[i]);
+    m_dataPtr++;
+    if (m_dataPtr >= P25_LDU_FRAME_LENGTH_SAMPLES) {
+      m_dataPtr = 0U;
+      m_duid = 0U;
     }
+
+    m_bitPtr++;
+    if (m_bitPtr >= P25_RADIO_SYMBOL_LENGTH)
+      m_bitPtr = 0U;
   }
 }
 
 void CP25RX::processNone(q15_t sample)
 {
-  m_symbolBuffer <<= 1;
-  if (sample < 0)
-    m_symbolBuffer |= 0x01U;
-
-  m_symbols[m_symbolPtr] = sample;
-
-  // Fuzzy matching of the data sync bit sequence
-  if (countBits32((m_symbolBuffer & P25_SYNC_SYMBOLS_MASK) ^ P25_SYNC_SYMBOLS) <= SYNC_SYMBOL_ERRS) {
-    q15_t max  = -16000;
-    q15_t min  =  16000;
-
-    for (uint8_t i = 0U; i < P25_SYNC_LENGTH_SYMBOLS; i++) {
-      q15_t val = m_symbols[i];
-      if (val > max)
-        max = val;
-      if (val < min)
-        min = val;
-    }
-
-    q15_t centre = (max + min) >> 1;
-
-    q31_t v1 = (max - centre) * SCALING_FACTOR;
-    q15_t threshold = q15_t(v1 >> 15);
-
-    uint16_t ptr = m_symbolPtr + 1U;
-    if (ptr >= P25_SYNC_LENGTH_SYMBOLS)
-      ptr = 0U;
-
-    for (uint8_t i = 0U; i < P25_SYNC_LENGTH_SYMBOLS; i++) {
-      q15_t sample = m_symbols[ptr] - centre;
-
-      if (sample < -threshold) {
-        m_bitBuffer <<= 2;
-        m_bitBuffer |= 0x01U;
-      } else if (sample < 0) {
-        m_bitBuffer <<= 2;
-        m_bitBuffer |= 0x00U;
-      } else if (sample < threshold) {
-        m_bitBuffer <<= 2;
-        m_bitBuffer |= 0x02U;
-      } else {
-        m_bitBuffer <<= 2;
-        m_bitBuffer |= 0x03U;
-      }
-
-      ptr++;
-      if (ptr >= P25_SYNC_LENGTH_SYMBOLS)
-        ptr = 0U;
-    }
-
-    // Fuzzy matching of the data sync bit sequence
-    if (countBits64((m_bitBuffer & P25_SYNC_BITS_MASK) ^ P25_SYNC_BITS) <= SYNC_BIT_START_ERRS) {
-      DEBUG5("P25RX: sync found in None min/max/centre/threshold", min, max, centre, threshold);
-      for (uint8_t i = 0U; i < P25_SYNC_LENGTH_BYTES; i++)
-        m_buffer[i] = P25_SYNC_BYTES[i];
-      m_centre    = centre;
-      m_threshold = threshold;
-      m_lostCount = MAX_SYNC_FRAMES;
-      m_bufferPtr = P25_SYNC_LENGTH_BITS;
-      m_state     = P25RXS_DATA;
+  bool ret = correlateSync();
+  if (ret) {
+    // On the first sync, start the countdown to the state change
+    if (m_countdown == 0U) {
+      m_rssiAccum = 0U;
+      m_rssiCount = 0U;
 
       io.setDecode(true);
       io.setADCDetection(true);
+
+      m_averagePtr = NOAVEPTR;
+
+      m_countdown = CORRELATION_COUNTDOWN;
     }
   }
 
-  m_symbolPtr++;
-  if (m_symbolPtr >= P25_SYNC_LENGTH_SYMBOLS)
-    m_symbolPtr = 0U;
+  if (m_countdown > 0U)
+    m_countdown--;
+
+  if (m_countdown == 1U) {
+      // These are the sync positions for the following LDU after a HDR
+      m_minSyncPtr = m_hdrSyncPtr + P25_HDR_FRAME_LENGTH_SAMPLES - 1U;
+      if (m_minSyncPtr >= P25_LDU_FRAME_LENGTH_SAMPLES)
+        m_minSyncPtr -= P25_LDU_FRAME_LENGTH_SAMPLES;
+
+      m_maxSyncPtr = m_hdrSyncPtr + P25_HDR_FRAME_LENGTH_SAMPLES + 1U;
+      if (m_maxSyncPtr >= P25_LDU_FRAME_LENGTH_SAMPLES)
+        m_maxSyncPtr -= P25_LDU_FRAME_LENGTH_SAMPLES;
+
+      m_state     = P25RXS_HDR;
+      m_countdown = 0U;
+  }
 }
 
-void CP25RX::processData(q15_t sample)
+void CP25RX::processHdr(q15_t sample)
 {
-  sample -= m_centre;
-
-  if (sample < -m_threshold) {
-    m_bitBuffer <<= 2;
-    m_bitBuffer |= 0x01U;
-    WRITE_BIT1(m_buffer, m_bufferPtr, false);
-    m_bufferPtr++;
-    WRITE_BIT1(m_buffer, m_bufferPtr, true);
-    m_bufferPtr++;
-  } else if (sample < 0) {
-    m_bitBuffer <<= 2;
-    m_bitBuffer |= 0x00U;
-    WRITE_BIT1(m_buffer, m_bufferPtr, false);
-    m_bufferPtr++;
-    WRITE_BIT1(m_buffer, m_bufferPtr, false);
-    m_bufferPtr++;
-  } else if (sample < m_threshold) {
-    m_bitBuffer <<= 2;
-    m_bitBuffer |= 0x02U;
-    WRITE_BIT1(m_buffer, m_bufferPtr, true);
-    m_bufferPtr++;
-    WRITE_BIT1(m_buffer, m_bufferPtr, false);
-    m_bufferPtr++;
+  if (m_minSyncPtr < m_maxSyncPtr) {
+    if (m_dataPtr >= m_minSyncPtr && m_dataPtr <= m_maxSyncPtr)
+      correlateSync();
   } else {
-    m_bitBuffer <<= 2;
-    m_bitBuffer |= 0x03U;
-    WRITE_BIT1(m_buffer, m_bufferPtr, true);
-    m_bufferPtr++;
-    WRITE_BIT1(m_buffer, m_bufferPtr, true);
-    m_bufferPtr++;
+    if (m_dataPtr >= m_minSyncPtr || m_dataPtr <= m_maxSyncPtr)
+      correlateSync();
   }
 
-  // Search for an early sync to indicate an LDU following a header
-  if (m_bufferPtr >= (P25_HDR_FRAME_LENGTH_BITS + P25_SYNC_LENGTH_BITS - 1U) && m_bufferPtr <= (P25_HDR_FRAME_LENGTH_BITS + P25_SYNC_LENGTH_BITS + 1U)) {
-    // Fuzzy matching of the data sync bit sequence
-    if (countBits64((m_bitBuffer & P25_SYNC_BITS_MASK) ^ P25_SYNC_BITS) <= SYNC_BIT_RUN_ERRS) {
-      DEBUG2("P25RX: found LDU sync in Data, pos", m_bufferPtr - P25_SYNC_LENGTH_BITS);
+  if (m_dataPtr == m_maxSyncPtr) {
+    uint16_t nidStartPtr = m_hdrStartPtr + P25_SYNC_LENGTH_SAMPLES;
+    if (nidStartPtr >= P25_LDU_FRAME_LENGTH_SAMPLES)
+        nidStartPtr -= P25_LDU_FRAME_LENGTH_SAMPLES;
 
-      m_outBuffer[0U] = 0x01U;
-      serial.writeP25Hdr(m_outBuffer, P25_HDR_FRAME_LENGTH_BYTES + 1U);
+    uint8_t nid[2U];
+    samplesToBits(nidStartPtr, (2U * 4U), nid, 0U, m_centreVal, m_thresholdVal);
+    // DEBUG3("P25RX: nid (b0 - b1)", nid[0U], nid[1U]);
 
-      // Restore the sync that's now in the wrong place
-      for (uint8_t i = 0U; i < P25_SYNC_LENGTH_BYTES; i++)
-        m_buffer[i] = P25_SYNC_BYTES[i];
+    m_duid = nid[1U] & 0x0F;
 
-      m_lostCount = MAX_SYNC_FRAMES;
-      m_bufferPtr = P25_SYNC_LENGTH_BITS;
+    switch (m_duid) {
+        case P25_DUID_HDU: {
+                calculateLevels(m_hdrStartPtr, P25_HDR_FRAME_LENGTH_SYMBOLS);
+
+                DEBUG4("P25RX: sync found in Hdr pos/centre/threshold", m_hdrSyncPtr, m_centreVal, m_thresholdVal);
+
+                uint8_t frame[P25_HDR_FRAME_LENGTH_BYTES + 1U];
+                samplesToBits(m_hdrStartPtr, P25_HDR_FRAME_LENGTH_SYMBOLS, frame, 8U, m_centreVal, m_thresholdVal);
+
+                frame[0U] = 0x01U;
+                serial.writeP25Hdr(frame, P25_HDR_FRAME_LENGTH_BYTES + 1U);
+            }
+            break;
+		case P25_DUID_PDU: {
+				calculateLevels(m_hdrSyncPtr, P25_PDU_HDR_FRAME_LENGTH_SYMBOLS);
+
+				DEBUG4("P25RX: sync found in PDU pos/centre/threshold", m_hdrSyncPtr, m_centreVal, m_thresholdVal);
+
+				uint8_t frame[P25_PDU_HDR_FRAME_LENGTH_BYTES + 1U];
+				samplesToBits(m_hdrSyncPtr, P25_PDU_HDR_FRAME_LENGTH_SYMBOLS, frame, 8U, m_centreVal, m_thresholdVal);
+
+				frame[0U] = 0x01U;
+				serial.writeP25Hdr(frame, P25_PDU_HDR_FRAME_LENGTH_BYTES + 1U);
+			}
+			break;
+		case P25_DUID_TSDU: {
+                calculateLevels(m_hdrStartPtr, P25_TSDU_FRAME_LENGTH_SYMBOLS);
+
+                DEBUG4("P25RX: sync found in TSDU pos/centre/threshold", m_hdrSyncPtr, m_centreVal, m_thresholdVal);
+
+                uint8_t frame[P25_TSDU_FRAME_LENGTH_BYTES + 1U];
+                samplesToBits(m_hdrStartPtr, P25_TSDU_FRAME_LENGTH_SYMBOLS, frame, 8U, m_centreVal, m_thresholdVal);
+
+                frame[0U] = 0x01U;
+                serial.writeP25Hdr(frame, P25_TSDU_FRAME_LENGTH_BYTES + 1U);
+            }
+            break;
+        case P25_DUID_TDU: {
+                calculateLevels(m_hdrStartPtr, P25_TERM_FRAME_LENGTH_SYMBOLS);
+
+                DEBUG4("P25RX: sync found in TDU pos/centre/threshold", m_hdrSyncPtr, m_centreVal, m_thresholdVal);
+
+                uint8_t frame[P25_TERM_FRAME_LENGTH_BYTES + 1U];
+                samplesToBits(m_hdrStartPtr, P25_TERM_FRAME_LENGTH_SYMBOLS, frame, 8U, m_centreVal, m_thresholdVal);
+
+                frame[0U] = 0x01U;
+                serial.writeP25Hdr(frame, P25_TERM_FRAME_LENGTH_BYTES + 1U);
+            }
+            break;
+        case P25_DUID_TDULC: {
+                calculateLevels(m_hdrStartPtr, P25_TERMLC_FRAME_LENGTH_SYMBOLS);
+
+                DEBUG4("P25RX: sync found in TDULC pos/centre/threshold", m_hdrSyncPtr, m_centreVal, m_thresholdVal);
+
+                uint8_t frame[P25_TERMLC_FRAME_LENGTH_BYTES + 1U];
+                samplesToBits(m_hdrStartPtr, P25_TERMLC_FRAME_LENGTH_SYMBOLS, frame, 8U, m_centreVal, m_thresholdVal);
+
+                frame[0U] = 0x01U;
+                serial.writeP25Hdr(frame, P25_TERMLC_FRAME_LENGTH_BYTES + 1U);
+            }
+            break;
+        default:
+            break;
     }
+
+    m_minSyncPtr = m_lduSyncPtr + P25_LDU_FRAME_LENGTH_SAMPLES - 1U;
+    if (m_minSyncPtr >= P25_LDU_FRAME_LENGTH_SAMPLES)
+      m_minSyncPtr -= P25_LDU_FRAME_LENGTH_SAMPLES;
+
+    m_maxSyncPtr = m_lduSyncPtr + 1U;
+    if (m_maxSyncPtr >= P25_LDU_FRAME_LENGTH_SAMPLES)
+      m_maxSyncPtr -= P25_LDU_FRAME_LENGTH_SAMPLES;
+
+    m_state   = P25RXS_LDU;
+    m_maxCorr = 0;
+  }
+}
+
+void CP25RX::processLdu(q15_t sample)
+{
+  if (m_minSyncPtr < m_maxSyncPtr) {
+    if (m_dataPtr >= m_minSyncPtr && m_dataPtr <= m_maxSyncPtr)
+      correlateSync();
+  } else {
+    if (m_dataPtr >= m_minSyncPtr || m_dataPtr <= m_maxSyncPtr)
+      correlateSync();
   }
 
-  // Only search for a sync in the right place +-2 symbols
-  if (m_bufferPtr >= (P25_SYNC_LENGTH_BITS - 2U) && m_bufferPtr <= (P25_SYNC_LENGTH_BITS + 2U)) {
-    // Fuzzy matching of the data sync bit sequence
-    if (countBits64((m_bitBuffer & P25_SYNC_BITS_MASK) ^ P25_SYNC_BITS) <= SYNC_BIT_RUN_ERRS) {
-      DEBUG2("P25RX: found sync in Data, pos", m_bufferPtr - P25_SYNC_LENGTH_BITS);
-      m_lostCount = MAX_SYNC_FRAMES;
-      m_bufferPtr = P25_SYNC_LENGTH_BITS;
+  if (m_dataPtr == m_lduEndPtr) {
+    // Only update the centre and threshold if they are from a good sync
+    if (m_lostCount == MAX_SYNC_FRAMES) {
+      m_minSyncPtr = m_lduSyncPtr + P25_LDU_FRAME_LENGTH_SAMPLES - 1U;
+      if (m_minSyncPtr >= P25_LDU_FRAME_LENGTH_SAMPLES)
+        m_minSyncPtr -= P25_LDU_FRAME_LENGTH_SAMPLES;
+
+      m_maxSyncPtr = m_lduSyncPtr + 1U;
+      if (m_maxSyncPtr >= P25_LDU_FRAME_LENGTH_SAMPLES)
+        m_maxSyncPtr -= P25_LDU_FRAME_LENGTH_SAMPLES;
     }
-  }
 
-  // Send a data frame to the host if the required number of bits have been received
-  if (m_bufferPtr == P25_LDU_FRAME_LENGTH_BITS) {
+    calculateLevels(m_lduStartPtr, P25_LDU_FRAME_LENGTH_SYMBOLS);
+
+    DEBUG4("P25RX: sync found in Ldu pos/centre/threshold", m_lduSyncPtr, m_centreVal, m_thresholdVal);
+
+    uint8_t frame[P25_LDU_FRAME_LENGTH_BYTES + 3U];
+    samplesToBits(m_lduStartPtr, P25_LDU_FRAME_LENGTH_SYMBOLS, frame, 8U, m_centreVal, m_thresholdVal);
+
     // We've not seen a data sync for too long, signal RXLOST and change to RX_NONE
     m_lostCount--;
     if (m_lostCount == 0U) {
@@ -247,16 +303,235 @@ void CP25RX::processData(q15_t sample)
 
       serial.writeP25Lost();
 
-      m_state = P25RXS_NONE;
-    } else {
-      m_outBuffer[0U] = m_lostCount == (MAX_SYNC_FRAMES - 1U) ? 0x01U : 0x00U;
-
-      serial.writeP25Ldu(m_outBuffer, P25_LDU_FRAME_LENGTH_BYTES + 1U);
-
-      // Start the next frame
-      ::memset(m_outBuffer, 0x00U, P25_LDU_FRAME_LENGTH_BYTES + 3U);
-      m_bufferPtr = 0U;
+      m_state      = P25RXS_NONE;
+      m_lduEndPtr  = NOENDPTR;
+      m_averagePtr = NOAVEPTR;
+      m_countdown  = 0U;
+      m_maxCorr    = 0;
+      m_duid       = 0U;
+		} else {
+      frame[0U] = m_lostCount == (MAX_SYNC_FRAMES - 1U) ? 0x01U : 0x00U;
+      writeRSSILdu(frame);
+      m_maxCorr = 0;
     }
   }
 }
 
+bool CP25RX::correlateSync()
+{
+  if (countBits32((m_bitBuffer[m_bitPtr] & P25_SYNC_SYMBOLS_MASK) ^ P25_SYNC_SYMBOLS) <= MAX_SYNC_SYMBOLS_ERRS) {
+    uint16_t ptr = m_dataPtr + P25_LDU_FRAME_LENGTH_SAMPLES - P25_SYNC_LENGTH_SAMPLES + P25_RADIO_SYMBOL_LENGTH;
+    if (ptr >= P25_LDU_FRAME_LENGTH_SAMPLES)
+      ptr -= P25_LDU_FRAME_LENGTH_SAMPLES;
+
+    q31_t corr = 0;
+    q15_t min =  16000;
+    q15_t max = -16000;
+
+    for (uint8_t i = 0U; i < P25_SYNC_LENGTH_SYMBOLS; i++) {
+      q15_t val = m_buffer[ptr];
+
+      if (val > max)
+        max = val;
+      if (val < min)
+        min = val;
+
+      switch (P25_SYNC_SYMBOLS_VALUES[i]) {
+      case +3:
+        corr -= (val + val + val);
+        break;
+      case +1:
+        corr -= val;
+        break;
+      case -1:
+        corr += val;
+        break;
+      default:  // -3
+        corr += (val + val + val);
+        break;
+      }
+
+      ptr += P25_RADIO_SYMBOL_LENGTH;
+      if (ptr >= P25_LDU_FRAME_LENGTH_SAMPLES)
+        ptr -= P25_LDU_FRAME_LENGTH_SAMPLES;
+    }
+
+    if (corr > m_maxCorr) {
+      if (m_averagePtr == NOAVEPTR) {
+        m_centreVal = (max + min) >> 1;
+
+        q31_t v1 = (max - m_centreVal) * SCALING_FACTOR;
+        m_thresholdVal = q15_t(v1 >> 15);
+      }
+
+      uint16_t startPtr = m_dataPtr + P25_LDU_FRAME_LENGTH_SAMPLES - P25_SYNC_LENGTH_SAMPLES + P25_RADIO_SYMBOL_LENGTH;
+      if (startPtr >= P25_LDU_FRAME_LENGTH_SAMPLES)
+        startPtr -= P25_LDU_FRAME_LENGTH_SAMPLES;
+
+      uint8_t sync[P25_SYNC_BYTES_LENGTH];
+      samplesToBits(startPtr, P25_SYNC_LENGTH_SYMBOLS, sync, 0U, m_centreVal, m_thresholdVal);
+
+      uint8_t maxErrs;
+      if (m_state == P25RXS_NONE)
+        maxErrs = MAX_SYNC_BIT_START_ERRS;
+      else
+        maxErrs = MAX_SYNC_BIT_RUN_ERRS;
+
+      uint8_t errs = 0U;
+      for (uint8_t i = 0U; i < P25_SYNC_BYTES_LENGTH; i++)
+        errs += countBits8(sync[i] ^ P25_SYNC_BYTES[i]);
+
+      if (errs <= maxErrs) {
+        m_maxCorr     = corr;
+        m_lostCount   = MAX_SYNC_FRAMES;
+
+        m_lduSyncPtr  = m_dataPtr;
+
+        // These are the positions of the start and end of an LDU
+        m_lduStartPtr = startPtr;
+
+        m_lduEndPtr = m_dataPtr + P25_LDU_FRAME_LENGTH_SAMPLES - P25_SYNC_LENGTH_SAMPLES - 1U;
+        if (m_lduEndPtr >= P25_LDU_FRAME_LENGTH_SAMPLES)
+          m_lduEndPtr -= P25_LDU_FRAME_LENGTH_SAMPLES;
+
+        if (m_state == P25RXS_NONE) {
+          m_hdrSyncPtr = m_dataPtr;
+
+          // This is the position of the start of a HDR
+          m_hdrStartPtr = startPtr;
+
+          // These are the range of positions for a sync for an LDU following a HDR
+          m_minSyncPtr = m_dataPtr + P25_HDR_FRAME_LENGTH_SAMPLES - 1U;
+          if (m_minSyncPtr >= P25_LDU_FRAME_LENGTH_SAMPLES)
+            m_minSyncPtr -= P25_LDU_FRAME_LENGTH_SAMPLES;
+
+          m_maxSyncPtr = m_dataPtr + P25_HDR_FRAME_LENGTH_SAMPLES + 1U;
+          if (m_maxSyncPtr >= P25_LDU_FRAME_LENGTH_SAMPLES)
+            m_maxSyncPtr -= P25_LDU_FRAME_LENGTH_SAMPLES;
+        }
+
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+void CP25RX::calculateLevels(uint16_t start, uint16_t count)
+{
+  q15_t maxPos = -16000;
+  q15_t minPos =  16000;
+  q15_t maxNeg =  16000;
+  q15_t minNeg = -16000;
+
+  for (uint16_t i = 0U; i < count; i++) {
+    q15_t sample = m_buffer[start];
+
+    if (sample > 0) {
+      if (sample > maxPos)
+        maxPos = sample;
+      if (sample < minPos)
+        minPos = sample;
+    } else {
+      if (sample < maxNeg)
+        maxNeg = sample;
+      if (sample > minNeg)
+        minNeg = sample;
+    }
+
+    start += P25_RADIO_SYMBOL_LENGTH;
+    if (start >= P25_LDU_FRAME_LENGTH_SAMPLES)
+      start -= P25_LDU_FRAME_LENGTH_SAMPLES;
+  }
+
+  q15_t posThresh = (maxPos + minPos) >> 1;
+  q15_t negThresh = (maxNeg + minNeg) >> 1;
+
+  q15_t centre = (posThresh + negThresh) >> 1;
+
+  q15_t threshold = posThresh - centre;
+
+  DEBUG5("P25RX: pos/neg/centre/threshold", posThresh, negThresh, centre, threshold);
+
+  if (m_averagePtr == NOAVEPTR) {
+    for (uint8_t i = 0U; i < 16U; i++) {
+      m_centre[i]    = centre;
+      m_threshold[i] = threshold;
+    }
+
+    m_averagePtr = 0U;
+  } else {
+    m_centre[m_averagePtr]    = centre;
+    m_threshold[m_averagePtr] = threshold;
+
+    m_averagePtr++;
+    if (m_averagePtr >= 16U)
+      m_averagePtr = 0U;
+  }
+
+  m_centreVal    = 0;
+  m_thresholdVal = 0;
+
+  for (uint8_t i = 0U; i < 16U; i++) {
+    m_centreVal    += m_centre[i];
+    m_thresholdVal += m_threshold[i];
+  }
+
+  m_centreVal    >>= 4;
+  m_thresholdVal >>= 4;
+}
+
+void CP25RX::samplesToBits(uint16_t start, uint16_t count, uint8_t* buffer, uint16_t offset, q15_t centre, q15_t threshold)
+{
+  for (uint16_t i = 0U; i < count; i++) {
+    q15_t sample = m_buffer[start] - centre;
+
+    if (sample < -threshold) {
+      WRITE_BIT1(buffer, offset, false);
+      offset++;
+      WRITE_BIT1(buffer, offset, true);
+      offset++;
+    } else if (sample < 0) {
+      WRITE_BIT1(buffer, offset, false);
+      offset++;
+      WRITE_BIT1(buffer, offset, false);
+      offset++;
+    } else if (sample < threshold) {
+      WRITE_BIT1(buffer, offset, true);
+      offset++;
+      WRITE_BIT1(buffer, offset, false);
+      offset++;
+    } else {
+      WRITE_BIT1(buffer, offset, true);
+      offset++;
+      WRITE_BIT1(buffer, offset, true);
+      offset++;
+    }
+
+    start += P25_RADIO_SYMBOL_LENGTH;
+    if (start >= P25_LDU_FRAME_LENGTH_SAMPLES)
+      start -= P25_LDU_FRAME_LENGTH_SAMPLES;
+  }
+}
+
+void CP25RX::writeRSSILdu(uint8_t* ldu)
+{
+#if defined(SEND_RSSI_DATA)
+  if (m_rssiCount > 0U) {
+    uint16_t rssi = m_rssiAccum / m_rssiCount;
+
+    ldu[217U] = (rssi >> 8) & 0xFFU;
+    ldu[218U] = (rssi >> 0) & 0xFFU;
+
+    serial.writeP25Ldu(ldu, P25_LDU_FRAME_LENGTH_BYTES + 3U);
+  } else {
+    serial.writeP25Ldu(ldu, P25_LDU_FRAME_LENGTH_BYTES + 1U);
+  }
+#else
+  serial.writeP25Ldu(ldu, P25_LDU_FRAME_LENGTH_BYTES + 1U);
+#endif
+
+  m_rssiAccum = 0U;
+  m_rssiCount = 0U;
+}

P25RX.h

@@ -1,5 +1,6 @@
 /*
- *   Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2018 by Bryan Biedenkapp <[email protected]>
  *
  *   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
@@ -24,35 +25,50 @@
 
 enum P25RX_STATE {
   P25RXS_NONE,
-  P25RXS_DATA
+  P25RXS_HDR,
+  P25RXS_LDU
 };
 
 class CP25RX {
 public:
   CP25RX();
 
-  void samples(const q15_t* samples, uint8_t length);
+  void samples(const q15_t* samples, uint16_t* rssi, uint8_t length);
 
   void reset();
 
 private:
-  uint32_t    m_pll;
-  bool        m_prev;
   P25RX_STATE m_state;
-  uint32_t    m_symbolBuffer;
-  uint64_t    m_bitBuffer;
-  q15_t       m_symbols[P25_SYNC_LENGTH_SYMBOLS];
-  uint8_t     m_outBuffer[P25_LDU_FRAME_LENGTH_BYTES + 3U];
-  uint8_t*    m_buffer;
-  uint16_t    m_bufferPtr;
-  uint16_t    m_symbolPtr;
+  uint32_t    m_bitBuffer[P25_RADIO_SYMBOL_LENGTH];
+  q15_t       m_buffer[P25_LDU_FRAME_LENGTH_SAMPLES];
+  uint16_t    m_bitPtr;
+  uint16_t    m_dataPtr;
+  uint16_t    m_hdrStartPtr;
+  uint16_t    m_lduStartPtr;
+  uint16_t    m_lduEndPtr;
+  uint16_t    m_minSyncPtr;
+  uint16_t    m_maxSyncPtr;
+  uint16_t    m_hdrSyncPtr;
+  uint16_t    m_lduSyncPtr;
+  q31_t       m_maxCorr;
   uint16_t    m_lostCount;
-  q15_t       m_centre;
-  q15_t       m_threshold;
+  uint8_t     m_countdown;
+  q15_t       m_centre[16U];
+  q15_t       m_centreVal;
+  q15_t       m_threshold[16U];
+  q15_t       m_thresholdVal;
+  uint8_t     m_averagePtr;
+  uint32_t    m_rssiAccum;
+  uint16_t    m_rssiCount;
+  uint8_t     m_duid;
 
   void processNone(q15_t sample);
-  void processData(q15_t sample);
+  void processHdr(q15_t sample);
+  void processLdu(q15_t sample);
+  bool correlateSync();
+  void calculateLevels(uint16_t start, uint16_t count);
+  void samplesToBits(uint16_t start, uint16_t count, uint8_t* buffer, uint16_t offset, q15_t centre, q15_t threshold);
+  void writeRSSILdu(uint8_t* ldu);
 };
 
 #endif
-

P25TX.cpp

@@ -1,5 +1,6 @@
 /*
- *   Copyright (C) 2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2016,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
  *   it under the terms of the GNU General Public License as published by
@@ -16,45 +17,33 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-// #define WANT_DEBUG
-
 #include "Config.h"
 #include "Globals.h"
 #include "P25TX.h"
 
 #include "P25Defines.h"
 
-#if defined(WIDE_C4FSK_FILTERS_TX)
-// Generated using rcosdesign(0.2, 4, 5, 'sqrt') in MATLAB
-static q15_t P25_C4FSK_FILTER[] = {688, -680, -2158, -3060, -2724, -775, 2684, 7041, 11310, 14425, 15565, 14425,
-                                   11310, 7041, 2684, -775, -2724, -3060, -2158, -680, 688, 0};
-const uint16_t P25_C4FSK_FILTER_LEN = 22U;
-#else
-// Generated using rcosdesign(0.2, 8, 5, 'sqrt') in MATLAB
-static q15_t P25_C4FSK_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 P25_C4FSK_FILTER_LEN = 42U;
-#endif
+// Generated using rcosdesign(0.2, 8, 5, 'normal') in MATLAB
+// numTaps = 40, L = 5
+static q15_t RC_0_2_FILTER[] = {-897, -1636, -1840, -1278, 0, 1613, 2936, 3310, 2315, 0, -3011, -5627, -6580, -4839,
+                                0, 7482, 16311, 24651, 30607, 32767, 30607, 24651, 16311, 7482, 0, -4839, -6580, -5627,
+                               -3011, 0, 2315, 3310, 2936, 1613, 0, -1278, -1840, -1636, -897, 0}; // numTaps = 40, L = 5
+const uint16_t RC_0_2_FILTER_PHASE_LEN = 8U; // phaseLength = numTaps/L
 
-// Generated in MATLAB using the following commands, and then normalised for unity gain
-// shape2 = 'Inverse-sinc Lowpass';
-// d2 = fdesign.interpolator(2, shape2);  
-// h2 = design(d2, 'SystemObject', true);
-static q15_t P25_LP_FILTER[] = {170, 401, 340, -203, -715, -478, 281, 419, -440, -1002, -103, 1114, 528, -1389, -1520, 1108, 2674, -388, -4662,
-                                -2132, 9168, 20241, 20241, 9168, -2132, -4662, -388, 2674, 1108, -1520, -1389, 528, 1114, -103, -1002, -440, 419,
-                                281, -478, -715, -203, 340, 401, 170};
-const uint16_t P25_LP_FILTER_LEN = 44U;
+static q15_t LOWPASS_FILTER[] = {124, -188, -682, 1262, 556, -621, -1912, -911, 2058, 3855, 1234, -4592, -7692, -2799,
+                                8556, 18133, 18133, 8556, -2799, -7692, -4592, 1234, 3855, 2058, -911, -1912, -621,
+                                556, 1262, -682, -188, 124};
+const uint16_t LOWPASS_FILTER_LEN = 32U;
 
-const q15_t P25_LEVELA[] = { 495,  495,  495,  495,  495};
-const q15_t P25_LEVELB[] = { 165,  165,  165,  165,  165};
-const q15_t P25_LEVELC[] = {-165, -165, -165, -165, -165};
-const q15_t P25_LEVELD[] = {-495, -495, -495, -495, -495};
+const q15_t P25_LEVELA =  1260;
+const q15_t P25_LEVELB =   420;
+const q15_t P25_LEVELC =  -420;
+const q15_t P25_LEVELD = -1260;
 
 const uint8_t P25_START_SYNC = 0x77U;
 
 CP25TX::CP25TX() :
-m_buffer(1500U),
+m_buffer(TX_BUFFER_LEN),
 m_modFilter(),
 m_lpFilter(),
 m_modState(),
@@ -63,35 +52,34 @@ m_poBuffer(),
 m_poLen(0U),
 m_poPtr(0U),
 m_txDelay(240U),      // 200ms
-m_count(0U)
+m_txHang(6000U),      // 5s
+m_txCount(0U)
 {
-  ::memset(m_modState, 0x00U, 70U * sizeof(q15_t));
-  ::memset(m_lpState,  0x00U, 70U * sizeof(q15_t));
+  ::memset(m_modState, 0x00U, 16U * sizeof(q15_t));
+  ::memset(m_lpState,  0x00U, 60U * sizeof(q15_t));
 
-  m_modFilter.numTaps = P25_C4FSK_FILTER_LEN;
-  m_modFilter.pState  = m_modState;
-  m_modFilter.pCoeffs = P25_C4FSK_FILTER;
+  m_modFilter.L           = P25_RADIO_SYMBOL_LENGTH;
+  m_modFilter.phaseLength = RC_0_2_FILTER_PHASE_LEN;
+  m_modFilter.pCoeffs     = RC_0_2_FILTER;
+  m_modFilter.pState      = m_modState;
 
-  m_lpFilter.numTaps = P25_LP_FILTER_LEN;
+  m_lpFilter.numTaps = LOWPASS_FILTER_LEN;
   m_lpFilter.pState  = m_lpState;
-  m_lpFilter.pCoeffs = P25_LP_FILTER;
+  m_lpFilter.pCoeffs = LOWPASS_FILTER;
 }
 
 void CP25TX::process()
 {
-  if (m_buffer.getData() == 0U && m_poLen == 0U)
-    return;
-
-  if (m_poLen == 0U) {
+  if (m_poLen == 0U && m_buffer.getData() > 0U) {
     if (!m_tx) {
-      m_count = 0U;
-
       for (uint16_t i = 0U; i < m_txDelay; i++)
         m_poBuffer[m_poLen++] = P25_START_SYNC;
     } else {
-      uint8_t length = m_buffer.get();
+      uint8_t length;
+      m_buffer.get(length);
       for (uint8_t i = 0U; i < length; i++) {
-        uint8_t c = m_buffer.get();
+        uint8_t c = 0U;
+        m_buffer.get(c);
         m_poBuffer[m_poLen++] = c;
       }
     }
@@ -107,13 +95,28 @@ void CP25TX::process()
       writeByte(c);
 
       space -= 4U * P25_RADIO_SYMBOL_LENGTH;
-      
+       if (m_duplex)
+        m_txCount = m_txHang;
+
       if (m_poPtr >= m_poLen) {
         m_poPtr = 0U;
         m_poLen = 0U;
         return;
       }
     }
+  } else if (m_txCount > 0U) {
+    // Transmit silence until the hang timer has expired.
+    uint16_t space = io.getSpace();
+
+    while (space > (4U * P25_RADIO_SYMBOL_LENGTH)) {
+      writeSilence();
+
+      space -= 4U * P25_RADIO_SYMBOL_LENGTH;
+      m_txCount--;
+
+      if (m_txCount == 0U)
+        return;
+    }
   }
 }
 
@@ -135,61 +138,63 @@ uint8_t CP25TX::writeData(const uint8_t* data, uint8_t length)
 
 void CP25TX::writeByte(uint8_t c)
 {
-  q15_t inBuffer[P25_RADIO_SYMBOL_LENGTH * 4U + 1U];
-  q15_t intBuffer[P25_RADIO_SYMBOL_LENGTH * 4U + 1U];
-  q15_t outBuffer[P25_RADIO_SYMBOL_LENGTH * 4U + 1U];
+  q15_t inBuffer[4U];
+  q15_t intBuffer[P25_RADIO_SYMBOL_LENGTH * 4U];
+  q15_t outBuffer[P25_RADIO_SYMBOL_LENGTH * 4U];
 
   const uint8_t MASK = 0xC0U;
 
-  q15_t* p = inBuffer;
-  for (uint8_t i = 0U; i < 4U; i++, c <<= 2, p += P25_RADIO_SYMBOL_LENGTH) {
+  for (uint8_t i = 0U; i < 4U; i++, c <<= 2) {
     switch (c & MASK) {
       case 0xC0U:
-        ::memcpy(p, P25_LEVELA, P25_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
+        inBuffer[i] = P25_LEVELA;
         break;
       case 0x80U:
-        ::memcpy(p, P25_LEVELB, P25_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
+        inBuffer[i] = P25_LEVELB;
         break;
       case 0x00U:
-        ::memcpy(p, P25_LEVELC, P25_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
+        inBuffer[i] = P25_LEVELC;
         break;
       default:
-        ::memcpy(p, P25_LEVELD, P25_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
+        inBuffer[i] = P25_LEVELD;
         break;
     }
   }
 
-  uint16_t blockSize = P25_RADIO_SYMBOL_LENGTH * 4U;
+  ::arm_fir_interpolate_q15(&m_modFilter, inBuffer, intBuffer, 4U);
 
-  // Handle the case of the oscillator not being accurate enough
-  if (m_sampleCount > 0U) {
-    m_count += P25_RADIO_SYMBOL_LENGTH * 4U;
+  ::arm_fir_fast_q15(&m_lpFilter, intBuffer, outBuffer, P25_RADIO_SYMBOL_LENGTH * 4U);
 
-    if (m_count >= m_sampleCount) {
-      if (m_sampleInsert) {
-        inBuffer[P25_RADIO_SYMBOL_LENGTH * 4U] = inBuffer[P25_RADIO_SYMBOL_LENGTH * 4U - 1U];
-        blockSize++;
-      } else {
-        blockSize--;
-      }
+  io.write(STATE_P25, outBuffer, P25_RADIO_SYMBOL_LENGTH * 4U);
+}
 
-      m_count -= m_sampleCount;
-    }
-  }
+void CP25TX::writeSilence()
+{
+  q15_t inBuffer[4U] = {0x00U, 0x00U, 0x00U, 0x00U};
+  q15_t intBuffer[P25_RADIO_SYMBOL_LENGTH * 4U];
+  q15_t outBuffer[P25_RADIO_SYMBOL_LENGTH * 4U];
 
-  ::arm_fir_fast_q15(&m_modFilter, inBuffer, intBuffer, blockSize);
+  ::arm_fir_interpolate_q15(&m_modFilter, inBuffer, intBuffer, 4U);
 
-  ::arm_fir_fast_q15(&m_lpFilter, intBuffer, outBuffer, blockSize);
+  ::arm_fir_fast_q15(&m_lpFilter, intBuffer, outBuffer, P25_RADIO_SYMBOL_LENGTH * 4U);
 
-  io.write(STATE_P25, outBuffer, blockSize);
+  io.write(STATE_P25, outBuffer, P25_RADIO_SYMBOL_LENGTH * 4U);
 }
 
 void CP25TX::setTXDelay(uint8_t delay)
 {
   m_txDelay = 600U + uint16_t(delay) * 12U;        // 500ms + tx delay
+
+  if (m_txDelay > 1200U)
+    m_txDelay = 1200U;
 }
 
-uint16_t CP25TX::getSpace() const
+uint8_t CP25TX::getSpace() const
 {
   return m_buffer.getSpace() / P25_LDU_FRAME_LENGTH_BYTES;
 }
+
+void CP25TX::setParams(uint8_t txHang)
+{
+  m_txHang = txHang * 1200U;
+}

P25TX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 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
@@ -21,7 +21,7 @@
 
 #include "Config.h"
 
-#include "SerialRB.h"
+#include "RingBuffer.h"
 
 class CP25TX {
 public:
@@ -33,22 +33,25 @@ public:
 
   void setTXDelay(uint8_t delay);
 
-  uint16_t getSpace() const;
+  uint8_t getSpace() const;
+
+  void setParams(uint8_t txHang);
 
 private:
-  CSerialRB            m_buffer;
-  arm_fir_instance_q15 m_modFilter;
-  arm_fir_instance_q15 m_lpFilter;
-  q15_t                m_modState[70U];    // NoTaps + BlockSize - 1, 42 + 20 - 1 plus some spare
-  q15_t                m_lpState[70U];     // NoTaps + BlockSize - 1, 44 + 20 - 1 plus some spare
-  uint8_t              m_poBuffer[920U];
-  uint16_t             m_poLen;
-  uint16_t             m_poPtr;
-  uint16_t             m_txDelay;
-  uint32_t             m_count;
+  CRingBuffer<uint8_t>                        m_buffer;
+  arm_fir_interpolate_instance_q15 m_modFilter;
+  arm_fir_instance_q15             m_lpFilter;
+  q15_t                            m_modState[16U];    // blockSize + phaseLength - 1, 4 + 9 - 1 plus some spare
+  q15_t                            m_lpState[60U];     // NoTaps + BlockSize - 1, 32 + 20 - 1 plus some spare
+  uint8_t                          m_poBuffer[1200U];
+  uint16_t                         m_poLen;
+  uint16_t                         m_poPtr;
+  uint16_t                         m_txDelay;
+  uint32_t                         m_txHang;
+  uint32_t                         m_txCount;
 
   void writeByte(uint8_t c);
+  void writeSilence();
 };
 
 #endif
-

POCSAGTX.cpp

@@ -0,0 +1,149 @@
+/*
+ *   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
+ *   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 "POCSAGTX.h"
+
+const uint16_t POCSAG_FRAME_LENGTH_BYTES = 17U * sizeof(uint32_t);
+
+const uint16_t POCSAG_PREAMBLE_LENGTH_BYTES = 18U * sizeof(uint32_t);
+
+const uint16_t POCSAG_RADIO_SYMBOL_LENGTH = 20U;
+
+const q15_t POCSAG_LEVEL1[] = { 1700,  1700,  1700,  1700,  1700,  1700,  1700,  1700,  1700,  1700,  1700,  1700,  1700,  1700,  1700,  1700,  1700,  1700,  1700,  1700};
+const q15_t POCSAG_LEVEL0[] = {-1700, -1700, -1700, -1700, -1700, -1700, -1700, -1700, -1700, -1700, -1700, -1700, -1700, -1700, -1700, -1700, -1700, -1700, -1700, -1700};
+
+static q15_t SHAPING_FILTER[] = {5461, 5461, 5461, 5461, 5461, 5461};
+const uint16_t SHAPING_FILTER_LEN = 6U;
+
+const uint8_t POCSAG_SYNC = 0xAAU;
+
+CPOCSAGTX::CPOCSAGTX() :
+m_buffer(4000U),
+m_modFilter(),
+m_modState(),
+m_poBuffer(),
+m_poLen(0U),
+m_poPtr(0U),
+m_txDelay(POCSAG_PREAMBLE_LENGTH_BYTES)
+{
+  ::memset(m_modState, 0x00U, 170U * sizeof(q15_t));
+
+  m_modFilter.numTaps = SHAPING_FILTER_LEN;
+  m_modFilter.pState  = m_modState;
+  m_modFilter.pCoeffs = SHAPING_FILTER;
+}
+
+void CPOCSAGTX::process()
+{
+  if (m_buffer.getData() == 0U && m_poLen == 0U)
+    return;
+
+  if (m_poLen == 0U) {
+    if (!m_tx) {
+      for (uint16_t i = 0U; i < m_txDelay; i++)
+        m_poBuffer[m_poLen++] = POCSAG_SYNC;
+    } else {
+      for (uint8_t i = 0U; i < POCSAG_FRAME_LENGTH_BYTES; i++) {
+        uint8_t c = 0U;
+        m_buffer.get(c);
+        m_poBuffer[m_poLen++] = c;
+      }
+    }
+
+    m_poPtr = 0U;
+  }
+
+  if (m_poLen > 0U) {
+    uint16_t space = io.getSpace();
+    
+    while (space > (8U * POCSAG_RADIO_SYMBOL_LENGTH)) {
+      uint8_t c = m_poBuffer[m_poPtr++];
+      writeByte(c);
+
+      space -= 8U * POCSAG_RADIO_SYMBOL_LENGTH;
+      
+      if (m_poPtr >= m_poLen) {
+        m_poPtr = 0U;
+        m_poLen = 0U;
+        return;
+      }
+    }
+  }
+}
+
+bool CPOCSAGTX::busy()
+{
+  if (m_poLen > 0U || m_buffer.getData() > 0U)
+    return true;
+  else
+    return false;
+}
+
+uint8_t CPOCSAGTX::writeData(const uint8_t* data, uint8_t length)
+{
+  if (length != POCSAG_FRAME_LENGTH_BYTES)
+    return 4U;
+
+  uint16_t space = m_buffer.getSpace();
+  if (space < POCSAG_FRAME_LENGTH_BYTES)
+    return 5U;
+
+  for (uint8_t i = 0U; i < POCSAG_FRAME_LENGTH_BYTES; i++)
+    m_buffer.put(data[i]);
+
+  return 0U;
+}
+
+void CPOCSAGTX::writeByte(uint8_t c)
+{
+  q15_t inBuffer[POCSAG_RADIO_SYMBOL_LENGTH * 8U];
+  q15_t outBuffer[POCSAG_RADIO_SYMBOL_LENGTH * 8U];
+
+  const uint8_t MASK = 0x80U;
+
+  uint8_t n = 0U;
+  for (uint8_t i = 0U; i < 8U; i++, c <<= 1, n += POCSAG_RADIO_SYMBOL_LENGTH) {
+    switch (c & MASK) {
+      case 0x80U:
+        ::memcpy(inBuffer + n, POCSAG_LEVEL1, POCSAG_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
+        break;
+      default:
+        ::memcpy(inBuffer + n, POCSAG_LEVEL0, POCSAG_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
+        break;
+    }
+  }
+
+  ::arm_fir_fast_q15(&m_modFilter, inBuffer, outBuffer, POCSAG_RADIO_SYMBOL_LENGTH * 8U);
+
+  io.write(STATE_POCSAG, outBuffer, POCSAG_RADIO_SYMBOL_LENGTH * 8U);
+}
+
+void CPOCSAGTX::setTXDelay(uint8_t delay)
+{
+  m_txDelay = POCSAG_PREAMBLE_LENGTH_BYTES + (delay * 3U) / 2U;
+
+  if (m_txDelay > 150U)
+    m_txDelay = 150U;
+}
+
+uint8_t CPOCSAGTX::getSpace() const
+{
+  return m_buffer.getSpace() / POCSAG_FRAME_LENGTH_BYTES;
+}

POCSAGTX.h

@@ -0,0 +1,53 @@
+/*
+ *   Copyright (C) 2015-2019 by Jonathan Naylor G4KLX
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#if !defined(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);
+
+  void writeByte(uint8_t c);
+
+  void process();
+
+  void setTXDelay(uint8_t delay);
+
+  uint8_t getSpace() const;
+
+  bool busy();
+
+private:
+  CRingBuffer<uint8_t>            m_buffer;
+  arm_fir_instance_q15 m_modFilter;
+  q15_t                m_modState[170U];     // NoTaps + BlockSize - 1, 6 + 160 - 1 plus some spare
+  uint8_t              m_poBuffer[200U];
+  uint16_t             m_poLen;
+  uint16_t             m_poPtr;
+  uint16_t             m_txDelay;
+};
+
+#endif
+

README.md

@@ -1,7 +1,7 @@
-This is the source code of the MMDVM firmware that supports D-Star, DMR, System Fusion and P25.
+This is the source code of the MMDVM firmware that supports D-Star, DMR, System Fusion, P25, NXDN, and POCSAG modes.
 
-It runs on the Arduino Due and the ST-Micro STM32F4xx platforms. Support for the Teensy (3.1/3.2 and 3.5/3.6) is being added.
+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.
 
-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 is via the latest beta of 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 being supplied via the Coocox IDE with ARM GCC. 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.

RSSIRB.cpp

@@ -1,104 +0,0 @@
-/*
-TX fifo control - Copyright (C) KI6ZUM 2015
-Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
-
-This library is free software; you can redistribute it and/or
-modify it under the terms of the GNU Library General Public
-License as published by the Free Software Foundation; either
-version 2 of the License, or (at your option) any later version.
-
-This library 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
-Library General Public License for more details.
-
-You should have received a copy of the GNU Library General Public
-License along with this library; if not, write to the
-Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
-Boston, MA  02110-1301, USA.
-*/
-
-#include "RSSIRB.h"
-
-CRSSIRB::CRSSIRB(uint16_t length) :
-m_length(length),
-m_rssi(NULL),
-m_head(0U),
-m_tail(0U),
-m_full(false),
-m_overflow(false)
-{
-  m_rssi = new uint16_t[length];
-}
-
-uint16_t CRSSIRB::getSpace() const
-{
-  uint16_t n = 0U;
-
-  if (m_tail == m_head)
-    n = m_full ? 0U : m_length;
-  else if (m_tail < m_head)
-    n = m_length - m_head + m_tail;
-  else
-    n = m_tail - m_head;
-
-  if (n > m_length)
-    n = 0U;
-
-  return n;
-}
-
-uint16_t CRSSIRB::getData() const
-{
-  if (m_tail == m_head)
-    return m_full ? m_length : 0U;
-  else if (m_tail < m_head)
-    return m_head - m_tail;
-  else
-    return m_length - m_tail + m_head;
-}
-
-bool CRSSIRB::put(uint16_t rssi)
-{
-  if (m_full) {
-    m_overflow = true;
-    return false;
-  }
-
-  m_rssi[m_head] = rssi;
-
-  m_head++;
-  if (m_head >= m_length)
-    m_head = 0U;
-
-  if (m_head == m_tail)
-    m_full = true;
-
-  return true;
-}
-
-bool CRSSIRB::get(uint16_t& rssi)
-{
-  if (m_head == m_tail && !m_full)
-    return false;
-
-  rssi  = m_rssi[m_tail];
-
-  m_full = false;
-
-  m_tail++;
-  if (m_tail >= m_length)
-    m_tail = 0U;
-
-  return true;
-}
-
-bool CRSSIRB::hasOverflowed()
-{
-  bool overflow = m_overflow;
-
-  m_overflow = false;
-
-  return overflow;
-}
-

RSSIRB.h

@@ -1,55 +0,0 @@
-/*
-Serial fifo control - Copyright (C) KI6ZUM 2015
-Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
-
-This library is free software; you can redistribute it and/or
-modify it under the terms of the GNU Library General Public
-License as published by the Free Software Foundation; either
-version 2 of the License, or (at your option) any later version.
-
-This library 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
-Library General Public License for more details.
-
-You should have received a copy of the GNU Library General Public
-License along with this library; if not, write to the
-Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
-Boston, MA  02110-1301, USA.
-*/
-
-#if !defined(RSSIRB_H)
-#define  RSSIRB_H
-
-#if defined(STM32F4XX) || defined(STM32F4)
-#include "stm32f4xx.h"
-#include <cstddef>
-#else
-#include <Arduino.h>
-#endif
-
-class CRSSIRB {
-public:
-  CRSSIRB(uint16_t length);
-  
-  uint16_t getSpace() const;
-  
-  uint16_t getData() const;
-
-  bool put(uint16_t rssi);
-
-  bool get(uint16_t& rssi);
-
-  bool hasOverflowed();
-
-private:
-  uint16_t           m_length;
-  volatile uint16_t* m_rssi;
-  volatile uint16_t  m_head;
-  volatile uint16_t  m_tail;
-  volatile bool      m_full;
-  bool               m_overflow;
-};
-
-#endif
-

RingBuff.h

@@ -0,0 +1,47 @@
+/*
+ * 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

@@ -0,0 +1,77 @@
+/*
+ *   Copyright (C) 2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020 by Geoffrey Merck F4FXL - KC3FRA
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#if !defined(RINGBUFFER_H)
+#define  RINGBUFFER_H
+
+#if defined(STM32F4XX)
+#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)
+#define  ARM_MATH_CM3
+#elif defined(STM32F7XX)
+#define  ARM_MATH_CM7
+#elif defined(STM32F4XX) || defined(__MK20DX256__) || defined(__MK64FX512__) || defined(__MK66FX1M0__)
+#define  ARM_MATH_CM4
+#else
+#error "Unknown processor type"
+#endif
+
+#include <arm_math.h>
+
+template <typename TDATATYPE>
+class CRingBuffer {
+public:
+  CRingBuffer(uint16_t length = 370U);
+  
+  uint16_t getSpace() const;
+  
+  uint16_t getData() const;
+
+  bool put(TDATATYPE item) volatile;
+
+  bool get(TDATATYPE& item) volatile;
+
+  TDATATYPE peek() const;
+
+  bool hasOverflowed();
+
+  void reset();
+
+private:
+  uint16_t              m_length;
+  TDATATYPE*            m_buffer;
+  volatile uint16_t     m_head;
+  volatile uint16_t     m_tail;
+  volatile bool         m_full;
+  bool                  m_overflow;
+};
+
+#include "RingBuffer.impl.h"
+
+#endif

RingBuffer.impl.h

@@ -0,0 +1,114 @@
+/*
+ *   Copyright (C) 2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020 by Geoffrey Merck F4FXL - KC3FRA
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   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 "RingBuffer.h"
+
+template <typename TDATATYPE> CRingBuffer<TDATATYPE>::CRingBuffer(uint16_t length) :
+m_length(length),
+m_head(0U),
+m_tail(0U),
+m_full(false),
+m_overflow(false)
+{
+  m_buffer = new TDATATYPE[length];
+}
+
+template <typename TDATATYPE> uint16_t CRingBuffer<TDATATYPE>::getSpace() const
+{
+  uint16_t n = 0U;
+
+  if (m_tail == m_head)
+    n = m_full ? 0U : m_length;
+  else if (m_tail < m_head)
+    n = m_length - m_head + m_tail;
+  else
+    n = m_tail - m_head;
+
+  if (n > m_length)
+    n = 0U;
+
+  return n;
+}
+
+template <typename TDATATYPE> uint16_t CRingBuffer<TDATATYPE>::getData() const
+{
+  if (m_tail == m_head)
+    return m_full ? m_length : 0U;
+  else if (m_tail < m_head)
+    return m_head - m_tail;
+  else
+    return m_length - m_tail + m_head;
+}
+
+template <typename TDATATYPE> bool CRingBuffer<TDATATYPE>::put(TDATATYPE item) volatile
+{
+  if (m_full) {
+    m_overflow = true;
+    return false;
+  }
+
+  m_buffer[m_head] = item;
+
+  m_head++;
+  if (m_head >= m_length)
+    m_head = 0U;
+
+  if (m_head == m_tail)
+    m_full = true;
+
+  return true;
+}
+
+template <typename TDATATYPE> TDATATYPE CRingBuffer<TDATATYPE>::peek() const
+{
+  return m_buffer[m_tail];
+}
+
+template <typename TDATATYPE> bool CRingBuffer<TDATATYPE>::get(TDATATYPE& item) volatile
+{
+  if (m_head == m_tail && !m_full)
+    return false;
+
+  item = m_buffer[m_tail];
+
+  m_full = false;
+
+  m_tail++;
+  if (m_tail >= m_length)
+    m_tail = 0U;
+
+  return true;
+}
+
+template <typename TDATATYPE> bool CRingBuffer<TDATATYPE>::hasOverflowed()
+{
+  bool overflow = m_overflow;
+
+  m_overflow = false;
+
+  return overflow;
+}
+
+template <typename TDATATYPE> void CRingBuffer<TDATATYPE>::reset()
+{
+  m_head = 0U;
+  m_tail = 0U;
+  m_full     = false;
+  m_overflow = false;
+}

STM32Utils.h

@@ -0,0 +1,50 @@
+/*
+ *   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
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#if !defined(STM32UTILS_H)
+#define STM32UTILS_H
+
+#include <stdint.h>
+
+/* ram function */
+#define RAMFUNC __attribute__ ((long_call, section (".data")))
+/* eeprom data */
+/* for placing variables in eeprom memory */
+#define EEMEM 	__attribute__((section(".eeprom")))
+
+/* bitband type */
+typedef volatile uint32_t * const bitband_t;
+
+/* base address for bit banding */
+#define BITBAND_SRAM_REF               		(0x20000000)
+/* base address for bit banding */
+#define BITBAND_SRAM_BASE              		(0x22000000)
+/* base address for bit banding */
+#define BITBAND_PERIPH_REF               	(0x40000000)
+/* base address for bit banding */
+#define BITBAND_PERIPH_BASE              	(0x42000000)
+
+/* sram bit band */
+#define BITBAND_SRAM(address, bit)     ((void*)(BITBAND_SRAM_BASE +   \
+		(((uint32_t)address) - BITBAND_SRAM_REF) * 32 + (bit) * 4))
+
+/* periph bit band */
+#define BITBAND_PERIPH(address, bit)   ((void *)(BITBAND_PERIPH_BASE + \
+		(((uint32_t)address) - BITBAND_PERIPH_REF) * 32 + (bit) * 4))
+
+#endif

STMUART.cpp

@@ -0,0 +1,100 @@
+/*
+ *   Copyright (c) 2020 by Jonathan Naylor G4KLX
+ *   Copyright (c) 2020 by Geoffrey Merck F4FXL - KC3FRA   
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#if defined(STM32F4XX) || defined(STM32F7XX)
+
+#include "STMUART.h"
+
+CSTMUART::CSTMUART() :
+m_usart(NULL)
+{
+
+}
+
+void CSTMUART::init(USART_TypeDef* usart)
+{
+  m_usart = usart;
+}
+
+void CSTMUART::write(const uint8_t * data, uint16_t length)
+{
+  if(length == 0U || m_usart == NULL)
+    return;
+
+
+  m_txFifo.put(data[0]);
+  USART_ITConfig(m_usart, USART_IT_TXE, ENABLE);//switch TX IRQ is on
+
+  for(uint16_t i = 1U; i < length; i++) {
+    m_txFifo.put(data[i]);
+  }
+
+  USART_ITConfig(m_usart, USART_IT_TXE, ENABLE);//make sure TX IRQ is on
+}
+
+uint8_t CSTMUART::read()
+{
+  return m_rxFifo.get();
+}
+
+void CSTMUART::handleIRQ()
+{
+  if(m_usart == NULL)
+    return;
+
+  if (USART_GetITStatus(m_usart, USART_IT_RXNE)) {
+    if(!m_rxFifo.isFull())
+      m_rxFifo.put((uint8_t) USART_ReceiveData(m_usart));
+    USART_ClearITPendingBit(USART1, USART_IT_RXNE);
+  }
+
+  if (USART_GetITStatus(m_usart, USART_IT_TXE)) {
+    if(!m_txFifo.isEmpty())
+      USART_SendData(m_usart, m_txFifo.get());
+
+    USART_ClearITPendingBit(m_usart, USART_IT_TXE);
+
+    if (m_txFifo.isEmpty()) // if there's no more data to transmit then turn off TX interrupts
+      USART_ITConfig(m_usart, USART_IT_TXE, DISABLE);
+  }
+}
+
+  // Flushes the transmit shift register
+// warning: this call is blocking
+void CSTMUART::flush()
+{
+  if(m_usart == NULL)
+    return;
+
+   // wait until the TXE shows the shift register is empty
+   while (USART_GetITStatus(m_usart, USART_FLAG_TXE))
+      ;
+}
+
+uint16_t CSTMUART::available()
+{
+  return m_rxFifo.isEmpty() ? 0U : 1U;
+}
+
+uint16_t CSTMUART::availableForWrite()
+{
+  return m_txFifo.isFull() ? 0U : 1U;
+}
+
+#endif

STMUART.h

@@ -0,0 +1,91 @@
+/*
+ *   Copyright (c) 2020 by Jonathan Naylor G4KLX
+ *   Copyright (c) 2020 by Geoffrey Merck F4FXL - KC3FRA   
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#if defined(STM32F4XX) || defined(STM32F7XX)
+#if !defined(STMUART_H)
+#define STMUART_H
+
+#if defined(STM32F4XX)
+#include "stm32f4xx.h"
+#elif defined(STM32F7XX)
+#include "stm32f7xx.h"
+#endif
+
+const uint16_t BUFFER_SIZE = 2048U; //needs to be a power of 2 !
+const uint16_t BUFFER_MASK = BUFFER_SIZE - 1;
+
+class CSTMUARTFIFO {
+public:
+  CSTMUARTFIFO() :
+  m_head(0U),
+  m_tail(0U)
+  {
+  }
+
+  void put(uint8_t data)
+  {
+    m_buffer[BUFFER_MASK & (m_head++)] = data;
+  }
+
+  uint8_t get()
+  {
+    return m_buffer[BUFFER_MASK & (m_tail++)];
+  }
+
+  void reset()
+  {
+    m_tail = 0U;
+    m_head = 0U;
+  }
+
+  bool isEmpty()
+  {
+    return m_tail == m_head;
+  }
+
+  bool isFull()
+  {
+    return ((m_head + 1U) & BUFFER_MASK) == (m_tail & BUFFER_MASK);
+  }
+
+private:
+  volatile uint8_t  m_buffer[BUFFER_SIZE];
+  volatile uint16_t m_head;
+  volatile uint16_t m_tail;
+};
+
+class CSTMUART {
+public:
+  CSTMUART();
+  void init(USART_TypeDef* usart);
+  void write(const uint8_t * data, uint16_t length);
+  uint8_t read();
+  void handleIRQ();
+  void flush();
+  uint16_t available();
+  uint16_t availableForWrite();
+
+private:
+  USART_TypeDef * m_usart;
+  CSTMUARTFIFO    m_rxFifo;
+  CSTMUARTFIFO    m_txFifo;
+};
+
+#endif
+#endif

SampleRB.cpp

@@ -1,108 +0,0 @@
-/*
-TX fifo control - Copyright (C) KI6ZUM 2015
-Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
-
-This library is free software; you can redistribute it and/or
-modify it under the terms of the GNU Library General Public
-License as published by the Free Software Foundation; either
-version 2 of the License, or (at your option) any later version.
-
-This library 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
-Library General Public License for more details.
-
-You should have received a copy of the GNU Library General Public
-License along with this library; if not, write to the
-Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
-Boston, MA  02110-1301, USA.
-*/
-
-#include "SampleRB.h"
-
-CSampleRB::CSampleRB(uint16_t length) :
-m_length(length),
-m_samples(NULL),
-m_control(NULL),
-m_head(0U),
-m_tail(0U),
-m_full(false),
-m_overflow(false)
-{
-  m_samples = new uint16_t[length];
-  m_control = new uint8_t[length];
-}
-
-uint16_t CSampleRB::getSpace() const
-{
-  uint16_t n = 0U;
-
-  if (m_tail == m_head)
-    n = m_full ? 0U : m_length;
-  else if (m_tail < m_head)
-    n = m_length - m_head + m_tail;
-  else
-    n = m_tail - m_head;
-
-  if (n > m_length)
-    n = 0U;
-
-  return n;
-}
-
-uint16_t CSampleRB::getData() const
-{
-  if (m_tail == m_head)
-    return m_full ? m_length : 0U;
-  else if (m_tail < m_head)
-    return m_head - m_tail;
-  else
-    return m_length - m_tail + m_head;
-}
-
-bool CSampleRB::put(uint16_t sample, uint8_t control)
-{
-  if (m_full) {
-    m_overflow = true;
-    return false;
-  }
-
-  m_samples[m_head] = sample;
-  m_control[m_head] = control;
-
-  m_head++;
-  if (m_head >= m_length)
-    m_head = 0U;
-
-  if (m_head == m_tail)
-    m_full = true;
-
-  return true;
-}
-
-bool CSampleRB::get(uint16_t& sample, uint8_t& control)
-{
-  if (m_head == m_tail && !m_full)
-    return false;
-
-  sample  = m_samples[m_tail];
-  control = m_control[m_tail];
-
-  m_full = false;
-
-  m_tail++;
-  if (m_tail >= m_length)
-    m_tail = 0U;
-
-  return true;
-}
-
-bool CSampleRB::hasOverflowed()
-{
-  bool overflow = m_overflow;
-
-  m_overflow = false;
-
-  return overflow;
-}
-

SampleRB.h

@@ -1,56 +0,0 @@
-/*
-Serial fifo control - Copyright (C) KI6ZUM 2015
-Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
-
-This library is free software; you can redistribute it and/or
-modify it under the terms of the GNU Library General Public
-License as published by the Free Software Foundation; either
-version 2 of the License, or (at your option) any later version.
-
-This library 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
-Library General Public License for more details.
-
-You should have received a copy of the GNU Library General Public
-License along with this library; if not, write to the
-Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
-Boston, MA  02110-1301, USA.
-*/
-
-#if !defined(SAMPLERB_H)
-#define  SAMPLERB_H
-
-#if defined(STM32F4XX) || defined(STM32F4)
-#include "stm32f4xx.h"
-#include <cstddef>
-#else
-#include <Arduino.h>
-#endif
-
-class CSampleRB {
-public:
-  CSampleRB(uint16_t length);
-  
-  uint16_t getSpace() const;
-  
-  uint16_t getData() const;
-
-  bool put(uint16_t sample, uint8_t control);
-
-  bool get(uint16_t& sample, uint8_t& control);
-
-  bool hasOverflowed();
-
-private:
-  uint16_t           m_length;
-  volatile uint16_t* m_samples;
-  volatile uint8_t*  m_control;
-  volatile uint16_t  m_head;
-  volatile uint16_t  m_tail;
-  volatile bool      m_full;
-  bool               m_overflow;
-};
-
-#endif
-

SerialArduino.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2016,2017 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
@@ -21,7 +21,10 @@
 
 #include "SerialPort.h"
 
-#if defined(__SAM3X8E__) || defined(__MK20DX256__) || defined(__MK64FX512__) || defined(__MK66FX1M0__)
+#if defined(VK6MST_TEENSY_PI3_SHIELD_I2C)
+//it will load I2CTeensy.cpp
+
+#elif defined(__SAM3X8E__) || defined(__MK20DX256__) || defined(__MK64FX512__) || defined(__MK66FX1M0__)
 
 void CSerialPort::beginInt(uint8_t n, int speed)
 {
@@ -54,6 +57,20 @@ int CSerialPort::availableInt(uint8_t n)
   }
 }
 
+int CSerialPort::availableForWriteInt(uint8_t n)
+{
+  switch (n) {
+    case 1U:
+      return Serial.availableForWrite();
+    case 2U:
+      return Serial2.availableForWrite();
+    case 3U:
+      return Serial3.availableForWrite();
+    default:
+      return false;
+  }
+}
+
 uint8_t CSerialPort::readInt(uint8_t n)
 {
   switch (n) {

SerialPort.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2013,2015,2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2013,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,11 +17,14 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-// #define  WANT_DEBUG
-
 #include "Config.h"
 #include "Globals.h"
 
+#if defined(MADEBYMAKEFILE)
+#include "GitVersion.h"
+#endif
+
+
 #include "SerialPort.h"
 
 const uint8_t MMDVM_FRAME_START  = 0xE0U;
@@ -33,6 +36,7 @@ const uint8_t MMDVM_SET_MODE     = 0x03U;
 const uint8_t MMDVM_SET_FREQ     = 0x04U;
 
 const uint8_t MMDVM_CAL_DATA     = 0x08U;
+const uint8_t MMDVM_RSSI_DATA    = 0x09U;
 
 const uint8_t MMDVM_SEND_CWID    = 0x0AU;
 
@@ -56,21 +60,61 @@ const uint8_t MMDVM_P25_HDR      = 0x30U;
 const uint8_t MMDVM_P25_LDU      = 0x31U;
 const uint8_t MMDVM_P25_LOST     = 0x32U;
 
+const uint8_t MMDVM_NXDN_DATA    = 0x40U;
+const uint8_t MMDVM_NXDN_LOST    = 0x41U;
+
+const uint8_t MMDVM_POCSAG_DATA  = 0x50U;
+
+const uint8_t MMDVM_FM_PARAMS1   = 0x60U;
+const uint8_t MMDVM_FM_PARAMS2   = 0x61U;
+const uint8_t MMDVM_FM_PARAMS3   = 0x62U;
+const uint8_t MMDVM_FM_PARAMS4   = 0x63U;
+const uint8_t MMDVM_FM_DATA      = 0x65U;
+const uint8_t MMDVM_FM_STATUS    = 0x66U;
+const uint8_t MMDVM_FM_EOT       = 0x67U;
+
 const uint8_t MMDVM_ACK          = 0x70U;
 const uint8_t MMDVM_NAK          = 0x7FU;
 
 const uint8_t MMDVM_SERIAL       = 0x80U;
 
+const uint8_t MMDVM_TRANSPARENT  = 0x90U;
+const uint8_t MMDVM_QSO_INFO     = 0x91U;
+
 const uint8_t MMDVM_DEBUG1       = 0xF1U;
 const uint8_t MMDVM_DEBUG2       = 0xF2U;
 const uint8_t MMDVM_DEBUG3       = 0xF3U;
 const uint8_t MMDVM_DEBUG4       = 0xF4U;
 const uint8_t MMDVM_DEBUG5       = 0xF5U;
 
-#if defined(EXTERNAL_OSC)
-const uint8_t HARDWARE[]         = "MMDVM 20161124 TCXO (D-Star/DMR/System Fusion/P25/CW Id)";
+#if EXTERNAL_OSC == 12000000
+#define TCXO "12.0000 MHz"
+#elif EXTERNAL_OSC == 12288000
+#define TCXO "12.2880 MHz"
+#elif EXTERNAL_OSC == 14400000
+#define TCXO "14.4000 MHz"
+#elif EXTERNAL_OSC == 19200000
+#define TCXO "19.2000 Mhz"
 #else
-const uint8_t HARDWARE[]         = "MMDVM 20161124 (D-Star/DMR/System Fusion/P25/CW Id)";
+#define TCXO "NO TCXO"
+#endif
+
+#if defined(DRCC_DVM_NQF)
+#define	HW_TYPE	"MMDVM DRCC_DVM_NQF"
+#elif defined(STM32F4_RPT_HAT_TGO)
+#define	HW_TYPE	"MMDVM RPT_HAT_TGO"
+#else
+#define	HW_TYPE	"MMDVM"
+#endif
+
+#define DESCRIPTION "20200620 (D-Star/DMR/System Fusion/P25/NXDN/POCSAG/FM)"
+
+#if defined(GITVERSION)
+#define concat(h, a, b, c) h " " a " " b " GitID #" c ""
+const char HARDWARE[] = concat(HW_TYPE, DESCRIPTION, TCXO, GITVERSION);
+#else
+#define concat(h, a, b, c, d) h " " a " " b " (Build: " c " " d ")"
+const char HARDWARE[] = concat(HW_TYPE, DESCRIPTION, TCXO, __TIME__, __DATE__);
 #endif
 
 const uint8_t PROTOCOL_VERSION   = 1U;
@@ -79,7 +123,9 @@ const uint8_t PROTOCOL_VERSION   = 1U;
 CSerialPort::CSerialPort() :
 m_buffer(),
 m_ptr(0U),
-m_len(0U)
+m_len(0U),
+m_debug(false),
+m_repeat()
 {
 }
 
@@ -112,11 +158,11 @@ void CSerialPort::getStatus()
 {
   io.resetWatchdog();
 
-  uint8_t reply[15U];
+  uint8_t reply[20U];
 
   // Send all sorts of interesting internal values
   reply[0U]  = MMDVM_FRAME_START;
-  reply[1U]  = 11U;
+  reply[1U]  = 14U;
   reply[2U]  = MMDVM_GET_STATUS;
 
   reply[3U]  = 0x00U;
@@ -128,6 +174,12 @@ void CSerialPort::getStatus()
     reply[3U] |= 0x04U;
   if (m_p25Enable)
     reply[3U] |= 0x08U;
+  if (m_nxdnEnable)
+    reply[3U] |= 0x10U;
+  if (m_pocsagEnable)
+    reply[3U] |= 0x20U;
+  if (m_fmEnable)
+    reply[3U] |= 0x40U;
 
   reply[4U]  = uint8_t(m_modemState);
 
@@ -182,12 +234,27 @@ void CSerialPort::getStatus()
   else
     reply[10U] = 0U;
 
-  writeInt(1U, reply, 11);
+  if (m_nxdnEnable)
+    reply[11U] = nxdnTX.getSpace();
+  else
+    reply[11U] = 0U;
+
+  if (m_pocsagEnable)
+    reply[12U] = pocsagTX.getSpace();
+  else
+    reply[12U] = 0U;
+
+  if (m_fmEnable)
+    reply[13U] = fm.getSpace();
+  else
+    reply[13U] = 0U;
+
+  writeInt(1U, reply, 14);
 }
 
 void CSerialPort::getVersion()
 {
-  uint8_t reply[100U];
+  uint8_t reply[150U];
 
   reply[0U] = MMDVM_FRAME_START;
   reply[1U] = 0U;
@@ -206,18 +273,24 @@ void CSerialPort::getVersion()
 
 uint8_t CSerialPort::setConfig(const uint8_t* data, uint8_t length)
 {
-  if (length < 13U)
+  if (length < 21U)
     return 4U;
 
   bool rxInvert  = (data[0U] & 0x01U) == 0x01U;
   bool txInvert  = (data[0U] & 0x02U) == 0x02U;
   bool pttInvert = (data[0U] & 0x04U) == 0x04U;
+  bool ysfLoDev  = (data[0U] & 0x08U) == 0x08U;
   bool simplex   = (data[0U] & 0x80U) == 0x80U;
 
-  bool dstarEnable = (data[1U] & 0x01U) == 0x01U;
-  bool dmrEnable   = (data[1U] & 0x02U) == 0x02U;
-  bool ysfEnable   = (data[1U] & 0x04U) == 0x04U;
-  bool p25Enable   = (data[1U] & 0x08U) == 0x08U;
+  m_debug = (data[0U] & 0x10U) == 0x10U;
+
+  bool dstarEnable  = (data[1U] & 0x01U) == 0x01U;
+  bool dmrEnable    = (data[1U] & 0x02U) == 0x02U;
+  bool ysfEnable    = (data[1U] & 0x04U) == 0x04U;
+  bool p25Enable    = (data[1U] & 0x08U) == 0x08U;
+  bool nxdnEnable   = (data[1U] & 0x10U) == 0x10U;
+  bool pocsagEnable = (data[1U] & 0x20U) == 0x20U;
+  bool fmEnable     = (data[1U] & 0x40U) == 0x40U;
 
   uint8_t txDelay = data[2U];
   if (txDelay > 50U)
@@ -225,7 +298,7 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint8_t length)
 
   MMDVM_STATE modemState = MMDVM_STATE(data[3U]);
 
-  if (modemState != STATE_IDLE && modemState != STATE_DSTAR && modemState != STATE_DMR && modemState != STATE_YSF && modemState != STATE_P25 && modemState != STATE_DSTARCAL && modemState != STATE_DMRCAL)
+  if (modemState != STATE_IDLE && modemState != STATE_DSTAR && modemState != STATE_DMR && modemState != STATE_YSF && modemState != STATE_P25 && modemState != STATE_NXDN && modemState != STATE_POCSAG && modemState != STATE_FM && modemState != STATE_DSTARCAL && modemState != STATE_DMRCAL && modemState != STATE_RSSICAL && modemState != STATE_LFCAL && modemState != STATE_DMRCAL1K && modemState != STATE_P25CAL1K && modemState != STATE_DMRDMO1K && modemState != STATE_NXDNCAL1K && modemState != STATE_POCSAGCAL && modemState != STATE_FMCAL10K && modemState != STATE_FMCAL12K && modemState != STATE_FMCAL15K && modemState != STATE_FMCAL20K && modemState != STATE_FMCAL25K && modemState != STATE_FMCAL30K)
     return 4U;
   if (modemState == STATE_DSTAR && !dstarEnable)
     return 4U;
@@ -235,6 +308,12 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint8_t length)
     return 4U;
   if (modemState == STATE_P25 && !p25Enable)
     return 4U;
+  if (modemState == STATE_NXDN && !nxdnEnable)
+    return 4U;
+  if (modemState == STATE_POCSAG && !pocsagEnable)
+    return 4U;
+  if (modemState == STATE_FM && !fmEnable)
+    return 4U;
 
   uint8_t rxLevel = data[4U];
 
@@ -244,36 +323,44 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint8_t length)
 
   uint8_t dmrDelay = data[7U];
 
-  int8_t oscOffset = int8_t(data[8U]) - 128;
-  if (oscOffset < 0) {
-    m_sampleCount = 1000000U / uint32_t(-oscOffset);
-    m_sampleInsert = false;
-  } else if (oscOffset > 0) {
-    m_sampleCount = 1000000U / uint32_t(oscOffset);
-    m_sampleInsert = true;
-  } else {
-    m_sampleCount = 0U;
-    m_sampleInsert = false;
-  }
-
   uint8_t cwIdTXLevel  = data[5U];
   uint8_t dstarTXLevel = data[9U];
   uint8_t dmrTXLevel   = data[10U];
   uint8_t ysfTXLevel   = data[11U];
   uint8_t p25TXLevel   = data[12U];
 
-  m_modemState  = modemState;
+  int16_t txDCOffset = int16_t(data[13U]) - 128;
+  int16_t rxDCOffset = int16_t(data[14U]) - 128;
 
-  m_dstarEnable = dstarEnable;
-  m_dmrEnable   = dmrEnable;
-  m_ysfEnable   = ysfEnable;
-  m_p25Enable   = p25Enable;
-  m_duplex      = !simplex;
+  uint8_t nxdnTXLevel   = data[15U];
+
+  uint8_t ysfTXHang     = data[16U];
+
+  uint8_t pocsagTXLevel = data[17U];
+
+  uint8_t fmTXLevel     = data[18U];
+
+  uint8_t p25TXHang     = data[19U];
+
+  uint8_t nxdnTXHang    = data[20U];
+
+  setMode(modemState);
+
+  m_dstarEnable  = dstarEnable;
+  m_dmrEnable    = dmrEnable;
+  m_ysfEnable    = ysfEnable;
+  m_p25Enable    = p25Enable;
+  m_nxdnEnable   = nxdnEnable;
+  m_pocsagEnable = pocsagEnable;
+  m_fmEnable     = fmEnable;
+  m_duplex       = !simplex;
 
   dstarTX.setTXDelay(txDelay);
   ysfTX.setTXDelay(txDelay);
   p25TX.setTXDelay(txDelay);
   dmrDMOTX.setTXDelay(txDelay);
+  nxdnTX.setTXDelay(txDelay);
+  pocsagTX.setTXDelay(txDelay);
 
   dmrTX.setColorCode(colorCode);
   dmrRX.setColorCode(colorCode);
@@ -281,13 +368,108 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint8_t length)
   dmrDMORX.setColorCode(colorCode);
   dmrIdleRX.setColorCode(colorCode);
 
-  io.setParameters(rxInvert, txInvert, pttInvert, rxLevel, cwIdTXLevel, dstarTXLevel, dmrTXLevel, ysfTXLevel, p25TXLevel);
+  ysfTX.setParams(ysfLoDev, ysfTXHang);
+  p25TX.setParams(p25TXHang);
+  nxdnTX.setParams(nxdnTXHang);
+
+  io.setParameters(rxInvert, txInvert, pttInvert, rxLevel, cwIdTXLevel, dstarTXLevel, dmrTXLevel, ysfTXLevel, p25TXLevel, nxdnTXLevel, pocsagTXLevel, fmTXLevel, txDCOffset, rxDCOffset);
 
   io.start();
 
   return 0U;
 }
 
+uint8_t CSerialPort::setFMParams1(const uint8_t* data, uint8_t length)
+{
+  if (length < 8U)
+    return 4U;
+
+  uint8_t  speed     = data[0U];;
+  uint16_t frequency = data[1U] * 10U;
+  uint8_t  time      = data[2U];
+  uint8_t  holdoff   = data[3U];
+  uint8_t  highLevel = data[4U];
+  uint8_t  lowLevel  = data[5U];
+
+  bool callAtStart = (data[6U] & 0x01U) == 0x01U;
+  bool callAtEnd   = (data[6U] & 0x02U) == 0x02U;
+  bool callAtLatch = (data[6U] & 0x04U) == 0x04U;
+
+  char callsign[50U];
+  uint8_t n = 0U;
+  for (uint8_t i = 7U; i < length; i++, n++)
+    callsign[n] = data[i];
+  callsign[n] = '\0';
+
+  return fm.setCallsign(callsign, speed, frequency, time, holdoff, highLevel, lowLevel, callAtStart, callAtEnd, callAtLatch);
+}
+
+uint8_t CSerialPort::setFMParams2(const uint8_t* data, uint8_t length)
+{
+  if (length < 6U)
+    return 4U;
+
+  uint8_t  speed     = data[0U];
+  uint16_t frequency = data[1U] * 10U;
+  uint8_t  minTime   = data[2U];
+  uint16_t delay     = data[3U] * 10U;
+  uint8_t  level     = data[4U];
+
+  char ack[50U];
+  uint8_t n = 0U;
+  for (uint8_t i = 5U; i < length; i++, n++)
+    ack[n] = data[i];
+  ack[n] = '\0';
+
+  return fm.setAck(ack, speed, frequency, minTime, delay, level);
+}
+
+uint8_t CSerialPort::setFMParams3(const uint8_t* data, uint8_t length)
+{
+  if (length < 12U)
+    return 4U;
+
+  uint16_t timeout        = data[0U] * 5U;
+  uint8_t  timeoutLevel   = data[1U];
+
+  uint8_t  ctcssFrequency     = data[2U];
+  uint8_t  ctcssHighThreshold = data[3U];
+  uint8_t  ctcssLowThreshold  = data[4U];
+  uint8_t  ctcssLevel         = data[5U];
+
+  uint8_t  kerchunkTime   = data[6U];
+  uint8_t  hangTime       = data[7U];
+
+  bool     useCOS         = (data[8U] & 0x01U) == 0x01U;
+  bool     cosInvert      = (data[8U] & 0x02U) == 0x02U;
+  bool     kerchunkTX     = (data[8U] & 0x04U) == 0x04U;
+
+  uint8_t  rfAudioBoost   = data[9U];
+  uint8_t  maxDev         = data[10U];
+  uint8_t  rxLevel        = data[11U];
+
+  return fm.setMisc(timeout, timeoutLevel, ctcssFrequency, ctcssHighThreshold, ctcssLowThreshold, ctcssLevel, kerchunkTime, kerchunkTX, hangTime, useCOS, cosInvert, rfAudioBoost, maxDev, rxLevel);
+}
+
+uint8_t CSerialPort::setFMParams4(const uint8_t* data, uint8_t length)
+{
+  if (length < 4U)
+    return 4U;
+
+  uint8_t  audioBoost = data[0U];
+  uint8_t  speed      = data[1U];
+  uint16_t frequency  = data[2U] * 10U;
+  uint8_t  level      = data[3U];
+
+  char ack[50U];
+  uint8_t n = 0U;
+  for (uint8_t i = 4U; i < length; i++, n++)
+    ack[n] = data[i];
+  ack[n] = '\0';
+
+  return fm.setExt(ack, audioBoost, speed, frequency, level);
+}
+
 uint8_t CSerialPort::setMode(const uint8_t* data, uint8_t length)
 {
   if (length < 1U)
@@ -298,7 +480,7 @@ uint8_t CSerialPort::setMode(const uint8_t* data, uint8_t length)
   if (modemState == m_modemState)
     return 0U;
 
-  if (modemState != STATE_IDLE && modemState != STATE_DSTAR && modemState != STATE_DMR && modemState != STATE_YSF && modemState != STATE_P25 && modemState != STATE_DSTARCAL && modemState != STATE_DMRCAL)
+  if (modemState != STATE_IDLE && modemState != STATE_DSTAR && modemState != STATE_DMR && modemState != STATE_YSF && modemState != STATE_P25 && modemState != STATE_NXDN && modemState != STATE_POCSAG && modemState != STATE_FM && modemState != STATE_DSTARCAL && modemState != STATE_DMRCAL && modemState != STATE_RSSICAL && modemState != STATE_LFCAL && modemState != STATE_DMRCAL1K && modemState != STATE_P25CAL1K && modemState != STATE_DMRDMO1K && modemState != STATE_NXDNCAL1K && modemState != STATE_POCSAGCAL && modemState != STATE_FMCAL10K  && modemState != STATE_FMCAL12K && modemState != STATE_FMCAL15K && modemState != STATE_FMCAL20K && modemState != STATE_FMCAL25K && modemState != STATE_FMCAL30K)
     return 4U;
   if (modemState == STATE_DSTAR && !m_dstarEnable)
     return 4U;
@@ -308,6 +490,12 @@ uint8_t CSerialPort::setMode(const uint8_t* data, uint8_t length)
     return 4U;
   if (modemState == STATE_P25 && !m_p25Enable)
     return 4U;
+  if (modemState == STATE_NXDN && !m_nxdnEnable)
+    return 4U;
+  if (modemState == STATE_POCSAG && !m_pocsagEnable)
+    return 4U;
+  if (modemState == STATE_FM && !m_fmEnable)
+    return 4U;
 
   setMode(modemState);
 
@@ -319,64 +507,95 @@ void CSerialPort::setMode(MMDVM_STATE modemState)
   switch (modemState) {
     case STATE_DMR:
       DEBUG1("Mode set to DMR");
-      dstarRX.reset();
-      ysfRX.reset();
-      p25RX.reset();
-      cwIdTX.reset();
       break;
     case STATE_DSTAR:
       DEBUG1("Mode set to D-Star");
-      dmrIdleRX.reset();
-      dmrDMORX.reset();
-      dmrRX.reset();
-      ysfRX.reset();
-      p25RX.reset();
-      cwIdTX.reset();
       break;
     case STATE_YSF:
       DEBUG1("Mode set to System Fusion");
-      dmrIdleRX.reset();
-      dmrDMORX.reset();
-      dmrRX.reset();
-      dstarRX.reset();
-      p25RX.reset();
-      cwIdTX.reset();
       break;
     case STATE_P25:
       DEBUG1("Mode set to P25");
-      dmrIdleRX.reset();
-      dmrDMORX.reset();
-      dmrRX.reset();
-      dstarRX.reset();
-      ysfRX.reset();
-      cwIdTX.reset();
+      break;
+    case STATE_NXDN:
+      DEBUG1("Mode set to NXDN");
+      break;
+    case STATE_POCSAG:
+      DEBUG1("Mode set to POCSAG");
+      break;
+    case STATE_FM:
+      DEBUG1("Mode set to FM");
       break;
     case STATE_DSTARCAL:
       DEBUG1("Mode set to D-Star Calibrate");
-      dmrIdleRX.reset();
-      dmrDMORX.reset();
-      dmrRX.reset();
-      dstarRX.reset();
-      ysfRX.reset();
-      p25RX.reset();
-      cwIdTX.reset();
       break;
     case STATE_DMRCAL:
       DEBUG1("Mode set to DMR Calibrate");
-      dmrIdleRX.reset();
-      dmrDMORX.reset();
-      dmrRX.reset();
-      dstarRX.reset();
-      ysfRX.reset();
-      p25RX.reset();
-      cwIdTX.reset();
       break;
-    default:
+    case STATE_RSSICAL:
+      DEBUG1("Mode set to RSSI Calibrate");
+      break;
+    case STATE_LFCAL:
+      DEBUG1("Mode set to 80 Hz Calibrate");
+      break;
+    case STATE_FMCAL10K:
+      DEBUG1("Mode set to FM 10Khz Calibrate");
+      break;
+    case STATE_FMCAL12K:
+      DEBUG1("Mode set to FM 12.5Khz Calibrate");
+      break;
+    case STATE_FMCAL15K:
+      DEBUG1("Mode set to FM 15Khz Calibrate");
+      break;
+    case STATE_FMCAL20K:
+      DEBUG1("Mode set to FM 20Khz Calibrate");
+      break;
+    case STATE_FMCAL25K:
+      DEBUG1("Mode set to FM 10Khz Calibrate");
+      break;
+    case STATE_FMCAL30K:
+      DEBUG1("Mode set to FM 30Khz Calibrate");
+      break;
+    case STATE_P25CAL1K:
+      DEBUG1("Mode set to P25 1011 Hz Calibrate");
+      break;
+    case STATE_DMRDMO1K:
+      DEBUG1("Mode set to DMR MS 1031 Hz Calibrate");
+      break;
+    case STATE_NXDNCAL1K:
+      DEBUG1("Mode set to NXDN 1031 Hz Calibrate");
+      break;
+    case STATE_POCSAGCAL:
+      DEBUG1("Mode set to POCSAG Calibrate");
+      break;
+    default:        // STATE_IDLE
       DEBUG1("Mode set to Idle");
-      // STATE_IDLE
       break;
   }
 
+  if (modemState != STATE_DSTAR)
+    dstarRX.reset();
+
+  if (modemState != STATE_DMR) {
+    dmrIdleRX.reset();
+    dmrDMORX.reset();
+    dmrRX.reset();
+  }
+
+  if (modemState != STATE_YSF)
+    ysfRX.reset();
+
+  if (modemState != STATE_P25)
+    p25RX.reset();
+
+  if (modemState != STATE_NXDN)
+    nxdnRX.reset();
+
+  if (modemState != STATE_FM)
+    fm.reset();
+
+  cwIdTX.reset();
+
   m_modemState = modemState;
 
   io.setMode();
@@ -384,7 +603,7 @@ void CSerialPort::setMode(MMDVM_STATE modemState)
 
 void CSerialPort::start()
 {
-  beginInt(1U, 115200);
+  beginInt(1U, SERIAL_SPEED);
 
 #if defined(SERIAL_REPEATER)
   beginInt(3U, 9600);
@@ -403,6 +622,10 @@ void CSerialPort::process()
         m_ptr = 1U;
         m_len = 0U;
       }
+      else {
+        m_ptr = 0U;
+        m_len = 0U;
+      }
     } else if (m_ptr == 1U) {
       // Handle the frame length
       m_len = m_buffer[m_ptr] = c;
@@ -445,11 +668,59 @@ void CSerialPort::process()
             sendACK();
             break;
 
+          case MMDVM_FM_PARAMS1:
+            err = setFMParams1(m_buffer + 3U, m_len - 3U);
+            if (err == 0U) {
+              sendACK();
+            } else {
+              DEBUG2("Received invalid FM params 1", err);
+              sendNAK(err);
+            }
+            break;
+
+          case MMDVM_FM_PARAMS2:
+            err = setFMParams2(m_buffer + 3U, m_len - 3U);
+            if (err == 0U) {
+              sendACK();
+            } else {
+              DEBUG2("Received invalid FM params 2", err);
+              sendNAK(err);
+            }
+            break;
+
+          case MMDVM_FM_PARAMS3:
+            err = setFMParams3(m_buffer + 3U, m_len - 3U);
+            if (err == 0U) {
+              sendACK();
+            } else {
+              DEBUG2("Received invalid FM params 3", err);
+              sendNAK(err);
+            }
+            break;
+
+          case MMDVM_FM_PARAMS4:
+            err = setFMParams4(m_buffer + 3U, m_len - 3U);
+            if (err == 0U) {
+              sendACK();
+            } else {
+              DEBUG2("Received invalid FM params 4", err);
+              sendNAK(err);
+            }
+            break;
+
           case MMDVM_CAL_DATA:
             if (m_modemState == STATE_DSTARCAL)
               err = calDStarTX.write(m_buffer + 3U, m_len - 3U);
-            if (m_modemState == STATE_DMRCAL)
+            if (m_modemState == STATE_DMRCAL || m_modemState == STATE_LFCAL || m_modemState == STATE_DMRCAL1K || m_modemState == STATE_DMRDMO1K)
               err = calDMR.write(m_buffer + 3U, m_len - 3U);
+            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)
+              err = calFM.write(m_buffer + 3U, m_len - 3U);
+            if (m_modemState == STATE_P25CAL1K)
+              err = calP25.write(m_buffer + 3U, m_len - 3U);
+            if (m_modemState == STATE_NXDNCAL1K)
+              err = calNXDN.write(m_buffer + 3U, m_len - 3U);
+            if (m_modemState == STATE_POCSAGCAL)
+              err = calPOCSAG.write(m_buffer + 3U, m_len - 3U);
             if (err == 0U) {
               sendACK();
             } else {
@@ -625,9 +896,58 @@ void CSerialPort::process()
             }
             break;
 
+          case MMDVM_NXDN_DATA:
+            if (m_nxdnEnable) {
+              if (m_modemState == STATE_IDLE || m_modemState == STATE_NXDN)
+                err = nxdnTX.writeData(m_buffer + 3U, m_len - 3U);
+            }
+            if (err == 0U) {
+              if (m_modemState == STATE_IDLE)
+                setMode(STATE_NXDN);
+            } else {
+              DEBUG2("Received invalid NXDN data", err);
+              sendNAK(err);
+            }
+            break;
+
+          case MMDVM_POCSAG_DATA:
+            if (m_pocsagEnable) {
+              if (m_modemState == STATE_IDLE || m_modemState == STATE_POCSAG)
+                err = pocsagTX.writeData(m_buffer + 3U, m_len - 3U);
+            }
+            if (err == 0U) {
+              if (m_modemState == STATE_IDLE)
+                setMode(STATE_POCSAG);
+            } else {
+              DEBUG2("Received invalid POCSAG data", err);
+              sendNAK(err);
+            }
+            break;
+
+          case MMDVM_FM_DATA:
+            if (m_fmEnable) {
+              if (m_modemState == STATE_IDLE || m_modemState == STATE_FM)
+                err = fm.writeData(m_buffer + 3U, m_len - 3U);
+            }
+            if (err == 0U) {
+              if (m_modemState == STATE_IDLE)
+                setMode(STATE_FM);
+            } else {
+              DEBUG2("Received invalid FM data", err);
+              sendNAK(err);
+            }
+            break;
+
+          case MMDVM_TRANSPARENT:
+          case MMDVM_QSO_INFO:
+            // Do nothing on the MMDVM.
+            break;
+
 #if defined(SERIAL_REPEATER)
-          case MMDVM_SERIAL:
-            writeInt(3U, m_buffer + 3U, m_len - 3U);
+          case MMDVM_SERIAL: {
+            for (uint8_t i = 3U; i < m_len; i++)
+              m_repeat.put(m_buffer[i]);
+            }
             break;
 #endif
 
@@ -643,8 +963,26 @@ void CSerialPort::process()
     }
   }
 
+  if (io.getWatchdog() >= 48000U) {
+    m_ptr = 0U;
+    m_len = 0U;
+  }
+
 #if defined(SERIAL_REPEATER)
-  // Drain any incoming serial data
+  // Write any outgoing serial data
+  uint16_t space = m_repeat.getData();
+  if (space > 0U) {
+    int avail = availableForWriteInt(3U);
+    if (avail < space)
+      space = avail;
+
+    for (uint16_t i = 0U; i < space; i++) {
+      uint8_t c = m_repeat.get();
+      writeInt(3U, &c, 1U);
+    }
+  }
+
+  // Read any incoming serial data
   while (availableInt(3U))
     readInt(3U);
 #endif
@@ -872,6 +1210,104 @@ void CSerialPort::writeP25Lost()
   writeInt(1U, reply, 3);
 }
 
+void CSerialPort::writeNXDNData(const uint8_t* data, uint8_t length)
+{
+  if (m_modemState != STATE_NXDN && m_modemState != STATE_IDLE)
+    return;
+
+  if (!m_nxdnEnable)
+    return;
+
+  uint8_t reply[130U];
+
+  reply[0U] = MMDVM_FRAME_START;
+  reply[1U] = 0U;
+  reply[2U] = MMDVM_NXDN_DATA;
+
+  uint8_t count = 3U;
+  for (uint8_t i = 0U; i < length; i++, count++)
+    reply[count] = data[i];
+
+  reply[1U] = count;
+
+  writeInt(1U, reply, count);
+}
+
+void CSerialPort::writeNXDNLost()
+{
+  if (m_modemState != STATE_NXDN && m_modemState != STATE_IDLE)
+    return;
+
+  if (!m_nxdnEnable)
+    return;
+
+  uint8_t reply[3U];
+
+  reply[0U] = MMDVM_FRAME_START;
+  reply[1U] = 3U;
+  reply[2U] = MMDVM_NXDN_LOST;
+
+  writeInt(1U, reply, 3);
+}
+
+void CSerialPort::writeFMData(const uint8_t* data, uint8_t length)
+{
+  if (m_modemState != STATE_FM && m_modemState != STATE_IDLE)
+    return;
+
+  if (!m_fmEnable)
+    return;
+
+  uint8_t reply[255U];
+
+  reply[0U] = MMDVM_FRAME_START;
+  reply[1U] = 0U;
+  reply[2U] = MMDVM_FM_DATA;
+
+  uint8_t count = 3U;
+  for (uint8_t i = 0U; i < length; i++, count++)
+    reply[count] = data[i];
+
+  reply[1U] = count;
+
+  writeInt(1U, reply, count);
+}
+
+void CSerialPort::writeFMStatus(uint8_t status)
+{
+  if (m_modemState != STATE_FM && m_modemState != STATE_IDLE)
+    return;
+
+  if (!m_fmEnable)
+    return;
+
+  uint8_t reply[10U];
+
+  reply[0U] = MMDVM_FRAME_START;
+  reply[1U] = 4U;
+  reply[2U] = MMDVM_FM_STATUS;
+  reply[3U] = status;
+
+  writeInt(1U, reply, 4U);
+}
+
+void CSerialPort::writeFMEOT()
+{
+  if (m_modemState != STATE_FM && m_modemState != STATE_IDLE)
+    return;
+
+  if (!m_fmEnable)
+    return;
+
+  uint8_t reply[10U];
+
+  reply[0U] = MMDVM_FRAME_START;
+  reply[1U] = 3U;
+  reply[2U] = MMDVM_FM_EOT;
+
+  writeInt(1U, reply, 3U);
+}
+
 void CSerialPort::writeCalData(const uint8_t* data, uint8_t length)
 {
   if (m_modemState != STATE_DSTARCAL)
@@ -892,8 +1328,31 @@ void CSerialPort::writeCalData(const uint8_t* data, uint8_t length)
   writeInt(1U, reply, count);
 }
 
+void CSerialPort::writeRSSIData(const uint8_t* data, uint8_t length)
+{
+  if (m_modemState != STATE_RSSICAL)
+    return;
+
+  uint8_t reply[30U];
+
+  reply[0U] = MMDVM_FRAME_START;
+  reply[1U] = 0U;
+  reply[2U] = MMDVM_RSSI_DATA;
+
+  uint8_t count = 3U;
+  for (uint8_t i = 0U; i < length; i++, count++)
+    reply[count] = data[i];
+
+  reply[1U] = count;
+
+  writeInt(1U, reply, count);
+}
+
 void CSerialPort::writeDebug(const char* text)
 {
+  if (!m_debug)
+    return;
+
   uint8_t reply[130U];
 
   reply[0U] = MMDVM_FRAME_START;
@@ -911,6 +1370,9 @@ void CSerialPort::writeDebug(const char* text)
 
 void CSerialPort::writeDebug(const char* text, int16_t n1)
 {
+  if (!m_debug)
+    return;
+
   uint8_t reply[130U];
 
   reply[0U] = MMDVM_FRAME_START;
@@ -931,6 +1393,9 @@ void CSerialPort::writeDebug(const char* text, int16_t n1)
 
 void CSerialPort::writeDebug(const char* text, int16_t n1, int16_t n2)
 {
+  if (!m_debug)
+    return;
+
   uint8_t reply[130U];
 
   reply[0U] = MMDVM_FRAME_START;
@@ -954,6 +1419,9 @@ void CSerialPort::writeDebug(const char* text, int16_t n1, int16_t n2)
 
 void CSerialPort::writeDebug(const char* text, int16_t n1, int16_t n2, int16_t n3)
 {
+  if (!m_debug)
+    return;
+
   uint8_t reply[130U];
 
   reply[0U] = MMDVM_FRAME_START;
@@ -980,6 +1448,9 @@ void CSerialPort::writeDebug(const char* text, int16_t n1, int16_t n2, int16_t n
 
 void CSerialPort::writeDebug(const char* text, int16_t n1, int16_t n2, int16_t n3, int16_t n4)
 {
+  if (!m_debug)
+    return;
+
   uint8_t reply[130U];
 
   reply[0U] = MMDVM_FRAME_START;
@@ -1006,32 +1477,3 @@ void CSerialPort::writeDebug(const char* text, int16_t n1, int16_t n2, int16_t n
 
   writeInt(1U, reply, count, true);
 }
-
-void CSerialPort::writeAssert(bool cond, const char* text, const char* file, long line)
-{
-  if (cond)
-    return;
-
-  uint8_t reply[200U];
-
-  reply[0U] = MMDVM_FRAME_START;
-  reply[1U] = 0U;
-  reply[2U] = MMDVM_DEBUG2;
-
-  uint8_t count = 3U;
-  for (uint8_t i = 0U; text[i] != '\0'; i++, count++)
-    reply[count] = text[i];
-
-  reply[count++] = ' ';
-  
-  for (uint8_t i = 0U; file[i] != '\0'; i++, count++)
-    reply[count] = file[i];
-
-  reply[count++] = (line >> 8) & 0xFF;
-  reply[count++] = (line >> 0) & 0xFF;
-
-  reply[1U] = count;
-
-  writeInt(1U, reply, count, true);
-}
-

SerialPort.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016 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
@@ -21,6 +21,11 @@
 
 #include "Config.h"
 #include "Globals.h"
+#include "RingBuffer.h"
+
+#if !defined(SERIAL_SPEED)
+#define SERIAL_SPEED 115200
+#endif
 
 
 class CSerialPort {
@@ -46,7 +51,15 @@ public:
   void writeP25Ldu(const uint8_t* data, uint8_t length);
   void writeP25Lost();
 
+  void writeNXDNData(const uint8_t* data, uint8_t length);
+  void writeNXDNLost();
+
+  void writeFMData(const uint8_t* data, uint8_t length);
+  void writeFMStatus(uint8_t status);
+  void writeFMEOT();
+
   void writeCalData(const uint8_t* data, uint8_t length);
+  void writeRSSIData(const uint8_t* data, uint8_t length);
 
   void writeDebug(const char* text);
   void writeDebug(const char* text, int16_t n1);
@@ -54,12 +67,12 @@ public:
   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 writeAssert(bool cond, const char* text, const char* file, long line);
-
 private:
-  uint8_t m_buffer[256U];
-  uint8_t m_ptr;
-  uint8_t m_len;
+  uint8_t   m_buffer[256U];
+  uint8_t   m_ptr;
+  uint8_t   m_len;
+  bool      m_debug;
+  CRingBuffer<uint8_t> m_repeat;
 
   void    sendACK();
   void    sendNAK(uint8_t err);
@@ -68,13 +81,17 @@ private:
   uint8_t setConfig(const uint8_t* data, uint8_t length);
   uint8_t setMode(const uint8_t* data, uint8_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);
 
   // Hardware versions
   void    beginInt(uint8_t n, int speed);
   int     availableInt(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
-

SerialRB.cpp

@@ -1,101 +0,0 @@
-/*
-Serial RB control - Copyright (C) KI6ZUM 2015
-Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
-
-This library is free software; you can redistribute it and/or
-modify it under the terms of the GNU Library General Public
-License as published by the Free Software Foundation; either
-version 2 of the License, or (at your option) any later version.
-
-This library 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
-Library General Public License for more details.
-
-You should have received a copy of the GNU Library General Public
-License along with this library; if not, write to the
-Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
-Boston, MA  02110-1301, USA.
-*/
-
-#include "SerialRB.h"
-
-CSerialRB::CSerialRB(uint16_t length) :
-m_length(length),
-m_buffer(NULL),
-m_head(0U),
-m_tail(0U),
-m_full(false)
-{
-  m_buffer = new uint8_t[length];
-}
-
-void CSerialRB::reset()
-{
-  m_head = 0U;
-  m_tail = 0U;
-  m_full = false;
-}
-
-uint16_t CSerialRB::getSpace() const
-{
-  uint16_t n = 0U;
-
-  if (m_tail == m_head)
-    n = m_full ? 0U : m_length;
-  else if (m_tail < m_head)
-    n = m_length - m_head + m_tail;
-  else
-    n = m_tail - m_head;
-
-  if (n > m_length)
-    n = 0U;
-
-  return n;
-}
-
-uint16_t CSerialRB::getData() const
-{
-  if (m_tail == m_head)
-    return m_full ? m_length : 0U;
-  else if (m_tail < m_head)
-    return m_head - m_tail;
-  else
-    return m_length - m_tail + m_head;
-}
-
-bool CSerialRB::put(uint8_t c)
-{
-  if (m_full)
-    return false;
-
-  m_buffer[m_head] = c;
-
-  m_head++;
-  if (m_head >= m_length)
-    m_head = 0U;
-
-  if (m_head == m_tail)
-    m_full = true;
-
-  return true;
-}
-
-uint8_t CSerialRB::peek() const
-{
-  return m_buffer[m_tail];
-}
-
-uint8_t CSerialRB::get()
-{
-  uint8_t value = m_buffer[m_tail];
-
-  m_full = false;
-
-  m_tail++;
-  if (m_tail >= m_length)
-    m_tail = 0U;
-
-  return value;
-}
-

SerialRB.h

@@ -1,58 +0,0 @@
-/*
-Serial fifo control - Copyright (C) KI6ZUM 2015
-Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
-
-This library is free software; you can redistribute it and/or
-modify it under the terms of the GNU Library General Public
-License as published by the Free Software Foundation; either
-version 2 of the License, or (at your option) any later version.
-
-This library 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
-Library General Public License for more details.
-
-You should have received a copy of the GNU Library General Public
-License along with this library; if not, write to the
-Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
-Boston, MA  02110-1301, USA.
-*/
-
-#if !defined(SERIALRB_H)
-#define  SERIALRB_H
-
-#if defined(STM32F4XX) || defined(STM32F4)
-#include "stm32f4xx.h"
-#include <cstddef>
-#else
-#include <Arduino.h>
-#endif
-
-const uint16_t SERIAL_RINGBUFFER_SIZE = 370U;
-
-class CSerialRB {
-public:
-  CSerialRB(uint16_t length = SERIAL_RINGBUFFER_SIZE);
-
-  uint16_t getSpace() const;
-
-  uint16_t getData() const;
-
-  void reset();
-
-  bool put(uint8_t c);
-
-  uint8_t peek() const;
-
-  uint8_t get();
-
-private:
-  uint16_t          m_length;
-  volatile uint8_t* m_buffer;
-  volatile uint16_t m_head;
-  volatile uint16_t m_tail;
-  volatile bool     m_full;
-};
-
-#endif
-

SerialSTM_CMSIS.cpp

@@ -0,0 +1,160 @@
+/*
+ *   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