diff --git a/FM.cpp b/FM.cpp
index fd0a4f2..367419a 100644
--- a/FM.cpp
+++ b/FM.cpp
@@ -39,15 +39,13 @@ m_hangTimer()
 {
 }
 
-void CFM::samples(bool cos, q15_t* samples, uint8_t length)
+void CFM::samples(q15_t* samples, uint8_t length)
 {
   // De-emphasis
 
-  bool ctcss = m_goertzel.process(samples, length);
+  bool validSignal = m_goertzel.process(samples, length);
 
-  bool validSignal = ctcss && cos;
-
-  stateMachine(validSignal);
+  stateMachine(validSignal, length);
 
   if (m_modemState != STATE_FM)
     return;
@@ -88,15 +86,15 @@ void CFM::setCallsign(const char* callsign, uint8_t speed, uint16_t frequency, u
   m_callsignAtStart = callsignAtStart;
   m_callsignAtEnd   = callsignAtEnd;
 
-  m_holdoffTimer.setTimeout(holdoff);
+  m_holdoffTimer.setTimeout(holdoff, 0U);
 }
 
 void CFM::setAck(const char* rfAck, uint8_t speed, uint16_t frequency, uint8_t minTime, uint16_t delay, uint8_t level)
 {
   m_rfAck.setParams(rfAck, speed, frequency, level);
 
-  m_ackDelayTimer.setTimeout(delay);
-  m_ackMinTimer.setTimeout(minTime);
+  m_ackDelayTimer.setTimeout(0U, delay);
+  m_ackMinTimer.setTimeout(minTime, 0U);
 }
 
 void CFM::setMisc(uint16_t timeout, uint8_t timeoutLevel, uint8_t ctcssFrequency, uint8_t ctcssThreshold, uint8_t ctcssLevel, uint8_t kerchunkTime, uint8_t hangTime)
@@ -105,20 +103,20 @@ void CFM::setMisc(uint16_t timeout, uint8_t timeoutLevel, uint8_t ctcssFrequency
   m_goertzel.setParams(ctcssFrequency, ctcssThreshold);
   m_ctcss.setParams(ctcssFrequency, ctcssLevel);
 
-  m_timeoutTimer.setTimeout(timeout);
-  m_kerchunkTimer.setTimeout(kerchunkTime);
-  m_hangTimer.setTimeout(hangTime);
+  m_timeoutTimer.setTimeout(timeout, 0U);
+  m_kerchunkTimer.setTimeout(kerchunkTime, 0U);
+  m_hangTimer.setTimeout(hangTime, 0U);
 }
 
-void CFM::stateMachine(bool validSignal)
+void CFM::stateMachine(bool validSignal, uint8_t length)
 {
-  m_callsignTimer.clock();
-  m_timeoutTimer.clock();
-  m_holdoffTimer.clock();
-  m_kerchunkTimer.clock();
-  m_ackMinTimer.clock();
-  m_ackDelayTimer.clock();
-  m_hangTimer.clock();
+  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:
diff --git a/FM.h b/FM.h
index fdc38a7..eab9450 100644
--- a/FM.h
+++ b/FM.h
@@ -41,7 +41,7 @@ class CFM {
 public:
   CFM();
 
-  void samples(bool cos, q15_t* samples, uint8_t length);
+  void samples(q15_t* samples, uint8_t length);
 
   void process();
 
@@ -68,7 +68,7 @@ private:
   CFMTimer    m_ackDelayTimer;
   CFMTimer    m_hangTimer;
 
-  void stateMachine(bool validSignal);
+  void stateMachine(bool validSignal, uint8_t length);
   void listeningState(bool validSignal);
   void kerchunkState(bool validSignal);
   void relayingState(bool validSignal);
diff --git a/FMTimer.cpp b/FMTimer.cpp
index 4711b8f..826bc13 100644
--- a/FMTimer.cpp
+++ b/FMTimer.cpp
@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2020 by Jonathan Naylor G4KLX
+ *   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
@@ -21,36 +21,50 @@
 #include "FMTimer.h"
 
 CFMTimer::CFMTimer() :
-m_timeout(0U)
+m_timeout(0U),
+m_timer(0U)
 {
 }
 
-void CFMTimer::setTimeout(uint16_t timeout)
+void CFMTimer::setTimeout(uint16_t secs, uint32_t msecs)
 {
-  m_timeout = timeout;
+  m_timeout = (secs * 24000U) + (msecs * 24U);
 }
 
-uint16_t CFMTimer::getTimeout() const
+uint32_t CFMTimer::getTimeout() const
 {
-  return m_timeout;
+  return m_timeout / 24U;
 }
 
 void CFMTimer::start()
 {
+  if (m_timeout > 0U)
+    m_timer = 1U;
 }
 
 void CFMTimer::stop()
 {
+  m_timer = 0U;
 }
 
-void CFMTimer::clock()
+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;
 }
diff --git a/FMTimer.h b/FMTimer.h
index 1fb0911..00dc343 100644
--- a/FMTimer.h
+++ b/FMTimer.h
@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2020 by Jonathan Naylor G4KLX
+ *   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
@@ -25,22 +25,23 @@ class CFMTimer {
 public:
   CFMTimer();
 
-  void setTimeout(uint16_t timeout);
+  void setTimeout(uint16_t secs, uint32_t msecs);
 
-  uint16_t getTimeout() const;
+  uint32_t getTimeout() const;
 
   void start();
   
   void stop();
 
-  void clock();
+  void clock(uint8_t length);
 
   bool isRunning() const;
   
   bool hasExpired() const;
 
 private:
-  uint16_t m_timeout;
+  uint32_t m_timeout;
+  uint32_t m_timer;
 };
 
 #endif
diff --git a/IO.cpp b/IO.cpp
index 94b0cbb..93a8109 100644
--- a/IO.cpp
+++ b/IO.cpp
@@ -348,7 +348,6 @@ void CIO::process()
       }
 
       if (m_fmEnable) {
-        bool cos = getCOSInt();
         q15_t FMVals[RX_BLOCK_SIZE];
 #if defined(USE_DCBLOCKER)
         for (uint16_t i = 0U; i < RX_BLOCK_SIZE; i++) {
@@ -361,7 +360,7 @@ void CIO::process()
           FMVals[i] = q15_t(__SSAT((res1 >> 15), 16));
         }
 #endif
-        fm.samples(cos, FMVals, RX_BLOCK_SIZE);
+        fm.samples(FMVals, RX_BLOCK_SIZE);
       }
     } else if (m_modemState == STATE_DSTAR) {
       if (m_dstarEnable) {
@@ -422,7 +421,6 @@ void CIO::process()
         nxdnRX.samples(NXDNVals, rssi, RX_BLOCK_SIZE);
       }
     } else if (m_modemState == STATE_FM) {
-      bool cos = getCOSInt();
       q15_t FMVals[RX_BLOCK_SIZE];
 #if defined(USE_DCBLOCKER)
       for (uint16_t i = 0U; i < RX_BLOCK_SIZE; i++) {
@@ -435,7 +433,7 @@ void CIO::process()
         FMVals[i] = q15_t(__SSAT((res1 >> 15), 16));
       }
 #endif
-      fm.samples(cos, FMVals, RX_BLOCK_SIZE);
+      fm.samples(FMVals, RX_BLOCK_SIZE);
     } else if (m_modemState == STATE_DSTARCAL) {
       q15_t GMSKVals[RX_BLOCK_SIZE];
       ::arm_fir_fast_q15(&m_gaussianFilter, samples, GMSKVals, RX_BLOCK_SIZE);
diff --git a/SerialPort.cpp b/SerialPort.cpp
index e893b0e..0d81a09 100644
--- a/SerialPort.cpp
+++ b/SerialPort.cpp
@@ -101,7 +101,7 @@ const uint8_t MMDVM_DEBUG5       = 0xF5U;
 #define	HW_TYPE	"MMDVM"
 #endif
 
-#define DESCRIPTION "20200411 (D-Star/DMR/System Fusion/P25/NXDN/POCSAG/FM)"
+#define DESCRIPTION "20200415 (D-Star/DMR/System Fusion/P25/NXDN/POCSAG/FM)"
 
 #if defined(GITVERSION)
 #define concat(h, a, b, c) h " " a " " b " GitID #" c ""
@@ -413,7 +413,7 @@ uint8_t CSerialPort::setFMParams2(const uint8_t* data, uint8_t length)
 
 uint8_t CSerialPort::setFMParams3(const uint8_t* data, uint8_t length)
 {
-  if (length < 8U)
+  if (length < 7U)
     return 4U;
 
   uint16_t timeout        = data[0U] * 5U;
@@ -426,12 +426,6 @@ uint8_t CSerialPort::setFMParams3(const uint8_t* data, uint8_t length)
   uint8_t  kerchunkTime   = data[5U];
   uint8_t  hangTime       = data[6U];
 
-  char ack[50U];
-  uint8_t n = 0U;
-  for (uint8_t i = 7U; i < length; i++, n++)
-    ack[n] = data[i];
-  ack[n] = '\0';
-
   fm.setMisc(timeout, timeoutLevel, ctcssFrequency, ctcssThreshold, ctcssLevel, kerchunkTime, hangTime);
 
   return 0U;