Revert "Make CTCSS threshold RXLevel and RXBoost agnostic"

Merge branch 'FM' of https://github.com/g4klx/MMDVM into FM
Add optional over deviation blanking.
2026-10-15 08:14:12 +02:00 · 2020-04-25 23:48:02 +01:00 · 2020-04-25 22:32:37 +01:00 · 2020-04-25 22:32:10 +01:00 · 2020-04-25 22:13:09 +01:00 · 2020-04-25 23:07:41 +02:00
48 changed files with 2735 additions and 277 deletions
@@ -4,3 +4,6 @@
 [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
@@ -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;
+}
@@ -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
@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020 by Jonathan Naylor G4KLX
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
@@ -38,17 +38,19 @@
 // Allow the use of the COS line to lockout the modem
 // #define USE_COS_AS_LOCKOUT

-// Use pins to output the current mode
-// #define 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
-
-// For the SQ6POG board
-// #define STM32F1_POG
+#endif

 // For the SP8NTH board
 // #define ARDUINO_DUE_NTH
@@ -57,8 +59,11 @@
 // #define STM32F4_NUCLEO_MORPHO_HEADER
 // #define STM32F4_NUCLEO_ARDUINO_HEADER

-// Use separate mode pins to switch external filters/bandwidth for example
-// #define STM32F4_NUCLEO_MODE_PINS
+// 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
@@ -79,5 +84,7 @@
 // Use the D-Star and DMR LEDs for POCSAG
 // #define USE_ALTERNATE_POCSAG_LEDS

-#endif
+// Use the D-Star and YSF LEDs for FM
+// #define USE_ALTERNATE_FM_LEDS

+#endif
@@ -388,7 +388,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]);
@@ -0,0 +1,399 @@
+/*
+ *   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"
+
+CFM::CFM() :
+m_callsign(),
+m_rfAck(),
+m_ctcssRX(),
+m_ctcssTX(),
+m_timeoutTone(),
+m_state(FS_LISTENING),
+m_callsignAtStart(false),
+m_callsignAtEnd(false),
+m_callsignTimer(),
+m_timeoutTimer(),
+m_holdoffTimer(),
+m_kerchunkTimer(),
+m_ackMinTimer(),
+m_ackDelayTimer(),
+m_hangTimer(),
+m_filterStage1(  724,   1448,   724, 32768, -37895, 21352),
+m_filterStage2(32768,      0,-32768, 32768, -50339, 19052),
+m_filterStage3(32768, -65536, 32768, 32768, -64075, 31460),
+m_blanking(),
+m_useCOS(true),
+m_rxBoost(1U)
+{
+}
+
+void CFM::samples(bool cos, q15_t* samples, uint8_t length)
+{
+  if (!m_useCOS)
+    cos = true;
+
+  uint8_t i = 0U;
+  for (; i < length; i++) {
+    q15_t currentSample = samples[i];//save to a local variable to avoid indirection on every access
+
+    CTCSSState ctcssState = m_ctcssRX.process(currentSample);
+
+    if (CTCSS_NOT_READY(ctcssState) && m_modemState != STATE_FM) {
+      //Not enough samples to determine if you have CTCSS, just carry on
+      continue;
+    } else if (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, i + 1U);
+      if (m_modemState != STATE_FM)
+        continue;
+    } else if (CTCSS_READY(ctcssState) && m_modemState == STATE_FM) {
+      //We had enough samples for CTCSS and we are in FM mode, trigger the state machine
+      bool validCTCSS = CTCSS_VALID(ctcssState);
+      stateMachine(validCTCSS && cos, i + 1U);
+      if (m_modemState != STATE_FM)
+        break;
+    } else if (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, i + 1U);
+    }
+    
+    // Only let audio through when relaying audio
+    if (m_state == FS_RELAYING || m_state == FS_KERCHUNK)
+      currentSample = m_blanking.process(currentSample);
+    else
+      currentSample = 0U;
+
+    currentSample *= m_rxBoost;
+
+    if (!m_callsign.isRunning())
+      currentSample += m_rfAck.getHighAudio();
+    
+    if (!m_rfAck.isRunning()) {
+      if (m_state == FS_LISTENING)
+        currentSample += m_callsign.getHighAudio();
+      else
+        currentSample += m_callsign.getLowAudio();
+    }
+
+    if (!m_callsign.isRunning() && !m_rfAck.isRunning())
+      currentSample += m_timeoutTone.getAudio();
+
+    currentSample = q15_t(m_filterStage3.filter(m_filterStage2.filter(m_filterStage1.filter(currentSample))));
+
+    currentSample += m_ctcssTX.getAudio();
+
+    samples[i] = currentSample;
+  }
+
+  if (m_modemState == STATE_FM)
+    io.write(STATE_FM, samples, i);//only write the actual number of processed samples to IO
+}
+
+void CFM::process()
+{
+}
+
+void CFM::reset()
+{
+  m_ctcssRX.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)
+{
+  m_callsignAtStart = callsignAtStart;
+  m_callsignAtEnd   = callsignAtEnd;
+
+  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);
+  m_ackMinTimer.setTimeout(minTime, 0U);
+
+  return m_rfAck.setParams(rfAck, speed, frequency, level, level);
+}
+
+uint8_t CFM::setMisc(uint16_t timeout, uint8_t timeoutLevel, uint8_t ctcssFrequency, uint8_t ctcssThreshold, uint8_t ctcssLevel, uint8_t kerchunkTime, uint8_t hangTime, bool useCOS, uint8_t rxBoost, uint8_t maxDev)
+{
+  m_useCOS  = useCOS;
+  m_rxBoost = q15_t(rxBoost);
+
+  m_timeoutTimer.setTimeout(timeout, 0U);
+  m_kerchunkTimer.setTimeout(kerchunkTime, 0U);
+  m_hangTimer.setTimeout(hangTime, 0U);
+
+  m_timeoutTone.setParams(timeoutLevel);
+  m_blanking.setParams(maxDev, timeoutLevel);
+
+  uint8_t ret = m_ctcssRX.setParams(ctcssFrequency, ctcssThreshold);
+  if (ret != 0U)
+    return ret;
+
+  return m_ctcssTX.setParams(ctcssFrequency, ctcssLevel);
+}
+
+void CFM::stateMachine(bool validSignal, 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);
+
+  switch (m_state) {
+    case FS_LISTENING:
+      listeningState(validSignal);
+      break;
+    case FS_KERCHUNK:
+      kerchunkState(validSignal);
+      break;
+    case FS_RELAYING:
+      relayingState(validSignal);
+      break;
+    case FS_RELAYING_WAIT:
+      relayingWaitState(validSignal);
+      break;
+    case FS_TIMEOUT:
+      timeoutState(validSignal);
+      break;
+    case FS_TIMEOUT_WAIT:
+      timeoutWaitState(validSignal);
+      break;
+    case FS_HANG:
+      hangState(validSignal);
+      break;
+    default:
+      break;
+  }
+
+  if (m_state == FS_LISTENING && m_modemState == STATE_FM) {
+    if (!m_callsign.isRunning() && !m_rfAck.isRunning()) {
+      DEBUG1("Change to STATE_IDLE");
+      m_modemState = STATE_IDLE;
+      m_callsignTimer.stop();
+      m_timeoutTimer.stop();
+      m_kerchunkTimer.stop();
+      m_ackMinTimer.stop();
+      m_ackDelayTimer.stop();
+      m_hangTimer.stop();
+    }
+  }
+}
+
+void CFM::listeningState(bool validSignal)
+{
+  if (validSignal) {
+    if (m_kerchunkTimer.getTimeout() > 0U) {
+      DEBUG1("State to KERCHUNK");
+      m_state = FS_KERCHUNK;
+      m_kerchunkTimer.start();
+    } else {
+      DEBUG1("State to RELAYING");
+      m_state = FS_RELAYING;
+      if (m_callsignAtStart)
+        sendCallsign();
+    }
+
+    beginRelaying();
+
+    m_callsignTimer.start();
+
+    DEBUG1("Change to STATE_FM");
+    m_modemState = STATE_FM;
+  }
+}
+
+void CFM::kerchunkState(bool validSignal)
+{
+  if (validSignal) {
+    if (m_kerchunkTimer.hasExpired()) {
+      DEBUG1("State to RELAYING");
+      m_state = FS_RELAYING;
+      m_kerchunkTimer.stop();
+    }
+  } else {
+    DEBUG1("State to LISTENING");
+    m_state = FS_LISTENING;
+    m_kerchunkTimer.stop();
+    m_timeoutTimer.stop();
+    m_ackMinTimer.stop();
+    m_callsignTimer.stop();
+  }
+}
+
+void CFM::relayingState(bool validSignal)
+{
+  if (validSignal) {
+    if (m_timeoutTimer.isRunning() && m_timeoutTimer.hasExpired()) {
+      DEBUG1("State to TIMEOUT");
+      m_state = FS_TIMEOUT;
+      m_ackMinTimer.stop();
+      m_timeoutTimer.stop();
+      m_timeoutTone.start();
+    }
+  } else {
+    DEBUG1("State to RELAYING_WAIT");
+    m_state = FS_RELAYING_WAIT;
+    m_ackDelayTimer.start();
+  }
+
+  if (m_callsignTimer.isRunning() && m_callsignTimer.hasExpired()) {
+    sendCallsign();
+    m_callsignTimer.start();
+  }
+}
+
+void CFM::relayingWaitState(bool validSignal)
+{
+  if (validSignal) {
+    DEBUG1("State to RELAYING");
+    m_state = FS_RELAYING;
+    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 ack");
+          m_rfAck.start();
+          m_ackMinTimer.stop();
+        }
+      } else {
+          DEBUG1("Send 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::hangState(bool validSignal)
+{
+  if (validSignal) {
+    DEBUG1("State to RELAYING");
+    m_state = FS_RELAYING;
+    DEBUG1("Stop ack");
+    m_rfAck.stop();
+    beginRelaying();
+  } else {
+    if (m_hangTimer.isRunning() && m_hangTimer.hasExpired()) {
+      DEBUG1("State to LISTENING");
+      m_state = FS_LISTENING;
+      m_hangTimer.stop();
+
+      if (m_callsignAtEnd)
+        sendCallsign();
+
+      m_callsignTimer.stop();
+    }
+  }
+
+  if (m_callsignTimer.isRunning() && m_callsignTimer.hasExpired()) {
+    sendCallsign();
+    m_callsignTimer.start();
+  }
+}
+
+void CFM::timeoutState(bool validSignal)
+{
+  if (!validSignal) {
+    DEBUG1("State to TIMEOUT_WAIT");
+    m_state = FS_TIMEOUT_WAIT;
+    m_ackDelayTimer.start();
+  }
+
+  if (m_callsignTimer.isRunning() && m_callsignTimer.hasExpired()) {
+    sendCallsign();
+    m_callsignTimer.start();
+  }
+}
+
+void CFM::timeoutWaitState(bool validSignal)
+{
+  if (validSignal) {
+    DEBUG1("State to TIMEOUT");
+    m_state = FS_TIMEOUT;
+    m_ackDelayTimer.stop();
+  } else {
+    if (m_ackDelayTimer.isRunning() && m_ackDelayTimer.hasExpired()) {
+      DEBUG1("State to HANG");
+      m_state = FS_HANG;
+      m_timeoutTone.stop();
+      DEBUG1("Send 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::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();
+}
@@ -0,0 +1,95 @@
+/*
+ *   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 "FMDirectForm1.h"
+
+enum FM_STATE {
+  FS_LISTENING,
+  FS_KERCHUNK,
+  FS_RELAYING,
+  FS_RELAYING_WAIT,
+  FS_TIMEOUT,
+  FS_TIMEOUT_WAIT,
+  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);
+  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 ctcssThreshold, uint8_t ctcssLevel, uint8_t kerchunkTime, uint8_t hangTime, bool useCOS, uint8_t rxBoost, uint8_t maxDev);
+
+private:
+  CFMKeyer             m_callsign;
+  CFMKeyer             m_rfAck;
+  CFMCTCSSRX           m_ctcssRX;
+  CFMCTCSSTX           m_ctcssTX;
+  CFMTimeout           m_timeoutTone;
+  FM_STATE             m_state;
+  bool                 m_callsignAtStart;
+  bool                 m_callsignAtEnd;
+  CFMTimer             m_callsignTimer;
+  CFMTimer             m_timeoutTimer;
+  CFMTimer             m_holdoffTimer;
+  CFMTimer             m_kerchunkTimer;
+  CFMTimer             m_ackMinTimer;
+  CFMTimer             m_ackDelayTimer;
+  CFMTimer             m_hangTimer;
+  CFMDirectFormI       m_filterStage1;
+  CFMDirectFormI       m_filterStage2;
+  CFMDirectFormI       m_filterStage3;
+  CFMBlanking          m_blanking;
+  bool                 m_useCOS;
+  q15_t                m_rxBoost;
+
+  void stateMachine(bool validSignal, uint8_t length);
+  void listeningState(bool validSignal);
+  void kerchunkState(bool validSignal);
+  void relayingState(bool validSignal);
+  void relayingWaitState(bool validSignal);
+  void timeoutState(bool validSignal);
+  void timeoutWaitState(bool validSignal);
+  void hangState(bool validSignal);
+
+  void sendCallsign();
+  void beginRelaying();
+};
+
+#endif
@@ -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;
+}
@@ -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
@@ -0,0 +1,172 @@
+/*
+ *   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_threshold(0),
+m_count(0U),
+m_q0(0),
+m_q1(0),
+m_result(CTS_NONE)
+{
+}
+
+uint8_t CFMCTCSSRX::setParams(uint8_t frequency, uint8_t threshold)
+{
+  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_threshold = q31_t(threshold);
+
+  return 0U;
+}
+
+CTCSSState CFMCTCSSRX::process(q15_t sample)
+{
+  m_result = 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 + q31_t(sample);
+
+  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;
+
+    m_result = m_result | CTS_READY;
+    if (value >= m_threshold)
+      m_result = m_result | CTS_VALID;
+    else
+      m_result = m_result & ~CTS_VALID;
+
+    m_count = 0U;
+    m_q0 = 0;
+    m_q1 = 0;
+  }
+
+  return m_result;
+}
+
+CTCSSState CFMCTCSSRX::getState()
+{
+  return m_result;
+}
+
+void CFMCTCSSRX::reset()
+{
+  m_q0 = 0;
+  m_q1 = 0;
+  m_result = CTS_NONE;
+  m_count  = 0U;
+}
@@ -0,0 +1,73 @@
+/*
+ *   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"
+
+enum CTCSSState
+{
+  CTS_NONE  = 0,
+  CTS_READY = 1,
+  CTS_VALID = 2,
+  CTS_READY_VALID = CTS_READY | CTS_VALID
+};
+
+inline CTCSSState operator|(CTCSSState a, CTCSSState b)
+{
+  return static_cast<CTCSSState>(static_cast<uint8_t>(a) | static_cast<uint8_t>(b));
+}
+
+inline CTCSSState operator&(CTCSSState a, CTCSSState b)
+{
+  return static_cast<CTCSSState>(static_cast<uint8_t>(a) & static_cast<uint8_t>(b));
+}
+
+inline CTCSSState operator~(CTCSSState a)
+{
+  return static_cast<CTCSSState>(~(static_cast<uint8_t>(a)));
+}
+
+#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 threshold);
+  
+  CTCSSState process(q15_t samples);
+
+  CTCSSState getState();
+
+  void reset();
+
+private:
+ q63_t      m_coeffDivTwo;
+ q31_t      m_threshold;
+ uint16_t   m_count;
+ q31_t      m_q0;
+ q31_t      m_q1;
+ CTCSSState m_result;
+};
+
+#endif
@@ -0,0 +1,126 @@
+/*
+ *   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;
+  q15_t    increment;
+} TX_CTCSS_TABLE_DATA[] = {
+  { 67U, 358U,  92},
+  { 69U, 346U,  95},
+  { 71U, 334U,  99},
+  { 74U, 323U, 102},
+  { 77U, 312U, 106},
+  { 79U, 301U, 109},
+  { 82U, 291U, 113},
+  { 85U, 281U, 117},
+  { 88U, 271U, 121},
+  { 91U, 262U, 125},
+  { 94U, 253U, 130},
+  { 97U, 246U, 133},
+  {100U, 240U, 137},
+  {103U, 232U, 142},
+  {107U, 224U, 147},
+  {110U, 216U, 152},
+  {114U, 209U, 157},
+  {118U, 202U, 163},
+  {123U, 195U, 168},
+  {127U, 189U, 174},
+  {131U, 182U, 180},
+  {136U, 176U, 187},
+  {141U, 170U, 193},
+  {146U, 164U, 200},
+  {151U, 159U, 207},
+  {156U, 153U, 214},
+  {159U, 150U, 219},
+  {162U, 148U, 222},
+  {165U, 145U, 226},
+  {167U, 143U, 230},
+  {171U, 140U, 234},
+  {173U, 138U, 238},
+  {177U, 135U, 243},
+  {179U, 133U, 246},
+  {183U, 131U, 251},
+  {186U, 129U, 255},
+  {189U, 126U, 260},
+  {192U, 124U, 264},
+  {196U, 122U, 269},
+  {199U, 120U, 273},
+  {203U, 118U, 278},
+  {206U, 116U, 282},
+  {210U, 114U, 288},
+  {218U, 110U, 298},
+  {225U, 106U, 309},
+  {229U, 105U, 313},
+  {233U, 103U, 319},
+  {241U,  99U, 331},
+  {250U,  96U, 342},
+  {254U,  94U, 347}
+};
+
+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];
+
+  q15_t arg = 0;
+  for (uint16_t i = 0U; i < m_length; i++) {
+    q31_t value = ::arm_sin_q15(arg) * q15_t(level * 13);
+    m_values[i] = q15_t(__SSAT((value >> 15), 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;
+}
@@ -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
@@ -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 "Globals.h"
+
+#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    //F4FXL puting stauration here made everything quiet, not sure why
+									+ 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 */
@@ -0,0 +1,45 @@
+# based on https://github.com/berndporr/iir_fixed_point/blob/master/gen_coeff.py
+
+import numpy as np
+import scipy.signal as signal
+import pylab as pl
+
+# Calculate the coefficients for a pure fixed point
+# integer filter
+
+# sampling rate
+fs = 24000
+
+# cutoffs
+f1 = 300
+f2 = 2700
+# ripple
+rp = 0.2
+
+# scaling factor in bits, do not change !
+q = 15
+# scaling factor as facor...
+scaling_factor = 2**q
+
+# let's generate a sequence of 2nd order IIR filters
+#sos = signal.butter(2,[f1/fs*2,f2/fs*2],'pass',output='sos')
+sos = signal.cheby1(3,rp,[f1/fs*2,f2/fs*2],'bandpass', output='sos')
+
+sos = np.round((sos) * scaling_factor)
+
+# print coefficients
+for biquad in sos:
+    for coeff in biquad:
+        print(int(coeff),",",sep="",end="")
+        #print((coeff),",",sep="",end="")
+    print("")
+
+# plot the frequency response
+b,a = signal.sos2tf(sos)
+w,h = signal.freqz(b,a)
+pl.plot(w/np.pi/2*fs,20*np.log(np.abs(h)))
+pl.xlabel('frequency/Hz');
+pl.ylabel('gain/dB');
+pl.ylim(top=1,bottom=-20);
+pl.xlim(left=250, right=12000);
+pl.show()
@@ -0,0 +1,210 @@
+/*
+ *   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},
+  {' ', 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::isRunning() const
+{
+  return m_poPos > 0U || m_dotPos > 0U || m_audioPos > 0U;
+}
@@ -0,0 +1,52 @@
+/*
+ *   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;
+
+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
@@ -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;
+}
@@ -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
@@ -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;
+}
@@ -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
@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020 by Jonathan Naylor G4KLX
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
@@ -50,6 +50,7 @@ enum MMDVM_STATE {
  STATE_P25       = 4,
  STATE_NXDN      = 5,
  STATE_POCSAG    = 6,
+  STATE_FM        = 10,

  // Dummy states start at 90
  STATE_NXDNCAL1K = 91,
@@ -60,7 +61,9 @@ enum MMDVM_STATE {
  STATE_RSSICAL   = 96,
  STATE_CWID      = 97,
  STATE_DMRCAL    = 98,
-  STATE_DSTARCAL  = 99
+  STATE_DSTARCAL  = 99,
+  STATE_INTCAL    = 100,
+  STATE_POCSAGCAL = 101
 };

 #include "SerialPort.h"
@@ -83,10 +86,12 @@ enum MMDVM_STATE {
 #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;
@@ -97,6 +102,12 @@ 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;
@@ -105,6 +116,7 @@ extern bool m_ysfEnable;
 extern bool m_p25Enable;
 extern bool m_nxdnEnable;
 extern bool m_pocsagEnable;
+extern bool m_fmEnable;

 extern bool m_duplex;

@@ -135,14 +147,16 @@ extern CNXDNTX nxdnTX;

 extern CPOCSAGTX pocsagTX;

+extern CFM fm;
+
 extern CCalDStarRX calDStarRX;
 extern CCalDStarTX calDStarTX;
 extern CCalDMR     calDMR;
 extern CCalP25     calP25;
 extern CCalNXDN    calNXDN;
+extern CCalPOCSAG  calPOCSAG;
 extern CCalRSSI    calRSSI;

 extern CCWIdTX cwIdTX;

 #endif
-
@@ -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
@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020 by Jonathan Naylor G4KLX
 *   Copyright (C) 2015 by Jim Mclaughlin KI6ZUM
 *   Copyright (C) 2016 by Colin Durbridge G4EML
 *
@@ -80,6 +80,7 @@ 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),
@@ -137,123 +138,75 @@ void CIO::selfTest()
    // We exclude PTT to avoid trigger the transmitter
    setLEDInt(ledValue);
    setCOSInt(ledValue);
-#if defined(MODE_PINS)
+#if defined(MODE_LEDS)
    setDStarInt(ledValue);
    setDMRInt(ledValue);
    setYSFInt(ledValue);
    setP25Int(ledValue);
    setNXDNInt(ledValue);
    setPOCSAGInt(ledValue);
+    setFMInt(ledValue);
 #endif
    delayInt(250);
  }

-#if defined(MODE_PINS)
+#if defined(MODE_LEDS)
  setDStarInt(true);
  setDMRInt(false);
  setYSFInt(false);
  setP25Int(false);
  setNXDNInt(false);
  setPOCSAGInt(false);
+  setFMInt(false);

  delayInt(250);
-
-  setDStarInt(true);
  setDMRInt(true);
-  setYSFInt(false);
-  setP25Int(false);
-  setNXDNInt(false);
-  setPOCSAGInt(false);

  delayInt(250);
-
-  setDStarInt(true);
-  setDMRInt(true);
  setYSFInt(true);
-  setP25Int(false);
-  setNXDNInt(false);
-  setPOCSAGInt(false);
-  
-  delayInt(250);

-  setDStarInt(true);
-  setDMRInt(true);
-  setYSFInt(true);
+  delayInt(250);
  setP25Int(true);
-  setNXDNInt(false);
-  setPOCSAGInt(false);
-  
-  delayInt(250);

-  setDStarInt(true);
-  setDMRInt(true);
-  setYSFInt(true);
-  setP25Int(true);
+#if !defined(USE_ALTERNATE_NXDN_LEDS)
+  delayInt(250);
  setNXDNInt(true);
-  setPOCSAGInt(false);
-  
-  delayInt(250);
+#endif

-  setDStarInt(true);
-  setDMRInt(true);
-  setYSFInt(true);
-  setP25Int(true);
-  setNXDNInt(true);
+#if !defined(USE_ALTERNATE_POCSAG_LEDS)
+  delayInt(250);
  setPOCSAGInt(true);
-  
-  delayInt(250);
+#endif

-  setDStarInt(true);
-  setDMRInt(true);
-  setYSFInt(true);
-  setP25Int(true);
-  setNXDNInt(true);
+#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);
-  
-  delayInt(250);
+#endif

-  setDStarInt(true);
-  setDMRInt(true);
-  setYSFInt(true);
-  setP25Int(true);
+#if !defined(USE_ALTERNATE_NXDN_LEDS)
+  delayInt(250);
  setNXDNInt(false);
-  setPOCSAGInt(false);
+#endif

  delayInt(250);
-  
-  setDStarInt(true);
-  setDMRInt(true);
-  setYSFInt(true);
  setP25Int(false);
-  setNXDNInt(false);
-  setPOCSAGInt(false);

  delayInt(250);
-
-  setDStarInt(true);
-  setDMRInt(true);
  setYSFInt(false);
-  setP25Int(false);
-  setNXDNInt(false);
-  setPOCSAGInt(false);

  delayInt(250);
-  
-  setDStarInt(true);
  setDMRInt(false);
-  setYSFInt(false);
-  setP25Int(false);
-  setNXDNInt(false);
-  setPOCSAGInt(false);

  delayInt(250);
-
  setDStarInt(false);
-  setDMRInt(false);
-  setYSFInt(false);
-  setP25Int(false);
-  setNXDNInt(false);
-  setPOCSAGInt(false);
 #endif
 }

@@ -402,6 +355,15 @@ void CIO::process()
            dmrDMORX.samples(RRCVals, rssi, RX_BLOCK_SIZE);
        }
      }
+
+      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];
@@ -460,6 +422,13 @@ void CIO::process()

        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);
@@ -505,6 +474,9 @@ void CIO::write(MMDVM_STATE mode, q15_t* samples, uint16_t length, const uint8_t
    case STATE_POCSAG:
      txLevel = m_pocsagTXLevel;
      break;
+    case STATE_FM:
+      txLevel = m_fmTXLevel;
+      break;
    default:
      txLevel = m_cwIdTXLevel;
      break;
@@ -546,17 +518,18 @@ void CIO::setADCDetection(bool detect)

 void CIO::setMode()
 {
-#if defined(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, uint8_t nxdnTXLevel, uint8_t pocsagTXLevel, int16_t txDCOffset, int16_t rxDCOffset)
+void CIO::setParameters(bool rxInvert, bool txInvert, bool pttInvert, uint8_t rxLevel, uint8_t cwIdTXLevel, uint8_t dstarTXLevel, uint8_t dmrTXLevel, uint8_t ysfTXLevel, uint8_t p25TXLevel, uint8_t nxdnTXLevel, uint8_t pocsagTXLevel, uint8_t fmTXLevel, int16_t txDCOffset, int16_t rxDCOffset)
 {
  m_pttInvert = pttInvert;

@@ -568,6 +541,7 @@ void CIO::setParameters(bool rxInvert, bool txInvert, bool pttInvert, uint8_t rx
  m_p25TXLevel    = q15_t(p25TXLevel * 128);
  m_nxdnTXLevel   = q15_t(nxdnTXLevel * 128);
  m_pocsagTXLevel = q15_t(pocsagTXLevel * 128);
+  m_fmTXLevel     = q15_t(fmTXLevel * 128);

  m_rxDCOffset   = DC_OFFSET + rxDCOffset;
  m_txDCOffset   = DC_OFFSET + txDCOffset;
@@ -618,4 +592,3 @@ bool CIO::hasLockout() const
 {
  return m_lockout;
 }
-
@@ -42,7 +42,7 @@ public:
  
  void interrupt();

-  void setParameters(bool rxInvert, bool txInvert, bool pttInvert, uint8_t rxLevel, uint8_t cwIdTXLevel, uint8_t dstarTXLevel, uint8_t dmrTXLevel, uint8_t ysfTXLevel, uint8_t p25TXLevel, uint8_t nxdnTXLevel, uint8_t pocsagTXLevel, int16_t txDCOffset, int16_t rxDCOffset);
+  void setParameters(bool rxInvert, bool txInvert, bool pttInvert, uint8_t rxLevel, uint8_t cwIdTXLevel, uint8_t dstarTXLevel, uint8_t dmrTXLevel, uint8_t ysfTXLevel, uint8_t p25TXLevel, uint8_t nxdnTXLevel, uint8_t pocsagTXLevel, uint8_t fmTXLevel, int16_t txDCOffset, int16_t rxDCOffset);

  void getOverflow(bool& adcOverflow, bool& dacOverflow);

@@ -86,6 +86,7 @@ private:
  q15_t                m_p25TXLevel;
  q15_t                m_nxdnTXLevel;
  q15_t                m_pocsagTXLevel;
+  q15_t                m_fmTXLevel;

  uint16_t             m_rxDCOffset;
  uint16_t             m_txDCOffset;
@@ -118,9 +119,9 @@ private:
  void setP25Int(bool on);
  void setNXDNInt(bool on);
  void setPOCSAGInt(bool on);
+  void setFMInt(bool on);
  
  void delayInt(unsigned int dly);
 };

 #endif
-
@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020 by Jonathan Naylor G4KLX
 *   Copyright (C) 2015 by Jim Mclaughlin KI6ZUM
 *   Copyright (C) 2016 by Colin Durbridge G4EML
 *
@@ -35,6 +35,7 @@
 #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
@@ -50,6 +51,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
@@ -67,6 +69,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
@@ -95,7 +98,7 @@ void CIO::initInt()
  pinMode(PIN_LED,    OUTPUT);
  pinMode(PIN_COS,    INPUT);

-#if defined(MODE_PINS)
+#if defined(MODE_LEDS)
  // Set up the mode output pins
  pinMode(PIN_DSTAR,  OUTPUT);
  pinMode(PIN_DMR,    OUTPUT);
@@ -107,6 +110,9 @@ void CIO::initInt()
 #if !defined(USE_ALTERNATE_POCSAG_LEDS)
  pinMode(PIN_POCSAG, OUTPUT);
 #endif
+#if !defined(USE_ALTERNATE_POCSAG_LEDS)
+  pinMode(PIN_FM,     OUTPUT);
+#endif
 #endif
 }

@@ -258,10 +264,19 @@ void CIO::setPOCSAGInt(bool on)
 #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
-
@@ -1,7 +1,7 @@
 /*
 *   Copyright (C) 2016 by Jim McLaughlin KI6ZUM
 *   Copyright (C) 2016,2017,2018 by Andy Uribe CA6JAU
- *   Copyright (C) 2017,2018 by Jonathan Naylor G4KLX
+ *   Copyright (C) 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
@@ -24,7 +24,120 @@

 #if defined(STM32F4XX) || defined(STM32F7XX)

-#if defined(STM32F4_DISCOVERY)
+#if defined(STM32F4_RPT_HAT_TGO)
+/*
+Pin definitions for MMDVM_RPT_Hat Pi-Hat BG4TGO  board::
+
+PTT      PB13   output           CN10 Pin30
+COSLED   PB14   output           CN10 Pin28
+LED      PA5    output           CN10 Pin11
+COS      PB15   input            CN10 Pin26
+
+DSTAR    PB10   output           CN10 Pin25
+DMR      PB4    output           CN10 Pin27
+YSF      PB5    output           CN10 Pin29
+P25      PB3    output           CN10 Pin31
+NXDN     PA10   output           CN10 Pin33
+POCSAG   PB12   output           CN10 Pin16
+
+MDSTAR   PC4    output           CN10 Pin34
+MDMR     PC5    output           CN10 Pin6
+MYSF     PC2    output           CN7  Pin35
+MP25     PC3    output           CN7  Pin37
+MNXDN    PC6    output           CN10 Pin4
+MPOCSAG  PC8    output           CN10 Pin2
+
+RX       PA0    analog input     CN7 Pin28
+RSSI     PA1    analog input     CN7 Pin30
+TX       PA4    analog output    CN7 Pin32
+
+EXT_CLK  PA15   input            CN7 Pin17
+*/
+
+#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_NXDN          GPIO_Pin_10
+#define PORT_NXDN         GPIOA
+#define RCC_Per_NXDN      RCC_AHB1Periph_GPIOA
+
+#define PIN_POCSAG        GPIO_Pin_12
+#define PORT_POCSAG       GPIOB
+#define RCC_Per_POCSAG    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
+
+#if defined(MODE_PINS)
+#define PIN_MP25          GPIO_Pin_3
+#define PORT_MP25         GPIOC
+#define RCC_Per_MP25      RCC_AHB1Periph_GPIOC
+
+#define PIN_MNXDN         GPIO_Pin_6
+#define PORT_MNXDN        GPIOC
+#define RCC_Per_MNXDN     RCC_AHB1Periph_GPIOC
+
+#define PIN_MDSTAR        GPIO_Pin_4
+#define PORT_MDSTAR       GPIOC
+#define RCC_Per_MDSTAR    RCC_AHB1Periph_GPIOC
+
+#define PIN_MDMR          GPIO_Pin_5
+#define PORT_MDMR         GPIOC
+#define RCC_Per_MDMR      RCC_AHB1Periph_GPIOC
+
+#define PIN_MYSF          GPIO_Pin_2
+#define PORT_MYSF         GPIOC
+#define RCC_Per_MYSF      RCC_AHB1Periph_GPIOC
+
+#define PIN_MPOCSAG       GPIO_Pin_8
+#define PORT_MPOCSAG      GPIOC
+#define RCC_Per_MPOCSAG   RCC_AHB1Periph_GPIOC
+#endif
+
+#define PIN_EXT_CLK       GPIO_Pin_15
+#define SRC_EXT_CLK       GPIO_PinSource15
+#define PORT_EXT_CLK      GPIOA
+
+#define PIN_RX            GPIO_Pin_0
+#define PIN_RX_CH         ADC_Channel_0
+#define PORT_RX           GPIOA
+#define RCC_Per_RX        RCC_AHB1Periph_GPIOA
+
+#define PIN_RSSI          GPIO_Pin_1
+#define PIN_RSSI_CH       ADC_Channel_1
+#define PORT_RSSI         GPIOA
+#define RCC_Per_RSSI      RCC_AHB1Periph_GPIOA
+
+#define PIN_TX            GPIO_Pin_4
+#define PIN_TX_CH         DAC_Channel_1
+
+#elif defined(STM32F4_DISCOVERY)
 /*
 Pin definitions for STM32F4 Discovery Board:

@@ -113,6 +226,7 @@ DMR      PC8    output
 YSF      PA8    output
 P25      PC9    output
 NXDN     PB1    output
+POCSAG   PB12   output

 RX       PA0    analog input
 RSSI     PA7    analog input
@@ -145,6 +259,10 @@ EXT_CLK  PA15   input
 #define PORT_NXDN         GPIOB
 #define RCC_Per_NXDN      RCC_AHB1Periph_GPIOB

+#define PIN_POCSAG        GPIO_Pin_12
+#define PORT_POCSAG       GPIOB
+#define RCC_Per_POCSAG    RCC_AHB1Periph_GPIOB
+
 #define PIN_DSTAR         GPIO_Pin_7
 #define PORT_DSTAR        GPIOC
 #define RCC_Per_DSTAR     RCC_AHB1Periph_GPIOC
@@ -188,6 +306,7 @@ DMR      PC8    output
 YSF      PA8    output
 P25      PC9    output
 NXDN     PB1    output
+POCSAG   PB12   output

 RX       PA0    analog input
 RSSI     PA7    analog input
@@ -220,6 +339,10 @@ EXT_CLK  PA15   input
 #define PORT_NXDN         GPIOB
 #define RCC_Per_NXDN      RCC_AHB1Periph_GPIOB

+#define PIN_POCSAG        GPIO_Pin_12
+#define PORT_POCSAG       GPIOB
+#define RCC_Per_POCSAG    RCC_AHB1Periph_GPIOB
+
 #define PIN_DSTAR         GPIO_Pin_7
 #define PORT_DSTAR        GPIOC
 #define RCC_Per_DSTAR     RCC_AHB1Periph_GPIOC
@@ -263,6 +386,7 @@ DMR      PC8    output
 YSF      PA8    output
 P25      PC9    output
 NXDN     PB1    output
+POCSAG   PB12   output

 RX       PA0    analog input
 RSSI     PA7    analog input
@@ -295,6 +419,10 @@ EXT_CLK  PA15   input
 #define PORT_NXDN         GPIOB
 #define RCC_Per_NXDN      RCC_AHB1Periph_GPIOB

+#define PIN_POCSAG        GPIO_Pin_12
+#define PORT_POCSAG       GPIOB
+#define RCC_Per_POCSAG    RCC_AHB1Periph_GPIOB
+
 #define PIN_DSTAR         GPIO_Pin_7
 #define PORT_DSTAR        GPIOC
 #define RCC_Per_DSTAR     RCC_AHB1Periph_GPIOC
@@ -372,7 +500,7 @@ EXT_CLK  PA15   input
 #define RCC_Per_NXDN      RCC_AHB1Periph_GPIOB

 #define PIN_POCSAG        GPIO_Pin_12
-#define PORT_NXDN         GPIOB
+#define PORT_POCSAG       GPIOB
 #define RCC_Per_POCSAG    RCC_AHB1Periph_GPIOB

 #define PIN_DSTAR         GPIO_Pin_7
@@ -404,6 +532,119 @@ EXT_CLK  PA15   input
 #define PIN_TX            GPIO_Pin_4
 #define PIN_TX_CH         DAC_Channel_1

+#elif defined(STM32F722_RPT_HAT)
+/*
+Pin definitions for MMDVM_RPT_Hat Pi-Hat F0DEI DB9MAT DF2ET board:
+
+PTT      PB14   output
+COSLED   PB13   output
+LED      PB12   output
+COS      PC0    input
+
+DSTAR    PB15   output
+DMR      PC6    output
+YSF      PC7    output
+P25      PC8    output
+NXDN     PC9    output
+POCSAG   PA8    output
+
+MDSTAR   PC1    output
+MDMR     PC2    output
+MYSF     PC3    output
+MP25     PC4    output
+MNXDN    PC10   output
+MPOCSAG  PC11   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_14
+#define PORT_PTT          GPIOB
+#define RCC_Per_PTT       RCC_AHB1Periph_GPIOB
+
+#define PIN_COSLED        GPIO_Pin_13
+#define PORT_COSLED       GPIOB
+#define RCC_Per_COSLED    RCC_AHB1Periph_GPIOB
+
+#define PIN_LED           GPIO_Pin_12
+#define PORT_LED          GPIOB
+#define RCC_Per_LED       RCC_AHB1Periph_GPIOB
+
+#define PIN_P25           GPIO_Pin_8
+#define PORT_P25          GPIOC
+#define RCC_Per_P25       RCC_AHB1Periph_GPIOC
+
+#define PIN_NXDN          GPIO_Pin_9
+#define PORT_NXDN         GPIOC
+#define RCC_Per_NXDN      RCC_AHB1Periph_GPIOC
+
+#define PIN_POCSAG        GPIO_Pin_8
+#define PORT_POCSAG       GPIOA
+#define RCC_Per_POCSAG    RCC_AHB1Periph_GPIOA
+
+#define PIN_DSTAR         GPIO_Pin_15
+#define PORT_DSTAR        GPIOB
+#define RCC_Per_DSTAR     RCC_AHB1Periph_GPIOB
+
+#define PIN_DMR           GPIO_Pin_6
+#define PORT_DMR          GPIOC
+#define RCC_Per_DMR       RCC_AHB1Periph_GPIOC
+
+#define PIN_YSF           GPIO_Pin_7
+#define PORT_YSF          GPIOC
+#define RCC_Per_YSF       RCC_AHB1Periph_GPIOC
+
+#if defined(MODE_PINS)
+#define PIN_MP25          GPIO_Pin_4
+#define PORT_MP25         GPIOC
+#define RCC_Per_MP25      RCC_AHB1Periph_GPIOC
+
+#define PIN_MNXDN         GPIO_Pin_10
+#define PORT_MNXDN        GPIOC
+#define RCC_Per_MNXDN     RCC_AHB1Periph_GPIOC
+
+#define PIN_MDSTAR        GPIO_Pin_1
+#define PORT_MDSTAR       GPIOC
+#define RCC_Per_MDSTAR    RCC_AHB1Periph_GPIOC
+
+#define PIN_MDMR          GPIO_Pin_2
+#define PORT_MDMR         GPIOC
+#define RCC_Per_MDMR      RCC_AHB1Periph_GPIOC
+
+#define PIN_MYSF          GPIO_Pin_3
+#define PORT_MYSF         GPIOC
+#define RCC_Per_MYSF      RCC_AHB1Periph_GPIOC
+
+#define PIN_MPOCSAG       GPIO_Pin_11
+#define PORT_MPOCSAG      GPIOC
+#define RCC_Per_MPOCSAG   RCC_AHB1Periph_GPIOC
+#endif
+
+#define PIN_EXT_CLK       GPIO_Pin_15
+#define SRC_EXT_CLK       GPIO_PinSource15
+#define PORT_EXT_CLK      GPIOA
+
+#define PIN_RX            GPIO_Pin_0
+#define PIN_RX_CH         ADC_Channel_0
+#define PORT_RX           GPIOA
+#define RCC_Per_RX        RCC_AHB1Periph_GPIOA
+
+#define PIN_RSSI          GPIO_Pin_7
+#define PIN_RSSI_CH       ADC_Channel_7
+#define PORT_RSSI         GPIOA
+#define RCC_Per_RSSI      RCC_AHB1Periph_GPIOA
+
+#define PIN_TX            GPIO_Pin_4
+#define PIN_TX_CH         DAC_Channel_1
+
 #elif defined(STM32F4_NUCLEO)

 #if defined(STM32F4_NUCLEO_MORPHO_HEADER)
@@ -420,12 +661,14 @@ DMR      PB4    output           CN10 Pin27
 YSF      PB5    output           CN10 Pin29
 P25      PB3    output           CN10 Pin31
 NXDN     PA10   output           CN10 Pin33
+POCSAG   PB12   output           CN10 Pin16

 MDSTAR   PC4    output           CN10 Pin34
 MDMR     PC5    output           CN10 Pin6
 MYSF     PC2    output           CN7 Pin35
 MP25     PC3    output           CN7 Pin37
 MNXDN    PC6    output           CN10 Pin4
+MPOCSAG  PC8    output           CN10 Pin2

 RX       PA0    analog input     CN7 Pin28
 RSSI     PA1    analog input     CN7 Pin30
@@ -458,6 +701,10 @@ EXT_CLK  PA15   input            CN7 Pin17
 #define PORT_NXDN         GPIOA
 #define RCC_Per_NXDN      RCC_AHB1Periph_GPIOA

+#define PIN_POCSAG        GPIO_Pin_12
+#define PORT_POCSAG       GPIOB
+#define RCC_Per_POCSAG    RCC_AHB1Periph_GPIOB
+
 #define PIN_DSTAR         GPIO_Pin_10
 #define PORT_DSTAR        GPIOB
 #define RCC_Per_DSTAR     RCC_AHB1Periph_GPIOB
@@ -470,7 +717,7 @@ EXT_CLK  PA15   input            CN7 Pin17
 #define PORT_YSF          GPIOB
 #define RCC_Per_YSF       RCC_AHB1Periph_GPIOB

-#if defined(STM32F4_NUCLEO_MODE_PINS)
+#if defined(MODE_PINS)
 #define PIN_MP25          GPIO_Pin_3
 #define PORT_MP25         GPIOC
 #define RCC_Per_MP25      RCC_AHB1Periph_GPIOC
@@ -490,6 +737,10 @@ EXT_CLK  PA15   input            CN7 Pin17
 #define PIN_MYSF          GPIO_Pin_2
 #define PORT_MYSF         GPIOC
 #define RCC_Per_MYSF      RCC_AHB1Periph_GPIOC
+
+#define PIN_MPOCSAG       GPIO_Pin_8
+#define PORT_MPOCSAG      GPIOC
+#define RCC_Per_MPOCSAG   RCC_AHB1Periph_GPIOC
 #endif

 #define PIN_EXT_CLK       GPIO_Pin_15
@@ -523,6 +774,7 @@ DMR      PA4    output           CN8 Pin3
 YSF      PB0    output           CN8 Pin4
 P25      PC1    output           CN8 Pin5
 NXDN     PA3    output           CN9 Pin1
+POCSAG   PB12   output

 RX       PA0    analog input     CN8 Pin1
 RSSI     PC0    analog input     CN8 Pin6
@@ -555,6 +807,10 @@ EXT_CLK  PB8    input            CN5 Pin10
 #define PORT_NXDN         GPIOA
 #define RCC_Per_NXDN      RCC_AHB1Periph_GPIOA

+#define PIN_POCSAG        GPIO_Pin_12
+#define PORT_POCSAG       GPIOB
+#define RCC_Per_POCSAG    RCC_AHB1Periph_GPIOB
+
 #define PIN_DSTAR         GPIO_Pin_1
 #define PORT_DSTAR        GPIOA
 #define RCC_Per_DSTAR     RCC_AHB1Periph_GPIOA
@@ -602,6 +858,7 @@ DMR      PB4    output           CN12 Pin27
 YSF      PB5    output           CN12 Pin29
 P25      PB3    output           CN12 Pin31
 NXDN     PA10   output           CN12 Pin33
+POCSAG   PB12   output           CN12 Pin16

 MDSTAR   PC4    output           CN12 Pin34
 MDMR     PC5    output           CN12 Pin6
@@ -640,6 +897,10 @@ EXT_CLK  PA15   input            CN11 Pin17
 #define PORT_NXDN         GPIOA
 #define RCC_Per_NXDN      RCC_AHB1Periph_GPIOA

+#define PIN_POCSAG        GPIO_Pin_12
+#define PORT_POCSAG       GPIOB
+#define RCC_Per_POCSAG    RCC_AHB1Periph_GPIOB
+
 #define PIN_DSTAR         GPIO_Pin_10
 #define PORT_DSTAR        GPIOB
 #define RCC_Per_DSTAR     RCC_AHB1Periph_GPIOB
@@ -652,7 +913,7 @@ EXT_CLK  PA15   input            CN11 Pin17
 #define PORT_YSF          GPIOB
 #define RCC_Per_YSF       RCC_AHB1Periph_GPIOB

-#if defined(STM32F4_NUCLEO_MODE_PINS)
+#if defined(MODE_PINS)
 #define PIN_MP25          GPIO_Pin_3
 #define PORT_MP25         GPIOC
 #define RCC_Per_MP25      RCC_AHB1Periph_GPIOC
@@ -705,6 +966,7 @@ NXDN     PB9    output
 DSTAR    PB6    output
 DMR      PB5    output
 YSF      PB7    output
+POCSAG   PC10   output

 RX       PB0    analog input
 RSSI     PB1    analog input
@@ -750,6 +1012,10 @@ EXT_CLK  PA15   input
 #define PORT_YSF          GPIOB
 #define RCC_Per_YSF       RCC_AHB1Periph_GPIOB

+#define PIN_POCSAG        GPIO_Pin_10
+#define PORT_POCSAG       GPIOC
+#define RCC_Per_POCSAG    RCC_AHB1Periph_GPIOC
+
 #define PIN_EXT_CLK       GPIO_Pin_15
 #define SRC_EXT_CLK       GPIO_PinSource15
 #define PORT_EXT_CLK      GPIOA
@@ -817,7 +1083,7 @@ void CIO::initInt()
   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_IN;
   GPIO_Init(PORT_COS, &GPIO_InitStruct);

-#if defined(MODE_PINS)
+#if defined(MODE_LEDS)
   // DSTAR pin
   RCC_AHB1PeriphClockCmd(RCC_Per_DSTAR, ENABLE);
   GPIO_InitStruct.GPIO_Pin   = PIN_DSTAR;
@@ -859,7 +1125,7 @@ void CIO::initInt()
 #endif
 #endif

-#if defined(STM32F4_NUCLEO_MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && defined(STM32F4_NUCLEO)
+#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;
@@ -1109,7 +1375,7 @@ void CIO::setCOSInt(bool on)
 void CIO::setDStarInt(bool on)
 {
   GPIO_WriteBit(PORT_DSTAR, PIN_DSTAR, on ? Bit_SET : Bit_RESET);
-#if defined(STM32F4_NUCLEO_MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && defined(STM32F4_NUCLEO)
+#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
 }
@@ -1117,7 +1383,7 @@ void CIO::setDStarInt(bool on)
 void CIO::setDMRInt(bool on)
 {
   GPIO_WriteBit(PORT_DMR, PIN_DMR, on ? Bit_SET : Bit_RESET);
-#if defined(STM32F4_NUCLEO_MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && defined(STM32F4_NUCLEO)
+#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
 }
@@ -1125,7 +1391,7 @@ void CIO::setDMRInt(bool on)
 void CIO::setYSFInt(bool on)
 {
   GPIO_WriteBit(PORT_YSF, PIN_YSF, on ? Bit_SET : Bit_RESET);
-#if defined(STM32F4_NUCLEO_MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && defined(STM32F4_NUCLEO)
+#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
 }
@@ -1133,7 +1399,7 @@ void CIO::setYSFInt(bool on)
 void CIO::setP25Int(bool on)
 {
   GPIO_WriteBit(PORT_P25, PIN_P25, on ? Bit_SET : Bit_RESET);
-#if defined(STM32F4_NUCLEO_MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && defined(STM32F4_NUCLEO)
+#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
 }
@@ -1143,13 +1409,13 @@ void CIO::setNXDNInt(bool on)
 #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);
-#if defined(STM32F4_NUCLEO_MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && defined(STM32F4_NUCLEO)
+#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);
   GPIO_WriteBit(PORT_MP25, PIN_MP25, on ? Bit_SET : Bit_RESET);
 #endif
 #else
   GPIO_WriteBit(PORT_NXDN, PIN_NXDN, on ? Bit_SET : Bit_RESET);
-#if defined(STM32F4_NUCLEO_MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && defined(STM32F4_NUCLEO)
+#if defined(MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && (defined(STM32F4_NUCLEO) || defined(STM32F722_RPT_HAT))
   GPIO_WriteBit(PORT_MNXDN, PIN_MNXDN, on ? Bit_SET : Bit_RESET);
 #endif
 #endif
@@ -1160,18 +1426,35 @@ void CIO::setPOCSAGInt(bool on)
 #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);
-#if defined(STM32F4_NUCLEO_MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && defined(STM32F4_NUCLEO)
+#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);
   GPIO_WriteBit(PORT_MDMR,   PIN_MDMR,   on ? Bit_SET : Bit_RESET);
 #endif
 #else
   GPIO_WriteBit(PORT_POCSAG,  PIN_POCSAG, on ? Bit_SET : Bit_RESET);
-#if defined(STM32F4_NUCLEO_MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && defined(STM32F4_NUCLEO)
+#if defined(MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && (defined(STM32F4_NUCLEO) || defined(STM32F722_RPT_HAT))
   GPIO_WriteBit(PORT_MPOCSAG, PIN_MPOCSAG, on ? Bit_SET : Bit_RESET);
 #endif
 #endif
 }

+void CIO::setFMInt(bool on)
+{
+#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);
+#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);
+   GPIO_WriteBit(PORT_MYSF,   PIN_MYSF,   on ? Bit_SET : Bit_RESET);
+#endif
+#else
+   GPIO_WriteBit(PORT_FM,  PIN_FM, on ? Bit_SET : Bit_RESET);
+#if defined(MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && (defined(STM32F4_NUCLEO) || defined(STM32F722_RPT_HAT))
+   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)
@@ -1,7 +1,7 @@
 /*
 *   Copyright (C) 2016 by Jim McLaughlin KI6ZUM
 *   Copyright (C) 2016, 2017 by Andy Uribe CA6JAU
- *   Copyright (C) 2017,2018 by Jonathan Naylor G4KLX
+ *   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
@@ -41,6 +41,7 @@ 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)
@@ -84,6 +85,9 @@ USART1_RXD PA10  input (AF)
 #define PIN_POCSAG        11
 #define PORT_POCSAG       GPIOB
 #define BB_POCSAG         *((bitband_t)BITBAND_PERIPH(&PORT_POCSAG->ODR, PIN_POCSAG))
+#define PIN_FM            12
+#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
@@ -154,9 +158,9 @@ void GPIOConfigPin(GPIO_TypeDef *port_ptr, uint32_t pin, uint32_t mode_cnf_value
 #if defined(STM32F1_POG)
 void FancyLEDEffect()
 {
-  bitband_t foo[] = {&BB_LED, &BB_COSLED, &BB_PTT, &BB_DMR, &BB_DSTAR, &BB_YSF, &BB_P25};
+  bitband_t foo[] = {&BB_LED, &BB_COSLED, &BB_PTT, &BB_DMR, &BB_DSTAR, &BB_YSF, &BB_P25, &BB_NXDN, &BB_POCSAG, &BB_FM};
   
-  for(int i=0; i<7; i++){
+  for(int i=0; i<10; i++){
    *foo[i] = 0x01;
  }
  GPIOConfigPin(PORT_USART1_TXD, PIN_USART1_TXD, GPIO_CRL_MODE0_1);
@@ -172,12 +176,12 @@ void FancyLEDEffect()
  *((bitband_t)BITBAND_PERIPH(&PORT_USART1_TXD->ODR, PIN_USART1_TXD)) = 0x01;
  
  *foo[0] = 0x01;
-  for(int i=1; i<7; i++){
+  for(int i=1; i<10; i++){
    delay(SystemCoreClock/1000*10);
    *foo[i-1] = 0x00;
    *foo[i] = 0x01;
  }
-  for(int i=5; i>=0; i--){
+  for(int i=10; i>=0; i--){
    delay(SystemCoreClock/1000*10);
    *foo[i+1] = 0x00;
    *foo[i] = 0x01;
@@ -228,6 +232,9 @@ static inline void GPIOInit()
 #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)
@@ -369,7 +376,9 @@ void CIO::interrupt()
 {
  uint8_t control  = MARK_NONE;
  uint16_t sample  = DC_OFFSET;
+#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)
@@ -458,6 +467,16 @@ void CIO::setPOCSAGInt(bool 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);
@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2016,2017,2018 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
@@ -37,9 +37,11 @@
 #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
@@ -64,7 +66,7 @@ void CIO::initInt()
  pinMode(PIN_LED,    OUTPUT);
  pinMode(PIN_COS,    INPUT);

-#if defined(MODE_PINS)
+#if defined(MODE_LEDS)
  // Set up the mode output pins
  pinMode(PIN_DSTAR,  OUTPUT);
  pinMode(PIN_DMR,    OUTPUT);
@@ -76,6 +78,9 @@ void CIO::initInt()
 #if !defined(USE_ALTERNATE_POCSAG_LEDS)
  pinMode(PIN_POCSAG, OUTPUT);
 #endif
+#if !defined(USE_ALTERNATE_FM_LEDS)
+  pinMode(PIN_FM,     OUTPUT);
+#endif
 #endif
 }

@@ -243,6 +248,16 @@ void CIO::setPOCSAGInt(bool on)
 #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);
@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020 by Jonathan Naylor G4KLX
 *   Copyright (C) 2016 by Mathis Schmieder DB9MAT
 *   Copyright (C) 2016 by Colin Durbridge G4EML
 *
@@ -32,6 +32,7 @@ bool m_ysfEnable    = true;
 bool m_p25Enable    = true;
 bool m_nxdnEnable   = true;
 bool m_pocsagEnable = true;
+bool m_fmEnable     = true;

 bool m_duplex = true;

@@ -59,11 +60,14 @@ CNXDNTX    nxdnTX;

 CPOCSAGTX  pocsagTX;

+CFM        fm;
+
 CCalDStarRX calDStarRX;
 CCalDStarTX calDStarTX;
 CCalDMR     calDMR;
 CCalP25     calP25;
 CCalNXDN    calNXDN;
+CCalPOCSAG  calPOCSAG;
 CCalRSSI    calRSSI;

 CCWIdTX cwIdTX;
@@ -102,9 +106,12 @@ void loop()
  if (m_nxdnEnable && m_modemState == STATE_NXDN)
    nxdnTX.process();

-  if (m_pocsagEnable && m_modemState == STATE_POCSAG)
+  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();

@@ -117,6 +124,9 @@ void loop()
  if (m_modemState == STATE_NXDNCAL1K)
    calNXDN.process();

+  if (m_modemState == STATE_POCSAGCAL)
+    calPOCSAG.process();
+
  if (m_modemState == STATE_IDLE)
    cwIdTX.process();
 }
@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020 by Jonathan Naylor G4KLX
 *   Copyright (C) 2016 by Colin Durbridge G4EML
 *
 *   This program is free software; you can redistribute it and/or modify
@@ -29,6 +29,7 @@ bool m_ysfEnable    = true;
 bool m_p25Enable    = true;
 bool m_nxdnEnable   = true;
 bool m_pocsagEnable = true;
+bool m_fmEnable     = true;

 bool m_duplex = true;

@@ -56,11 +57,14 @@ CNXDNTX    nxdnTX;

 CPOCSAGTX  pocsagTX;

+CFM        fm;
+
 CCalDStarRX calDStarRX;
 CCalDStarTX calDStarTX;
 CCalDMR     calDMR;
 CCalP25     calP25;
 CCalNXDN    calNXDN;
+CCalPOCSAG  calPOCSAG;
 CCalRSSI    calRSSI;

 CCWIdTX cwIdTX;
@@ -99,9 +103,12 @@ void loop()
  if (m_nxdnEnable && m_modemState == STATE_NXDN)
    nxdnTX.process();

-  if (m_pocsagEnable && m_modemState == STATE_POCSAG)
+  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();

@@ -114,7 +121,9 @@ void loop()
  if (m_modemState == STATE_NXDNCAL1K)
    calNXDN.process();

+  if (m_modemState == STATE_POCSAGCAL)
+    calPOCSAG.process();
+
  if (m_modemState == STATE_IDLE)
    cwIdTX.process();
 }
-
@@ -97,7 +97,7 @@
          <Define name="STM32F446xx"/>
          <Define name="HSE_VALUE=12000000"/>
          <Define name="STM32F4_PI"/>
-          <Define name="MODE_PINS"/>
+          <Define name="MODE_LEDS"/>
        </DefinedSymbols>
      </Compile>
      <Link useDefault="0">
@@ -128,8 +128,12 @@ DEFS_NUCLEO_F767=-DUSE_HAL_DRIVER -DSTM32F767xx -DSTM32F7XX -DSTM32F7_NUCLEO -DH
 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

 # Build compiler flags
 CFLAGS_F4=-c $(MCFLAGS_F4) $(INCLUDES_F4)
@@ -148,7 +152,7 @@ CXXFLAGS=-Os -fno-exceptions -ffunction-sections -fdata-sections -fno-builtin -f
 LDFLAGS=-Os --specs=nano.specs

 # Build Rules
-.PHONY: all release dis pi pi_f722 f4m nucleo f767 dvm clean
+.PHONY: all release dis pi pi-f722 f4m nucleo f767 dvm clean

 # Default target: Nucleo-64 F446RE board
 all: nucleo
@@ -177,6 +181,18 @@ f7m: CXXFLAGS+=$(CXXFLAGS_F7) $(DEFS_F7M)
 f7m: LDFLAGS+=$(LDFLAGS_F722)
 f7m: release_f7

+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)
@@ -223,7 +239,7 @@ $(OBJDIR_F7):
 $(BINDIR)/$(BINHEX_F4): $(BINDIR)/$(BINELF_F4)
 	$(CP) -O ihex $< $@
 	@echo "Objcopy from ELF to IHEX complete!\n"
-	
+
 $(BINDIR)/$(BINBIN_F4): $(BINDIR)/$(BINELF_F4)
 	$(CP) -O binary $< $@
 	@echo "Objcopy from ELF to BINARY complete!\n"
@@ -236,7 +252,7 @@ $(BINDIR)/$(BINELF_F4): $(OBJ_F4)
 $(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"
@@ -326,17 +342,15 @@ 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/stm32ld /dev/ttyAMA0 57600 bin/$(BINBIN_F7)
 	/usr/local/bin/stm32flash -v -w bin/$(BINBIN_F7) -g 0x0 -R -c /dev/ttyAMA0
-endif

-ifneq ($(wildcard /usr/bin/stm32flash),)
+else ifneq ($(wildcard /usr/bin/stm32flash),)
 	-/usr/bin/stm32flash -i 20,-21,21:-20,21 /dev/ttyAMA0
-	-/usr/bin/stm32ld /dev/ttyAMA0 57600 bin/$(BINBIN_F7)
 	/usr/bin/stm32flash -v -w bin/$(BINBIN_F7) -g 0x0 -R -c /dev/ttyAMA0
 endif

-deploy-f7m: deploy-pi-f7
+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:
@@ -25,7 +25,7 @@ STARTUP:=$(SYSDIR)/startup_stm32f105xc.S
 STARTUP_DEFS=

 # Include directory for CMSIS
-CMSISDIR:=/opt/STM32Cube_FW_F1_V1.4.0/Drivers/CMSIS
+CMSISDIR:=STM32F10X_Lib/CMSIS

 # Libraries
 LIBDIR:=
@@ -65,7 +65,7 @@ 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)
+COMMON_FLAGS+= -D$(MCU) -DMADEBYMAKEFILE -DSTM32F1
 COMMON_FLAGS+= -Os -flto -ffunction-sections -fdata-sections
 COMMON_FLAGS+= -g
 # Assembler flags
@@ -91,7 +91,7 @@ DEPENDS:=$(CSRC:%.c=$(OBJDIR)/%.d) $(CXXSRC:%.cpp=$(OBJDIR)/%.d)

 # Targets
 .PHONY: all
-all: $(DIS) $(HEX)
+all: GitVersion.h $(DIS) $(HEX)
 	$(SIZE) $(ELF)

 .PHONY: program
@@ -116,7 +116,7 @@ debug: $(ELF)

 .PHONY: clean
 clean:
-	$(RM) $(OBJ) $(HEX) $(ELF) $(DIS) $(MAP) $(DEPENDS)
+	$(RM) $(OBJ) $(HEX) $(ELF) $(DIS) $(MAP) $(DEPENDS) GitVersion.h

 # implicit rules
 .elf.hex:
@@ -149,3 +149,17 @@ $(DIS): $(ELF)

 # 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
@@ -45,7 +45,7 @@ const uint8_t NXDN_PREAMBLE[] = {0x57U, 0x75U, 0xFDU};
 const uint8_t NXDN_SYNC = 0x5FU;

 CNXDNTX::CNXDNTX() :
-m_buffer(4000U),
+m_buffer(TX_BUFFER_LEN),
 m_modFilter(),
 m_sincFilter(),
 m_modState(),
@@ -47,6 +47,11 @@ const unsigned int P25_TSDU_FRAME_LENGTH_BITS      = P25_TSDU_FRAME_LENGTH_BYTES
 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;
@@ -199,7 +199,19 @@ void CP25RX::processHdr(q15_t sample)
                serial.writeP25Hdr(frame, P25_HDR_FRAME_LENGTH_BYTES + 1U);
            }
            break;
-        case P25_DUID_TSDU: {
+		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);
@@ -43,7 +43,7 @@ const q15_t P25_LEVELD = -1260;
 const uint8_t P25_START_SYNC = 0x77U;

 CP25TX::CP25TX() :
-m_buffer(4000U),
+m_buffer(TX_BUFFER_LEN),
 m_modFilter(),
 m_lpFilter(),
 m_modState(),
@@ -87,6 +87,14 @@ void CPOCSAGTX::process()
  }
 }

+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)
@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018 by Jonathan Naylor G4KLX
+ *   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
@@ -29,12 +29,16 @@ public:

  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:
  CSerialRB            m_buffer;
  arm_fir_instance_q15 m_modFilter;
@@ -43,8 +47,6 @@ private:
  uint16_t             m_poLen;
  uint16_t             m_poPtr;
  uint16_t             m_txDelay;
-
-  void writeByte(uint8_t c);
 };

 #endif
@@ -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)
 {
@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2013,2015,2016,2017,2018 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
@@ -65,12 +65,17 @@ 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_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;
@@ -90,14 +95,20 @@ const uint8_t MMDVM_DEBUG5       = 0xF5U;
 #define TCXO "NO TCXO"
 #endif

-#define DESCRIPTION              "MMDVM 20180327 (D-Star/DMR/System Fusion/P25/NXDN/POCSAG)"
+#if defined(STM32F4_RPT_HAT_TGO)
+#define	HW_TYPE	"MMDVM RPT_HAT_TGO"
+#else
+#define	HW_TYPE	"MMDVM"
+#endif
+
+#define DESCRIPTION "20200425 (D-Star/DMR/System Fusion/P25/NXDN/POCSAG/FM)"

 #if defined(GITVERSION)
-#define concat(a, b, c) a " " b " GitID #" c ""
-const char HARDWARE[] = concat(DESCRIPTION, TCXO, GITVERSION);
+#define concat(h, a, b, c) h " " a " " b " GitID #" c ""
+const char HARDWARE[] = concat(HW_TYPE, DESCRIPTION, TCXO, GITVERSION);
 #else
-#define concat(a, b, c, d) a " " b " (Build: " c " " d ")"
-const char HARDWARE[] = concat(DESCRIPTION, TCXO, __TIME__, __DATE__);
+#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;
@@ -161,6 +172,8 @@ void CSerialPort::getStatus()
    reply[3U] |= 0x10U;
  if (m_pocsagEnable)
    reply[3U] |= 0x20U;
+  if (m_fmEnable)
+    reply[3U] |= 0x40U;

  reply[4U]  = uint8_t(m_modemState);

@@ -249,7 +262,7 @@ void CSerialPort::getVersion()

 uint8_t CSerialPort::setConfig(const uint8_t* data, uint8_t length)
 {
-  if (length < 18U)
+  if (length < 19U)
    return 4U;

  bool rxInvert  = (data[0U] & 0x01U) == 0x01U;
@@ -266,6 +279,7 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint8_t length)
  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)
@@ -273,7 +287,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_NXDN && modemState != STATE_POCSAG && modemState != STATE_DSTARCAL && modemState != STATE_DMRCAL && modemState != STATE_RSSICAL && modemState != STATE_LFCAL && modemState != STATE_DMRCAL1K && modemState != STATE_P25CAL1K && modemState != STATE_DMRDMO1K && modemState != STATE_NXDNCAL1K)
+  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)
    return 4U;
  if (modemState == STATE_DSTAR && !dstarEnable)
    return 4U;
@@ -287,6 +301,8 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint8_t length)
    return 4U;
  if (modemState == STATE_POCSAG && !pocsagEnable)
    return 4U;
+  if (modemState == STATE_FM && !fmEnable)
+    return 4U;

  uint8_t rxLevel = data[4U];

@@ -311,6 +327,8 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint8_t length)

  uint8_t pocsagTXLevel = data[17U];

+  uint8_t fmTXLevel     = data[18U];
+
  m_modemState  = modemState;

  m_dstarEnable  = dstarEnable;
@@ -319,6 +337,7 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint8_t length)
  m_p25Enable    = p25Enable;
  m_nxdnEnable   = nxdnEnable;
  m_pocsagEnable = pocsagEnable;
+  m_fmEnable     = fmEnable;
  m_duplex       = !simplex;

  dstarTX.setTXDelay(txDelay);
@@ -336,13 +355,80 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint8_t length)

  ysfTX.setParams(ysfLoDev, ysfTXHang);

-  io.setParameters(rxInvert, txInvert, pttInvert, rxLevel, cwIdTXLevel, dstarTXLevel, dmrTXLevel, ysfTXLevel, p25TXLevel, nxdnTXLevel, pocsagTXLevel, txDCOffset, rxDCOffset);
+  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;
+
+  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);
+}
+
+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 < 10U)
+    return 4U;
+
+  uint16_t timeout        = data[0U] * 5U;
+  uint8_t  timeoutLevel   = data[1U];
+
+  uint8_t  ctcssFrequency = data[2U];
+  uint8_t  ctcssThreshold = data[3U];
+  uint8_t  ctcssLevel     = data[4U];
+
+  uint8_t  kerchunkTime   = data[5U];
+  uint8_t  hangTime       = data[6U];
+
+  bool     useCOS         = (data[7U] & 0x01U) == 0x01U;
+
+  uint8_t  rxBoost        = data[8U];
+  uint8_t  maxDev         = data[9U];
+
+  return fm.setMisc(timeout, timeoutLevel, ctcssFrequency, ctcssThreshold, ctcssLevel, kerchunkTime, hangTime, useCOS, rxBoost, maxDev);
+}
+
 uint8_t CSerialPort::setMode(const uint8_t* data, uint8_t length)
 {
  if (length < 1U)
@@ -353,7 +439,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_NXDN && modemState != STATE_POCSAG && modemState != STATE_DSTARCAL && modemState != STATE_DMRCAL && modemState != STATE_RSSICAL && modemState != STATE_LFCAL && modemState != STATE_DMRCAL1K && modemState != STATE_P25CAL1K && modemState != STATE_DMRDMO1K && modemState != STATE_NXDNCAL1K)
+  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)
    return 4U;
  if (modemState == STATE_DSTAR && !m_dstarEnable)
    return 4U;
@@ -367,6 +453,8 @@ uint8_t CSerialPort::setMode(const uint8_t* data, uint8_t length)
    return 4U;
  if (modemState == STATE_POCSAG && !m_pocsagEnable)
    return 4U;
+  if (modemState == STATE_FM && !m_fmEnable)
+    return 4U;

  setMode(modemState);

@@ -378,157 +466,80 @@ void CSerialPort::setMode(MMDVM_STATE modemState)
  switch (modemState) {
    case STATE_DMR:
      DEBUG1("Mode set to DMR");
-      dstarRX.reset();
-      ysfRX.reset();
-      p25RX.reset();
-      nxdnRX.reset();
-      cwIdTX.reset();
      break;
    case STATE_DSTAR:
      DEBUG1("Mode set to D-Star");
-      dmrIdleRX.reset();
-      dmrDMORX.reset();
-      dmrRX.reset();
-      ysfRX.reset();
-      p25RX.reset();
-      nxdnRX.reset();
-      cwIdTX.reset();
      break;
    case STATE_YSF:
      DEBUG1("Mode set to System Fusion");
-      dmrIdleRX.reset();
-      dmrDMORX.reset();
-      dmrRX.reset();
-      dstarRX.reset();
-      p25RX.reset();
-      nxdnRX.reset();
-      cwIdTX.reset();
      break;
    case STATE_P25:
      DEBUG1("Mode set to P25");
-      dmrIdleRX.reset();
-      dmrDMORX.reset();
-      dmrRX.reset();
-      dstarRX.reset();
-      ysfRX.reset();
-      nxdnRX.reset();
-      cwIdTX.reset();
      break;
    case STATE_NXDN:
      DEBUG1("Mode set to NXDN");
-      dmrIdleRX.reset();
-      dmrDMORX.reset();
-      dmrRX.reset();
-      dstarRX.reset();
-      ysfRX.reset();
-      p25RX.reset();
-      cwIdTX.reset();
      break;
    case STATE_POCSAG:
      DEBUG1("Mode set to POCSAG");
-      dmrIdleRX.reset();
-      dmrDMORX.reset();
-      dmrRX.reset();
-      dstarRX.reset();
-      ysfRX.reset();
-      p25RX.reset();
-      nxdnRX.reset();
-      cwIdTX.reset();
+      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();
-      nxdnRX.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();
-      nxdnRX.reset();
-      cwIdTX.reset();
      break;
    case STATE_RSSICAL:
      DEBUG1("Mode set to RSSI Calibrate");
-      dmrIdleRX.reset();
-      dmrDMORX.reset();
-      dmrRX.reset();
-      dstarRX.reset();
-      ysfRX.reset();
-      p25RX.reset();
-      nxdnRX.reset();
-      cwIdTX.reset();
      break;
    case STATE_LFCAL:
      DEBUG1("Mode set to 80 Hz Calibrate");
-      dmrIdleRX.reset();
-      dmrDMORX.reset();
-      dmrRX.reset();
-      dstarRX.reset();
-      ysfRX.reset();
-      p25RX.reset();
-      nxdnRX.reset();
-      cwIdTX.reset();
      break;
    case STATE_DMRCAL1K:
      DEBUG1("Mode set to DMR BS 1031 Hz Calibrate");
-      dmrIdleRX.reset();
-      dmrDMORX.reset();
-      dmrRX.reset();
-      dstarRX.reset();
-      ysfRX.reset();
-      p25RX.reset();
-      nxdnRX.reset();
-      cwIdTX.reset();
      break;
    case STATE_P25CAL1K:
      DEBUG1("Mode set to P25 1011 Hz Calibrate");
-      dmrIdleRX.reset();
-      dmrDMORX.reset();
-      dmrRX.reset();
-      dstarRX.reset();
-      ysfRX.reset();
-      p25RX.reset();
-      nxdnRX.reset();
-      cwIdTX.reset();
      break;
    case STATE_DMRDMO1K:
      DEBUG1("Mode set to DMR MS 1031 Hz Calibrate");
-      dmrIdleRX.reset();
-      dmrDMORX.reset();
-      dmrRX.reset();
-      dstarRX.reset();
-      ysfRX.reset();
-      p25RX.reset();
-      nxdnRX.reset();
-      cwIdTX.reset();
      break;
    case STATE_NXDNCAL1K:
      DEBUG1("Mode set to NXDN 1031 Hz Calibrate");
-      dmrIdleRX.reset();
-      dmrDMORX.reset();
-      dmrRX.reset();
-      dstarRX.reset();
-      ysfRX.reset();
-      p25RX.reset();
-      nxdnRX.reset();
-      cwIdTX.reset();
      break;
-    default:
+    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();
@@ -601,6 +612,36 @@ 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_CAL_DATA:
            if (m_modemState == STATE_DSTARCAL)
              err = calDStarTX.write(m_buffer + 3U, m_len - 3U);
@@ -610,6 +651,8 @@ void CSerialPort::process()
              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 {
@@ -814,6 +857,7 @@ void CSerialPort::process()
            break;

          case MMDVM_TRANSPARENT:
+          case MMDVM_QSO_INFO:
            // Do nothing on the MMDVM.
            break;

@@ -73,6 +73,9 @@ 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);

  // Hardware versions
  void    beginInt(uint8_t n, int speed);
@@ -83,4 +86,3 @@ private:
 };

 #endif
-
@@ -32,7 +32,7 @@ Boston, MA  02110-1301, USA.
 #include <Arduino.h>
 #endif

-const uint16_t SERIAL_RINGBUFFER_SIZE = 2000U;
+const uint16_t SERIAL_RINGBUFFER_SIZE = 370U;

 class CSerialRB {
 public:
@@ -28,13 +28,13 @@ Pin definitions:

 - Host communication:
 USART1 - TXD PA9  - RXD PA10 (MMDVM-Pi board, MMDVM-Pi F722 board, MMDVM-F4M board, STM32F722-F7M board, STM32F4-DVM board)
-USART2 - TXD PA2  - RXD PA3  (Nucleo64 F446RE board, Morpho or Arduino header)
+USART2 - TXD PA2  - RXD PA3  (Nucleo64 F446RE board, Morpho or Arduino header, MMDVM_RPT_Hat BG4TGO/BG5HHP board)
 USART3 - TXD PC10 - RXD PC11 (Discovery board)
 USART3 - TXD PD8  - RXD PD9  (Nucleo144 F767ZI board)

 - Serial repeater:
 USART1 - TXD PA9  - RXD PA10 (Nucleo with Arduino header)
-UART5  - TXD PC12 - RXD PD2 (Discovery, MMDVM-Pi, MMDVM-Pi F722 board, MMDVM-F4M board, STM32F722-F7M board, STM32F4-DVM board, Nucleo64 with Morpho header and Nucleo144 F767ZI)
+UART5  - TXD PC12 - RXD PD2 (Discovery, MMDVM-Pi, MMDVM-Pi F722 board, MMDVM-F4M board, STM32F722-F7M board, STM32F4-DVM board, Nucleo64 with Morpho header and Nucleo144 F767ZI, MMDVM_RPT_Hat BG4TGO/BG5HHP board)
 */

 #if defined(STM32F4XX) || defined(STM32F7XX)
@@ -50,7 +50,7 @@ extern "C" {
 }

 /* ************* USART1 ***************** */
-#if defined(STM32F4_PI) || defined(STM32F4_F4M) || defined(STM32F722_F7M) || defined(STM32F722_PI) || defined(STM32F4_DVM) || (defined(STM32F4_NUCLEO) && defined(STM32F4_NUCLEO_ARDUINO_HEADER))
+#if defined(STM32F4_PI) || defined(STM32F4_F4M) || defined(STM32F722_F7M) || defined(STM32F722_PI) || defined(STM32F722_RPT_HAT) || defined(STM32F4_DVM) || (defined(STM32F4_NUCLEO) && defined(STM32F4_NUCLEO_ARDUINO_HEADER))

 volatile uint8_t  TXSerialfifo1[TX_SERIAL_FIFO_SIZE];
 volatile uint8_t  RXSerialfifo1[RX_SERIAL_FIFO_SIZE];
@@ -241,7 +241,7 @@ void WriteUSART1(const uint8_t* data, uint16_t length)
 #endif

 /* ************* USART2 ***************** */
-#if defined(STM32F4_NUCLEO)
+#if defined(STM32F4_NUCLEO) || defined(STM32F4_RPT_HAT_TGO)

 volatile uint8_t  TXSerialfifo2[TX_SERIAL_FIFO_SIZE];
 volatile uint8_t  RXSerialfifo2[RX_SERIAL_FIFO_SIZE];
@@ -841,9 +841,9 @@ void CSerialPort::beginInt(uint8_t n, int speed)
      case 1U:
         #if defined(STM32F4_DISCOVERY) || defined(STM32F7_NUCLEO)
         InitUSART3(speed);
-         #elif defined(STM32F4_PI) || defined(STM32F4_F4M) || defined(STM32F722_PI) || defined(STM32F722_F7M) || defined(STM32F4_DVM)
+         #elif defined(STM32F4_PI) || defined(STM32F4_F4M) || defined(STM32F722_PI) || defined(STM32F722_F7M) || defined(STM32F722_RPT_HAT) || defined(STM32F4_DVM)
         InitUSART1(speed);
-         #elif defined(STM32F4_NUCLEO)
+         #elif defined(STM32F4_NUCLEO) || defined(STM32F4_RPT_HAT_TGO)
         InitUSART2(speed);
         #endif
         break;
@@ -865,9 +865,9 @@ int CSerialPort::availableInt(uint8_t n)
      case 1U:
         #if defined(STM32F4_DISCOVERY) || defined(STM32F7_NUCLEO)
         return AvailUSART3();
-         #elif defined(STM32F4_PI) || defined(STM32F4_F4M) || defined(STM32F722_PI) || defined(STM32F722_F7M) || defined(STM32F4_DVM)
+         #elif defined(STM32F4_PI) || defined(STM32F4_F4M) || defined(STM32F722_PI) || defined(STM32F722_F7M) || defined(STM32F722_RPT_HAT) || defined(STM32F4_DVM)
         return AvailUSART1();
-         #elif defined(STM32F4_NUCLEO)
+         #elif defined(STM32F4_NUCLEO) || defined(STM32F4_RPT_HAT_TGO)
         return AvailUSART2();
         #endif
      case 3U:
@@ -887,9 +887,9 @@ int CSerialPort::availableForWriteInt(uint8_t n)
      case 1U:
         #if defined(STM32F4_DISCOVERY) || defined(STM32F7_NUCLEO)
         return AvailForWriteUSART3();
-         #elif defined(STM32F4_PI) || defined(STM32F4_F4M) || defined(STM32F722_PI) || defined(STM32F722_F7M) || defined(STM32F4_DVM)
+         #elif defined(STM32F4_PI) || defined(STM32F4_F4M) || defined(STM32F722_PI) || defined(STM32F722_F7M) || defined(STM32F722_RPT_HAT) || defined(STM32F4_DVM)
         return AvailForWriteUSART1();
-         #elif defined(STM32F4_NUCLEO)
+         #elif defined(STM32F4_NUCLEO) || defined(STM32F4_RPT_HAT_TGO)
         return AvailForWriteUSART2();
         #endif
      case 3U:
@@ -909,9 +909,9 @@ uint8_t CSerialPort::readInt(uint8_t n)
      case 1U:
         #if defined(STM32F4_DISCOVERY) || defined(STM32F7_NUCLEO)
         return ReadUSART3();
-         #elif defined(STM32F4_PI) || defined(STM32F4_F4M) || defined(STM32F722_PI) || defined(STM32F722_F7M) || defined(STM32F4_DVM)
+         #elif defined(STM32F4_PI) || defined(STM32F4_F4M) || defined(STM32F722_PI) || defined(STM32F722_F7M) || defined(STM32F722_RPT_HAT) || defined(STM32F4_DVM)
         return ReadUSART1();
-         #elif defined(STM32F4_NUCLEO)
+         #elif defined(STM32F4_NUCLEO) || defined(STM32F4_RPT_HAT_TGO)
         return ReadUSART2();
         #endif
      case 3U:
@@ -933,11 +933,11 @@ void CSerialPort::writeInt(uint8_t n, const uint8_t* data, uint16_t length, bool
         WriteUSART3(data, length);
         if (flush)
            TXSerialFlush3();
-         #elif defined(STM32F4_PI) || defined(STM32F4_F4M) || defined(STM32F722_PI) || defined(STM32F722_F7M) || defined(STM32F4_DVM)
+         #elif defined(STM32F4_PI) || defined(STM32F4_F4M) || defined(STM32F722_PI) || defined(STM32F722_F7M) || defined(STM32F722_RPT_HAT) || defined(STM32F4_DVM)
         WriteUSART1(data, length);
         if (flush)
            TXSerialFlush1();
-         #elif defined(STM32F4_NUCLEO)
+         #elif defined(STM32F4_NUCLEO) || defined(STM32F4_RPT_HAT_TGO)
         WriteUSART2(data, length);
         if (flush)
            TXSerialFlush2();
@@ -44,7 +44,7 @@ const uint8_t YSF_END_SYNC   = 0xFFU;
 const uint8_t YSF_HANG       = 0x00U;

 CYSFTX::CYSFTX() :
-m_buffer(4000U),
+m_buffer(TX_BUFFER_LEN),
 m_modFilter(),
 m_modState(),
 m_poBuffer(),
@@ -83,7 +83,7 @@ EOF
    "3")  sed -e 's/\/\/ #define EXTERNAL_OSC 14400000/#define EXTERNAL_OSC 14400000/'     $conf > $conf.tmp && mv -f $conf.tmp $conf && echo "14.400 MHz clock enabled";;
    "4")  sed -e 's/\/\/ #define EXTERNAL_OSC 19200000/#define EXTERNAL_OSC 19200000/'     $conf > $conf.tmp && mv -f $conf.tmp $conf && echo "19.200 MHz clock enabled";;
    "5")  sed -e 's/\/\/ #define USE_COS_AS_LOCKOUT /#define USE_COS_AS_LOCKOUT/'          $conf > $conf.tmp && mv -f $conf.tmp $conf && echo "COS as Lockout enabled";;
-    "6")  sed -e 's/\/\/ #define MODE_PINS/#define MODE_PINS/'             $conf > $conf.tmp && mv -f $conf.tmp $conf && echo "Mode pins enabled";;
+    "6")  sed -e 's/\/\/ #define MODE_LEDS/#define MODE_LEDS/'             $conf > $conf.tmp && mv -f $conf.tmp $conf && echo "Mode pins enabled";;
    "7")  sed -e 's/\/\/ #define ARDUINO_DUE_PAPA/#define ARDUINO_DUE_PAPA/'               $conf > $conf.tmp && mv -f $conf.tmp $conf && echo "Layout for the PAPA board enabled";;
    "8")  sed -e 's/\/\/ #define ARDUINO_DUE_ZUM_V10/#define ARDUINO_DUE_ZUM_V10/'         $conf > $conf.tmp && mv -f $conf.tmp $conf && echo "Layout for ZUM V1.0 and V1.0.1 boards enabled";;
    "9")  sed -e 's/\/\/ #define ARDUINO_DUE_NTH/#define ARDUINO_DUE_NTH/'                 $conf > $conf.tmp && mv -f $conf.tmp $conf && echo "Layout for SP8NTH board enabled";;
Author	SHA1	Message	Date
Jonathan Naylor	bd4096b6be	Revert "Make CTCSS threshold RXLevel and RXBoost agnostic"	2020-04-25 23:48:02 +01:00
Jonathan Naylor	f92d93772c	Merge branch 'FM' of https://github.com/g4klx/MMDVM into FM	2020-04-25 22:32:37 +01:00
Jonathan Naylor	b963b2b848	Add optional over deviation blanking.	2020-04-25 22:32:10 +01:00
Jonathan Naylor	9dadb51f11	Merge pull request #229 from F4FXL/FM Make CTCSS threshold RXLevel and RXBoost agnostic	2020-04-25 22:13:09 +01:00
Geoffrey Merck	23cf22d87d	remove Debug info	2020-04-25 23:07:41 +02:00
Geoffrey Merck	d2d50e21e1	CTCSS threshold is level agnostic, experimental	2020-04-25 22:12:16 +02:00
Jonathan Naylor	8c38fdb36d	Clean out the CTCSS decoder coefficient before initialising.	2020-04-25 17:37:37 +01:00
Jonathan Naylor	4fe1c11250	Remove memory leak and other configuration funnies.	2020-04-25 17:29:10 +01:00
Jonathan Naylor	394ab8dfd1	Merge pull request #228 from m0vse/FM Fix for Ack/Callsign corruption in FM branch	2020-04-25 16:24:10 +01:00
m0vse	5295e0bdc3	Fix for Ack/Callsign corruption	2020-04-25 16:13:13 +01:00
Jonathan Naylor	c638dbe55a	Merge branch 'FM' of https://github.com/g4klx/MMDVM into FM	2020-04-25 15:17:53 +01:00
Jonathan Naylor	6ac6deba10	Add two more FM parameters.	2020-04-25 15:17:11 +01:00
Jonathan Naylor	d2ce76fe89	Merge pull request #227 from F4FXL/FM Fix STM32F10X compile complaining about duplicate stuff	2020-04-25 08:12:03 +01:00
Geoffrey Merck	0b27ec5443	Fix STM32F10X compile complaining about duplicate stuff	2020-04-25 08:05:31 +02:00
Jonathan Naylor	868d33ebd2	Rescale the CTCSS TX level.	2020-04-24 15:00:40 +01:00
Jonathan Naylor	9fab1e0823	Rescale some of the tone levels.	2020-04-24 13:13:25 +01:00
Jonathan Naylor	242bc7b322	Bump the version date.	2020-04-24 12:54:50 +01:00
Jonathan Naylor	e5c25f55fe	Remove the FM RX level.	2020-04-24 12:51:10 +01:00
Jonathan Naylor	33f88344c3	Run the holdoff timer permamnently.	2020-04-24 12:15:58 +01:00
Jonathan Naylor	103d937152	Remove unneeded line.	2020-04-24 11:52:47 +01:00
Jonathan Naylor	e721dedf1e	Merge pull request #225 from F4FXL/FM Add FM Filtering	2020-04-24 08:46:45 +01:00
Geoffrey Merck	176e067ab9	Merge branch 'FM' of https://github.com/F4FXL/MMDVM into FM	2020-04-24 09:41:14 +02:00
Geoffrey Merck	2057ef5206	clean up	2020-04-24 09:40:06 +02:00
Geoffrey Merck	5c2659deaa	Add FM filtering	2020-04-24 09:40:06 +02:00
Geoffrey Merck	4f9d5a8c70	3rd order IIR	2020-04-24 09:40:06 +02:00
Geoffrey Merck	8ecd8b67f4	Using 2 stage IIR filter	2020-04-24 09:40:06 +02:00
Geoffrey Merck	22c40e1d96	Remove bit roation	2020-04-24 09:40:03 +02:00
Geoffrey Merck	a720ceeb54	clean up	2020-04-24 09:21:13 +02:00
Geoffrey Merck	f8d082e2dd	Add FM filtering	2020-04-24 09:10:50 +02:00
Geoffrey Merck	507a4bf64c	3rd order IIR	2020-04-23 22:37:29 +02:00
Jonathan Naylor	7a75db2aeb	Remove the bit shift of the sample.	2020-04-23 21:30:41 +01:00
Geoffrey Merck	ce0aebce48	Using 2 stage IIR filter	2020-04-23 21:16:52 +02:00
Geoffrey Merck	906de3ad11	Remove bit roation	2020-04-23 21:16:20 +02:00
Jonathan Naylor	bf5ad25609	A working fixed point Goertzel based on simulations.	2020-04-23 12:36:34 +01:00
Jonathan Naylor	f19009b132	Allow for two levels of the callsign.	2020-04-22 22:10:34 +01:00
Jonathan Naylor	526a53cd8c	Use fixed point for the Goertzel algorithm.	2020-04-22 17:40:01 +01:00
Jonathan Naylor	57730d7f81	Implement an efficient FIR filter.	2020-04-22 14:37:23 +01:00
Jonathan Naylor	f936bc6fe8	Use a shorter filter.	2020-04-22 14:15:07 +01:00
Jonathan Naylor	3f1f1d1586	Small tidy-ups.	2020-04-22 14:08:34 +01:00
Jonathan Naylor	7940025095	Merge pull request #223 from F4FXL/FM One loop to rule them all !	2020-04-22 13:30:56 +01:00
Geoffrey Merck	63847ebe62	One loop to rule them all ! Change CFM::Samples and CFMCTCSSRX::process to be able to process all stuff in one and only loop.	2020-04-22 11:04:27 +02:00
Jonathan Naylor	03f5056236	Small code cleanups.	2020-04-21 22:30:28 +01:00
Jonathan Naylor	23ff29c8f1	Merge pull request #222 from F4FXL/FM Almost working FM	2020-04-21 22:09:58 +01:00
Geoffrey Merck	1b0229ca6c	Attemp to do filtering	2020-04-21 23:03:30 +02:00
Geoffrey Merck	ae6cbcd9e7	Minor clean up	2020-04-21 22:43:59 +02:00
Geoffrey Merck	1c599138ad	GetAudio do not take any arguments	2020-04-21 22:00:11 +02:00
Geoffrey Merck	9170c398be	Reenable CTCSS	2020-04-21 21:36:30 +02:00
Geoffrey Merck	04fd9838b5	Fix state machine wrong kerchunk	2020-04-21 21:00:09 +02:00
Geoffrey Merck	8d340cbfba	(almost) One loop to rule all the samples Avoid looping over and over the samples. One	2020-04-21 20:38:02 +02:00
Geoffrey Merck	87c3b57ae4	Stripping ut stuff, testing	2020-04-21 18:45:11 +02:00
Geoffrey Merck	7befef2f4a	Avoid looping samples 2 times, convert each sample on the fly	2020-04-21 18:41:27 +02:00
Geoffrey Merck	b2dcbb2df8	Merge remote-tracking branch 'upstream/FM' into FM	2020-04-21 07:03:35 +02:00
Jonathan Naylor	0a51b4c34e	Store FM output in a ring buffer.	2020-04-20 21:57:21 +01:00
Geoffrey Merck	3b653dca6a	Merge remote-tracking branch 'upstream/FM' into FM	2020-04-20 20:49:58 +02:00
Jonathan Naylor	046a1de51a	Reduce the size of the main FM filter.	2020-04-20 13:54:11 +01:00
Jonathan Naylor	ae58f8eb64	Don't square the threshold value.	2020-04-20 13:28:07 +01:00
Geoffrey Merck	e4c351d5d0	delete old BS	2020-04-20 07:46:03 +02:00
Geoffrey Merck	0b0a59497f	Merge branch 'FM' of https://github.com/F4FXL/MMDVM into FM	2020-04-20 07:43:07 +02:00
Geoffrey Merck	939b019592	delete old BS	2020-04-20 07:42:39 +02:00
Geoffrey Merck	3d54519dbf	add CTCSS decoder	2020-04-20 07:42:39 +02:00
Geoffrey Merck	94f566aacc	Add Goertzel	2020-04-20 07:42:39 +02:00
Geoffrey Merck	a765e863c0	delete old BS	2020-04-20 07:42:39 +02:00
Geoffrey Merck	9e552ba1ab	add CTCSS decoder	2020-04-20 07:39:19 +02:00
Geoffrey Merck	b03fead62d	Add Goertzel	2020-04-20 07:39:19 +02:00
Geoffrey Merck	2825c25607	Merge remote-tracking branch 'upstream/FM' into FM	2020-04-20 07:23:59 +02:00
Jonathan Naylor	5ed8eeda6f	Allow kerchunk audio to pass through.	2020-04-19 21:40:51 +01:00
Jonathan Naylor	1aef1a39f2	Revert the CTCSS decoder to floats.	2020-04-19 21:21:10 +01:00
Jonathan Naylor	a310bf0547	Adjust the coefficients again.	2020-04-19 19:46:44 +01:00
Geoffrey Merck	116b51bd8d	delete old BS	2020-04-19 20:45:14 +02:00
Geoffrey Merck	c05e7bf873	Merge branch 'FM' of https://github.com/F4FXL/MMDVM into FM	2020-04-19 20:44:18 +02:00
Geoffrey Merck	c14ae56e2d	delete old BS	2020-04-19 20:43:50 +02:00
Geoffrey Merck	32a71bfbf6	Use long based algorithm	2020-04-19 20:42:57 +02:00
Geoffrey Merck	7435074c0f	add CTCSS decoder	2020-04-19 19:34:47 +02:00
Geoffrey Merck	ec202d7fb9	Add Goertzel	2020-04-19 19:34:47 +02:00
Jonathan Naylor	6575cba982	Rescale the coefficient.	2020-04-19 17:59:04 +01:00
Jonathan Naylor	a17bd9cc1d	Don't scale up the sample values.	2020-04-19 17:37:24 +01:00
Jonathan Naylor	f7e5c2436c	Convert the Goertzel algorithm to Q15 and Q31.	2020-04-19 16:52:11 +01:00
Jonathan Naylor	85816d5bec	Re-add COS.	2020-04-18 16:59:25 +01:00
Jonathan Naylor	ebdba2bdb9	Convert to using floats.	2020-04-18 16:48:30 +01:00
Jonathan Naylor	6d5b864cba	Start the Goertzel development.	2020-04-18 16:07:52 +01:00
Jonathan Naylor	c8a450b00d	Ensure all timers are stopped when we leave FM mode.	2020-04-18 15:51:49 +01:00
Jonathan Naylor	61ccd79c5f	Set up the FM mode pins, partially.	2020-04-18 14:31:21 +01:00
Jonathan Naylor	c55002534e	Rename the Goertzel class to CTCSSRX.	2020-04-18 13:55:34 +01:00
Jonathan Naylor	8ca756ec22	Simplify the FM arguments.	2020-04-18 13:47:41 +01:00
Jonathan Naylor	d1c106b3b8	Add state machine debugging messages.	2020-04-17 18:53:28 +01:00
Jonathan Naylor	564260b2f1	Add the main audio filter.	2020-04-17 18:45:42 +01:00
Jonathan Naylor	4a85122483	CTCSS tones are added to the audio, not replacing it.	2020-04-17 14:11:42 +01:00
Jonathan Naylor	bc889f3d26	Handle some extra edge cases.	2020-04-17 13:11:21 +01:00
Jonathan Naylor	95e76f387c	Complete the CW keyer.	2020-04-16 21:15:15 +01:00
Jonathan Naylor	4a5f985d02	More efficient CTCSS tone generation.	2020-04-16 14:27:33 +01:00
Jonathan Naylor	bbe56f5082	Return configuration errors.	2020-04-16 14:00:31 +01:00
Jonathan Naylor	4b0c3d88f3	More work on the keyer.	2020-04-15 22:41:30 +01:00
Jonathan Naylor	c103ac91b3	Add the CTCSS tone generator.	2020-04-15 19:49:26 +01:00
Jonathan Naylor	ebd87584da	Add the timeout tones.	2020-04-15 18:38:39 +01:00
Jonathan Naylor	a9a985182f	Add the timer class functionality.	2020-04-15 17:18:01 +01:00
Jonathan Naylor	db6fde90e0	Add the intial state machine.	2020-04-15 16:31:49 +01:00
Jonathan Naylor	74228c506e	Add stubs for FM classes.	2020-04-15 15:24:01 +01:00
Geoffrey Merck	bcd43006ac	Merge branch 'FM' of https://github.com/F4FXL/MMDVM into FM	2020-04-14 13:33:59 +02:00
Geoffrey Merck	cf616caef9	add CTCSS decoder	2020-04-14 13:33:35 +02:00
Geoffrey Merck	7ab6e51c2c	Add Goertzel	2020-04-14 13:33:35 +02:00
Jonathan Naylor	7a549e96ba	Handle the net ack parameter.	2020-04-14 12:23:26 +01:00
Geoffrey Merck	3e4d709225	Merge remote-tracking branch 'upstream/FM' into FM	2020-04-14 12:16:54 +02:00
Geoffrey Merck	031563e727	add CTCSS decoder	2020-04-14 12:16:07 +02:00
Geoffrey Merck	3f80248477	Add Goertzel	2020-04-14 12:15:25 +02:00
Jonathan Naylor	c84d81d91c	Add the minimum time for a 'K' parameter.	2020-04-13 15:54:37 +01:00
Jonathan Naylor	ef65268b45	First version of initialisation.	2020-04-12 15:28:56 +01:00
Jonathan Naylor	9d725b9479	Beginnings of FM controller support.	2020-04-11 22:08:17 +01:00
Andy CA6JAU	b4647d8d1b	Merge pull request #214 from veraabad/master Fixed deploy-pi-f7	2019-10-23 21:22:43 -03:00
Abad Vera	f28a22802d	Fixed deploy-pi-f7	2019-10-23 14:36:34 -07:00
Jonathan Naylor	8a60fc1ecb	Fix id string for the rpt_hat_tgo.	2019-07-15 09:06:43 +01:00
Jonathan Naylor	dfad6d8409	Revert "Merge pull request #204 from shawnchain/support_udid" This reverts commit `b94b8afb77`, reversing changes made to `7c863671c9`.	2019-06-04 10:12:53 +01:00
Jonathan Naylor	b94b8afb77	Merge pull request #204 from shawnchain/support_udid Fix HW_TYPE string of RPT_HAT_TGO for MMDVMCal and add UDID support	2019-05-17 08:08:06 +01:00
Shawn Chain	0f37bfa20d	arduino_due support	2019-05-16 23:29:28 +08:00
Shawn Chain	d6d03158d0	Fix HWType string of RPT_HAT_TGO to work with MMDVMCal and add udid support to the firmware	2019-05-16 23:22:27 +08:00
Jonathan Naylor	7c863671c9	Merge pull request #203 from shawnchain/stm32f1 add STM32F10X_Lib for stm32f105 support	2019-05-14 13:24:48 +01:00
Shawn Chain	2a6db2ab52	Make STM32F1_POG as default type when Makefile.CMSIS is used	2019-05-14 11:53:21 +08:00
Shawn Chain	c8a345a301	rollback changes on Config.h	2019-05-14 11:43:29 +08:00
Shawn Chain	37efcb3d4f	add STM32F10X_Lib	2019-05-13 21:59:32 +08:00
Jonathan Naylor	ff7a9fdd4e	Simplify the state change.	2019-03-01 08:00:20 +00:00
Jonathan Naylor	9ccbb842bf	Merge branch 'pocsagcal'	2019-01-31 07:56:41 +00:00
Jonathan Naylor	73d3bd5778	Do the POCSAG calibration in a different way.	2019-01-30 14:31:15 +00:00
Jonathan Naylor	f785a5260a	Merge branch 'master' of https://github.com/g4klx/MMDVM	2019-01-30 13:51:22 +00:00
Jonathan Naylor	03716daca0	Bump the version date.	2019-01-30 13:51:05 +00:00
phl0	9987140790	Fix damn typo	2019-01-30 14:49:21 +01:00
phl0	6b00f7d27a	Change to square wave and align amplitude	2019-01-30 14:42:17 +01:00
phl0	98fffb9b77	Fix const compiler issue	2019-01-30 13:02:55 +01:00
Jonathan Naylor	000da1889f	Simplify the POCSAG calibration code.	2019-01-30 11:18:16 +00:00
phl0	0a634b1223	Fix some minor bugs :)	2019-01-30 09:40:09 +01:00
phl0	5456f403a1	Add changes by G4KLX	2019-01-30 09:25:33 +01:00
phl0	461182bf60	1st attempt to send 600Hz sine wave	2019-01-23 16:23:45 +01:00
phl0	580ba0b536	Add synthetic 600Hz sine wave and some more POCSAGCal states	2019-01-23 14:58:01 +01:00
phl0	5e3c4c91bb	Add basics for a POCSAG Cal mode	2019-01-22 22:21:40 +01:00
phl0	3875da80e7	Make MODE_PINS available on MMDVM_RPT_Hat	2018-11-02 15:02:34 +01:00
Jonathan Naylor	6af252f315	Ignore DVMEGA-Cast specific command.	2018-10-31 14:49:57 +00:00
Jonathan Naylor	e46ef4f9ce	Merge pull request #198 from gatekeep/master fix proper PDU reception and processing;	2018-10-09 07:43:11 +01:00
Bryan Biedenkapp	3bae422a8e	fix proper PDU reception and processing;	2018-10-08 10:19:31 -04:00
Andy CA6JAU	d7526891c5	Restore ring buffer default size	2018-10-07 21:10:34 -03:00
Florian (DF2ET)	6563ee2fb2	Merge pull request #195 from shawnchain/master Fixed the concat macro error if no GITVERSION is defined, which is in…	2018-09-18 15:23:36 +02:00
Shawn Chain	c0952d73d1	Fixed the concat macro error if no GITVERSION is defined, which is introduced by my previous changes.	2018-09-18 21:19:50 +08:00
phl0	4d780389bf	Add GitVersion target to Makefile.CMSIS	2018-09-18 10:46:24 +02:00
phl0	5c9abf2eeb	Only need rawRSSI variable if SEND_RSSI is defined	2018-09-18 10:33:33 +02:00
phl0	11997ca017	Fix -Wmisleading-indentation compiler warning	2018-09-18 10:17:51 +02:00
Jonathan Naylor	ed36d13c8f	Merge pull request #194 from shawnchain/rpt_hat_tgo_board Add support for RPT_HAT_TGO board by BG4TGO and BG5HHP	2018-09-18 09:11:42 +01:00
Shawn Chain	119eea161e	Restore the DEFS_DVM for DVM board	2018-09-18 15:46:33 +08:00
Shawn Chain	d67809eda6	Add support for RPT_HAT_TGO board by BG4TGO and BG5HHP	2018-09-15 12:06:41 +08:00
phl0	428d36da90	Rename F7Hat to (MMDVM_)RPT_Hat	2018-08-29 09:49:53 +02:00
phl0	328e88856a	Add MODE_PINS for F7hat boards	2018-08-28 15:22:54 +02:00
Andy CA6JAU	99966e20ad	Reduce buffer sizes for Teensy 3.2/3.1	2018-08-19 12:16:36 -03:00
phl0	1fef7772cb	Add MODE pin for POCSAG	2018-08-08 11:16:16 +02:00
Andy CA6JAU	f8ab4fe9bd	Fix for STM32F105 startup hang	2018-08-06 14:53:47 -04:00
phl0	c2e785cdc4	Generalize MODE_PINS (not F4 specific any more)	2018-08-01 21:12:31 +02:00
phl0	5f19cfcb49	Rename MODE_PINS to MODE_LEDS	2018-08-01 21:09:57 +02:00
Florian (DF2ET)	5405395e1a	Merge pull request #186 from N4IRS/master Add POCSAG Pin for STM32-DVM	2018-07-24 12:05:24 +02:00
Steve N4IRS	3c95d1f604	Add POCSAG Pin for STM32-DVM	2018-07-24 05:58:58 -04:00
Jonathan Naylor	da8023eabf	Bump the version date.	2018-07-23 21:53:36 +01:00
phl0	0d55ba317d	Correct POCSAG LED for F7Hat	2018-07-23 11:39:16 +02:00
Andy CA6JAU	404dc3d99d	Additional check to transmit all POCSAG buffer	2018-07-20 20:31:38 -04:00
Andy CA6JAU	4821d0e959	Fix for missing POCSAG start tone	2018-07-20 14:17:33 -04:00
Jonathan Naylor	db3649827f	Merge pull request #184 from Hootie81/VK6MST_Shield Add support VK6MST_Shield Serial pass-thru	2018-07-20 12:17:01 +01:00
Hootie81	5bec0d0780	Add support VK6MST_Shield Serial pass-thru	2018-07-20 21:00:09 +10:00
Andy CA6JAU	110062bf65	Reduce the size of serial ring buffer	2018-07-20 00:50:53 -04:00
Jonathan Naylor	f3c621307a	Restore the original configuration file.	2018-07-19 18:21:17 +01:00
Jonathan Naylor	03177a05e7	Merge pull request #183 from Hootie81/VK6MST_Shield Add support for VK6MST_Shield	2018-07-19 18:15:57 +01:00
Hootie81	e93b08380d	Add support for VK6MST_Shield	2018-07-19 13:01:20 +00:00
phl0	012b366143	Add POCSAG Pin for F7hat	2018-07-18 22:35:13 +02:00
phl0	fd8bc07b61	Merge branch 'master' into F7hat	2018-07-18 22:30:34 +02:00
phl0	68106058d6	Add missing ifdefines for F7Hat	2018-07-18 21:32:56 +02:00
phl0	d62c945887	Add POCSAG pin defs for f767 target	2018-07-12 07:36:44 +02:00
phl0	0aea9aef38	Correct typo in Makefile	2018-07-12 07:16:40 +02:00
Andy	88409dccd2	Add temporary POCSAG pin definitions for F446 and F722	2018-07-12 00:59:08 -04:00
Jonathan Naylor	f705656178	Bump the version date.	2018-07-05 18:44:31 +01:00
phl0	6b28efc011	Flash F7Hat via GPIO	2018-07-01 01:45:42 +02:00
phl0	8c6289802f	Add support for MMDVM-F7-Hat	2018-07-01 01:41:33 +02:00