Merge branch 'master' into AX25

AX25Defines.h

@@ -0,0 +1,36 @@
+/*
+ *   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(AX25DEFINES_H)
+#define  AX25DEFINES_H
+
+const uint8_t AX25_RADIO_SYMBOL_LENGTH = 20U;      // At 24 kHz sample rate
+
+const uint8_t AX25_FRAME_START = 0x7EU;
+const uint8_t AX25_FRAME_END   = 0x7EU;
+const uint8_t AX25_FRAME_ABORT = 0xFEU;
+
+const uint8_t AX25_MAX_ONES    = 5U;
+
+const uint16_t AX25_MIN_FRAME_LENGTH = 17U;        // Callsign (7) + Callsign (7) + Control (1) + Checksum (2)
+
+const uint16_t AX25_MAX_FRAME_LENGTH = 330U;       // Callsign (7) + Callsign (7) + 8 Digipeaters (56) +
+                                                   // Control (1) + PID (1) + Data (256) + Checksum (2)
+
+#endif
+

AX25Demodulator.cpp

@@ -0,0 +1,266 @@
+/*
+ *   Copyright (C) 2020 by Jonathan Naylor G4KLX
+ *   Copyright 2015-2019 Mobilinkd LLC <[email protected]>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   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 "AX25Demodulator.h"
+#include "AX25Defines.h"
+
+const float32_t SAMPLE_RATE = 24000.0F;
+const float32_t SYMBOL_RATE = 1200.0F;
+
+const uint16_t DELAY_LEN = 11U;
+
+const float32_t SAMPLES_PER_SYMBOL = SAMPLE_RATE / SYMBOL_RATE;
+const float32_t PLL_LIMIT          = SAMPLES_PER_SYMBOL / 2.0F;
+
+const uint32_t LPF_FILTER_LEN = 96U;
+
+q15_t LPF_FILTER_COEFFS[] = {
+     0,    0,    0,    1,    2,    5,    8,   12,   18,   23,
+    29,   33,   36,   36,   33,   25,   13,   -5,  -28,  -57,
+   -89, -123, -159, -194, -225, -249, -264, -267, -254, -224,
+  -175, -104,  -12,  102,  236,  389,  557,  738,  926, 1117,
+  1306, 1486, 1654, 1802, 1927, 2025, 2092, 2126, 2126, 2092,
+  2025, 1927, 1802, 1654, 1486, 1306, 1117,  926,  738,  557,
+   389,  236,  102,  -12, -104, -175, -224, -254, -267, -264,
+  -249, -225, -194, -159, -123,  -89,  -57,  -28,   -5,   13,
+    25,   33,   36,   36,   33,   29,   23,   18,   12,    8,
+     5,    2,    1,    0,    0,    0
+};
+
+// 64 Hz loop filter.
+// scipy.signal:
+//      loop_coeffs = firwin(9, [64.0/(1200/2)], width = None,
+//          pass_zero = True, scale = True, window='hann')
+//
+const uint32_t PLL_FILTER_LEN = 7U;
+
+float32_t PLL_FILTER_COEFFS[] = {3.196252e-02F, 1.204223e-01F, 2.176819e-01F, 2.598666e-01F, 2.176819e-01F, 1.204223e-01F, 3.196252e-02F};
+
+CAX25Demodulator::CAX25Demodulator(int8_t n) :
+m_frame(),
+m_twist(n),
+m_lpfFilter(),
+m_lpfState(),
+m_delayLine(NULL),
+m_delayPos(0U),
+m_nrziState(false),
+m_pllFilter(),
+m_pllState(),
+m_pllLast(false),
+m_pllBits(1U),
+m_pllCount(0.0F),
+m_hdlcOnes(0U),
+m_hdlcFlag(false),
+m_hdlcBuffer(0U),
+m_hdlcBits(0U),
+m_hdlcState(AX25_IDLE)
+{
+  m_delayLine = new bool[DELAY_LEN];
+
+  m_lpfFilter.numTaps = LPF_FILTER_LEN;
+  m_lpfFilter.pState  = m_lpfState;
+  m_lpfFilter.pCoeffs = LPF_FILTER_COEFFS;
+
+  m_pllFilter.numTaps = PLL_FILTER_LEN;
+  m_pllFilter.pState  = m_pllState;
+  m_pllFilter.pCoeffs = PLL_FILTER_COEFFS;
+}
+
+bool CAX25Demodulator::process(q15_t* samples, uint8_t length, CAX25Frame& frame)
+{
+  bool result = false;
+
+  q15_t fa[RX_BLOCK_SIZE];
+  m_twist.process(samples, fa, RX_BLOCK_SIZE);
+
+  int16_t buffer[RX_BLOCK_SIZE];
+  for (uint8_t i = 0; i < length; i++) {
+      bool   level = (fa[i] >= 0);
+      bool delayed = delay(level);
+      buffer[i] = (int16_t(level ^ delayed) << 1) - 1;
+  }
+
+  q15_t fc[RX_BLOCK_SIZE];
+  ::arm_fir_fast_q15(&m_lpfFilter, buffer, fc, RX_BLOCK_SIZE);
+
+  for (uint8_t i = 0; i < length; i++) {
+    bool bit = fc[i] >= 0;
+    bool sample = PLL(bit);
+
+    if (sample) {
+      // We will only ever get one frame because there are
+      // not enough bits in a block for more than one.
+      if (result) {
+        HDLC(NRZI(bit));
+      } else {
+        result = HDLC(NRZI(bit));
+        if (result) {
+          // Copy the frame data.
+          ::memcpy(frame.m_data, m_frame.m_data, AX25_MAX_PACKET_LEN);
+          frame.m_length = m_frame.m_length;
+          frame.m_fcs    = m_frame.m_fcs;
+          m_frame.m_length = 0U;
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+bool CAX25Demodulator::delay(bool b)
+{
+  bool r = m_delayLine[m_delayPos];
+
+  m_delayLine[m_delayPos++] = b;
+
+  if (m_delayPos >= DELAY_LEN)
+    m_delayPos = 0U;
+
+  return r;
+}
+
+bool CAX25Demodulator::NRZI(bool b)
+{
+  bool result = (b == m_nrziState);
+
+  m_nrziState = b;
+
+  return result;
+}
+
+bool CAX25Demodulator::PLL(bool input)
+{
+  bool sample = false;
+		
+  if (input != m_pllLast || m_pllBits > 16U) {
+    // Record transition.
+    m_pllLast = input;
+
+    if (m_pllCount > PLL_LIMIT)
+      m_pllCount -= SAMPLES_PER_SYMBOL;
+
+    float32_t offset = m_pllCount / float32_t(m_pllBits);
+    float32_t jitter;
+    ::arm_fir_f32(&m_pllFilter, &offset, &jitter, 1U);
+
+    m_pllCount -= jitter / 2.0F;
+    m_pllBits = 1U;
+  } else {
+    if (m_pllCount > PLL_LIMIT) {
+      sample = true;
+      m_pllCount -= SAMPLES_PER_SYMBOL;
+      m_pllBits++;
+    }
+  }
+
+  m_pllCount += 1.0F;
+
+  return sample;
+}
+
+bool CAX25Demodulator::HDLC(bool b)
+{
+  if (m_hdlcOnes == AX25_MAX_ONES) {
+    if (b) {
+      // flag byte
+      m_hdlcFlag = true;
+    } else {
+      // bit stuffing...
+      m_hdlcFlag = false;
+      m_hdlcOnes = 0U;
+      return false;
+    }
+  }
+
+  m_hdlcBuffer >>= 1;
+  m_hdlcBuffer |= b ? 128U : 0U;
+  m_hdlcBits++;                      // Free-running until Sync byte.
+
+  if (b)
+    m_hdlcOnes++;
+  else
+    m_hdlcOnes = 0U;
+
+  if (m_hdlcFlag) {
+    bool result = false;
+
+    switch (m_hdlcBuffer) {
+      case AX25_FRAME_END:
+        if (m_frame.m_length >= AX25_MIN_FRAME_LENGTH) {
+          result = m_frame.checkCRC();
+          if (!result)
+              m_frame.m_length = 0U;
+        } else {
+            m_frame.m_length = 0U;
+        }
+        m_hdlcState = AX25_SYNC;
+        m_hdlcFlag = false;
+        m_hdlcBits = 0U;
+        break;
+
+      case AX25_FRAME_ABORT:
+        // Frame aborted
+        m_frame.m_length = 0U;
+        m_hdlcState = AX25_IDLE;
+        m_hdlcFlag = false;
+        m_hdlcBits = 0U;
+        break;
+
+      default:
+        break;
+    }
+
+    return result;
+  }
+
+  switch (m_hdlcState) {
+    case AX25_IDLE:
+      break;
+
+    case AX25_SYNC:
+      if (m_hdlcBits == 8U) {    // 8th bit.
+        // Start of frame data.
+        m_hdlcState = AX25_RECEIVE;
+        m_frame.append(m_hdlcBuffer);
+        m_hdlcBits = 0U;
+      }
+      break;
+
+    case AX25_RECEIVE:
+      if (m_hdlcBits == 8U) {    // 8th bit.
+        m_frame.append(m_hdlcBuffer);
+        m_hdlcBits = 0U;
+      }
+      break;
+
+    default:
+      break;
+  }
+
+  return false;
+}
+
+void CAX25Demodulator::setTwist(int8_t n)
+{
+  m_twist.setTwist(n);
+}
+

AX25Demodulator.h

@@ -0,0 +1,67 @@
+/*
+ *   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(AX25Demodulator_H)
+#define  AX25Demodulator_H
+
+#include "Config.h"
+
+#include "AX25Frame.h"
+#include "AX25Twist.h"
+
+enum AX25_STATE {
+  AX25_IDLE,
+  AX25_SYNC,
+  AX25_RECEIVE
+};
+
+class CAX25Demodulator {
+public:
+  CAX25Demodulator(int8_t n);
+
+  bool process(q15_t* samples, uint8_t length, CAX25Frame& frame);
+
+  void setTwist(int8_t n);
+
+private:
+  CAX25Frame           m_frame;
+  CAX25Twist           m_twist;
+  arm_fir_instance_q15 m_lpfFilter;
+  q15_t                m_lpfState[120U];    // NoTaps + BlockSize - 1, 96 + 20 - 1 plus some spare
+  bool*                m_delayLine;
+  uint16_t             m_delayPos;
+  bool                 m_nrziState;
+  arm_fir_instance_f32 m_pllFilter;
+  float32_t            m_pllState[20U];     // NoTaps + BlockSize - 1, 7 + 1 - 1 plus some spare
+  bool                 m_pllLast;
+  uint8_t              m_pllBits;
+  float32_t            m_pllCount;
+  uint16_t             m_hdlcOnes;
+  bool                 m_hdlcFlag;
+  uint16_t             m_hdlcBuffer;
+  uint16_t             m_hdlcBits;
+  AX25_STATE           m_hdlcState;
+
+  bool delay(bool b);
+  bool NRZI(bool b);
+  bool PLL(bool b);
+  bool HDLC(bool b);
+};
+
+#endif
+

AX25Frame.cpp

@@ -0,0 +1,122 @@
+/*
+ *   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 "AX25Frame.h"
+
+const uint16_t CCITT_TABLE[] = {
+	0x0000,0x1189,0x2312,0x329b,0x4624,0x57ad,0x6536,0x74bf,
+	0x8c48,0x9dc1,0xaf5a,0xbed3,0xca6c,0xdbe5,0xe97e,0xf8f7,
+	0x1081,0x0108,0x3393,0x221a,0x56a5,0x472c,0x75b7,0x643e,
+	0x9cc9,0x8d40,0xbfdb,0xae52,0xdaed,0xcb64,0xf9ff,0xe876,
+	0x2102,0x308b,0x0210,0x1399,0x6726,0x76af,0x4434,0x55bd,
+	0xad4a,0xbcc3,0x8e58,0x9fd1,0xeb6e,0xfae7,0xc87c,0xd9f5,
+	0x3183,0x200a,0x1291,0x0318,0x77a7,0x662e,0x54b5,0x453c,
+	0xbdcb,0xac42,0x9ed9,0x8f50,0xfbef,0xea66,0xd8fd,0xc974,
+	0x4204,0x538d,0x6116,0x709f,0x0420,0x15a9,0x2732,0x36bb,
+	0xce4c,0xdfc5,0xed5e,0xfcd7,0x8868,0x99e1,0xab7a,0xbaf3,
+	0x5285,0x430c,0x7197,0x601e,0x14a1,0x0528,0x37b3,0x263a,
+	0xdecd,0xcf44,0xfddf,0xec56,0x98e9,0x8960,0xbbfb,0xaa72,
+	0x6306,0x728f,0x4014,0x519d,0x2522,0x34ab,0x0630,0x17b9,
+	0xef4e,0xfec7,0xcc5c,0xddd5,0xa96a,0xb8e3,0x8a78,0x9bf1,
+	0x7387,0x620e,0x5095,0x411c,0x35a3,0x242a,0x16b1,0x0738,
+	0xffcf,0xee46,0xdcdd,0xcd54,0xb9eb,0xa862,0x9af9,0x8b70,
+	0x8408,0x9581,0xa71a,0xb693,0xc22c,0xd3a5,0xe13e,0xf0b7,
+	0x0840,0x19c9,0x2b52,0x3adb,0x4e64,0x5fed,0x6d76,0x7cff,
+	0x9489,0x8500,0xb79b,0xa612,0xd2ad,0xc324,0xf1bf,0xe036,
+	0x18c1,0x0948,0x3bd3,0x2a5a,0x5ee5,0x4f6c,0x7df7,0x6c7e,
+	0xa50a,0xb483,0x8618,0x9791,0xe32e,0xf2a7,0xc03c,0xd1b5,
+	0x2942,0x38cb,0x0a50,0x1bd9,0x6f66,0x7eef,0x4c74,0x5dfd,
+	0xb58b,0xa402,0x9699,0x8710,0xf3af,0xe226,0xd0bd,0xc134,
+	0x39c3,0x284a,0x1ad1,0x0b58,0x7fe7,0x6e6e,0x5cf5,0x4d7c,
+	0xc60c,0xd785,0xe51e,0xf497,0x8028,0x91a1,0xa33a,0xb2b3,
+	0x4a44,0x5bcd,0x6956,0x78df,0x0c60,0x1de9,0x2f72,0x3efb,
+	0xd68d,0xc704,0xf59f,0xe416,0x90a9,0x8120,0xb3bb,0xa232,
+	0x5ac5,0x4b4c,0x79d7,0x685e,0x1ce1,0x0d68,0x3ff3,0x2e7a,
+	0xe70e,0xf687,0xc41c,0xd595,0xa12a,0xb0a3,0x8238,0x93b1,
+	0x6b46,0x7acf,0x4854,0x59dd,0x2d62,0x3ceb,0x0e70,0x1ff9,
+	0xf78f,0xe606,0xd49d,0xc514,0xb1ab,0xa022,0x92b9,0x8330,
+	0x7bc7,0x6a4e,0x58d5,0x495c,0x3de3,0x2c6a,0x1ef1,0x0f78 };
+
+CAX25Frame::CAX25Frame(const uint8_t* data, uint16_t length) :
+m_data(),
+m_length(0U),
+m_fcs(0U)
+{
+  for (uint16_t i = 0U; i < length && i < (AX25_MAX_PACKET_LEN - 2U); i++)
+    m_data[m_length++] = data[i];
+}
+
+CAX25Frame::CAX25Frame() :
+m_data(),
+m_length(0U),
+m_fcs(0U)
+{
+}
+
+bool CAX25Frame::append(uint16_t c)
+{
+  if (m_length == AX25_MAX_PACKET_LEN)
+    return false;
+
+  m_data[m_length++] = uint8_t(c);
+
+  return true;
+}
+
+bool CAX25Frame::checkCRC()
+{
+  union {
+    uint16_t crc16;
+    uint8_t  crc8[2U];
+  };
+
+  crc16 = 0xFFFFU;
+  for (uint16_t i = 0U; i < (m_length - 2U); i++)
+    crc16 = uint16_t(crc8[1U]) ^ CCITT_TABLE[crc8[0U] ^ m_data[i]];
+
+  crc16 = ~crc16;
+
+  if (crc8[0U] == m_data[m_length - 2U] && crc8[1U] == m_data[m_length - 1U]) {
+    m_fcs = crc16;
+    return true;
+  } else {
+    return false;
+  }
+}
+
+void CAX25Frame::addCRC()
+{
+  union {
+    uint16_t crc16;
+    uint8_t  crc8[2U];
+  };
+
+  crc16 = 0xFFFFU;
+  for (uint16_t i = 0U; i < m_length; i++)
+    crc16 = uint16_t(crc8[1U]) ^ CCITT_TABLE[crc8[0U] ^ m_data[i]];
+
+  crc16 = ~crc16;
+
+  m_fcs = crc16;
+
+  m_data[m_length++] = crc8[0U];
+  m_data[m_length++] = crc8[1U];
+}
+

AX25Frame.h

@@ -0,0 +1,43 @@
+/*
+ *   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(AX25Frame_H)
+#define  AX25Frame_H
+
+#include "Config.h"
+
+const uint16_t AX25_MAX_PACKET_LEN = 300U;
+
+class CAX25Frame {
+public:
+  CAX25Frame(const uint8_t* data, uint16_t length);
+  CAX25Frame();
+
+  bool append(uint16_t c);
+
+  bool checkCRC();
+
+  void addCRC();
+
+  uint8_t  m_data[AX25_MAX_PACKET_LEN];
+  uint16_t m_length;
+  uint16_t m_fcs;
+};
+
+#endif
+

AX25RX.cpp

@@ -0,0 +1,120 @@
+/*
+ *   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 "AX25RX.h"
+
+/*
+ * Generated with Scipy Filter, 152 coefficients, 1100-2300Hz bandpass,
+ * Hann window, starting and ending 0 value coefficients removed.
+ *
+ * np.array(
+ *  firwin2(152,
+ *      [
+ *          0.0,
+ *          1000.0/(sample_rate/2),
+ *          1100.0/(sample_rate/2),
+ *          2350.0/(sample_rate/2),
+ *          2500.0/(sample_rate/2),
+ *          1.0
+ *      ],
+ *      [0,0,1,1,0,0],
+ *      antisymmetric = False,
+ *      window='hann') * 32768,
+ *  dtype=int)[10:-10]
+ */
+const uint32_t FILTER_LEN = 132;
+q15_t FILTER_COEFFS[] = {
+      0,     5,    12,    18,    21,   19,   11,    -2,   -15,   -25,
+    -27,   -21,   -11,    -3,    -5,  -19,  -43,   -69,   -83,   -73,
+    -35,    27,    98,   155,   180,  163,  109,    39,   -20,   -45,
+    -26,    23,    74,    89,    39,  -81, -247,  -407,  -501,  -480,
+   -334,   -92,   175,   388,   479,  429,  275,    99,     5,    68,
+    298,   626,   913,   994,   740,  115, -791, -1770, -2544, -2847,
+  -2509, -1527,   -76,  1518,  2875, 3653, 3653,  2875,  1518,   -76,
+  -1527, -2509, -2847, -2544, -1770, -791,  115,   740,   994,   913,
+    626,   298,    68,     5,    99,  275,  429,   479,   388,   175,
+    -92,  -334,  -480,  -501,  -407, -247,  -81,    39,    89,    74,
+     23,   -26,   -45,   -20,    39,  109,  163,   180,   155,    98,
+     27,   -35,   -73,   -83,   -69,  -43,  -19,    -5,    -3,   -11,
+    -21,   -27,   -25,   -15,    -2,   11,   19,    21,    18,    12,
+      5,     0
+};
+
+CAX25RX::CAX25RX() :
+m_filter(),
+m_state(),
+m_demod1(3),
+m_demod2(6),
+m_demod3(9),
+m_lastFCS(0U),
+m_count(0U)
+{
+  m_filter.numTaps = FILTER_LEN;
+  m_filter.pState  = m_state;
+  m_filter.pCoeffs = FILTER_COEFFS;
+}
+
+void CAX25RX::samples(q15_t* samples, uint8_t length)
+{
+  q15_t output[RX_BLOCK_SIZE];
+  ::arm_fir_fast_q15(&m_filter, samples, output, RX_BLOCK_SIZE);
+
+  m_count++;
+
+  CAX25Frame frame;
+
+  bool ret = m_demod1.process(output, length, frame);
+  if (ret) {
+    if (frame.m_fcs != m_lastFCS || m_count > 2U) {
+      m_lastFCS = frame.m_fcs;
+      m_count   = 0U;
+      serial.writeAX25Data(frame.m_data, frame.m_length - 2U);
+    }
+    DEBUG1("Decoder 1 reported");
+  }
+
+  ret = m_demod2.process(output, length, frame);
+  if (ret) {
+    if (frame.m_fcs != m_lastFCS || m_count > 2U) {
+      m_lastFCS = frame.m_fcs;
+      m_count   = 0U;
+      serial.writeAX25Data(frame.m_data, frame.m_length - 2U);
+    }
+    DEBUG1("Decoder 2 reported");
+  }
+
+  ret = m_demod3.process(output, length, frame);
+  if (ret) {
+    if (frame.m_fcs != m_lastFCS || m_count > 2U) {
+      m_lastFCS = frame.m_fcs;
+      m_count   = 0U;
+      serial.writeAX25Data(frame.m_data, frame.m_length - 2U);
+    }
+    DEBUG1("Decoder 3 reported");
+  }
+}
+
+void CAX25RX::setParams(int8_t twist)
+{
+  m_demod1.setTwist(twist - 3);
+  m_demod2.setTwist(twist);
+  m_demod3.setTwist(twist + 3);
+}
+

AX25RX.h

@@ -0,0 +1,45 @@
+/*
+ *   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(AX25RX_H)
+#define  AX25RX_H
+
+#include "Config.h"
+
+#include "AX25Demodulator.h"
+
+class CAX25RX {
+public:
+  CAX25RX();
+
+  void samples(q15_t* samples, uint8_t length);
+
+  void setParams(int8_t twist);
+
+private:
+  arm_fir_instance_q15 m_filter;
+  q15_t                m_state[160U];    // NoTaps + BlockSize - 1, 132 + 20 - 1 plus some spare
+  CAX25Demodulator     m_demod1;
+  CAX25Demodulator     m_demod2;
+  CAX25Demodulator     m_demod3;
+  uint16_t             m_lastFCS;
+  uint32_t             m_count;
+};
+
+#endif
+

AX25TX.cpp

@@ -0,0 +1,180 @@
+/*
+ *   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 "AX25TX.h"
+
+#include "AX25Defines.h"
+#include "AX25Frame.h"
+
+
+const uint8_t START_FLAG[] = { AX25_FRAME_START };
+const uint8_t END_FLAG[]   = { AX25_FRAME_END };
+
+const uint8_t BIT_MASK_TABLE1[] = { 0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02U, 0x01U };
+
+#define WRITE_BIT1(p,i,b) p[(i)>>3] = (b) ? (p[(i)>>3] | BIT_MASK_TABLE1[(i)&7]) : (p[(i)>>3] & ~BIT_MASK_TABLE1[(i)&7])
+#define READ_BIT1(p,i)    (p[(i)>>3] & BIT_MASK_TABLE1[(i)&7])
+
+const uint8_t BIT_MASK_TABLE2[] = { 0x01U, 0x02U, 0x04U, 0x08U, 0x10U, 0x20U, 0x40U, 0x80U };
+
+#define WRITE_BIT2(p,i,b) p[(i)>>3] = (b) ? (p[(i)>>3] | BIT_MASK_TABLE2[(i)&7]) : (p[(i)>>3] & ~BIT_MASK_TABLE2[(i)&7])
+#define READ_BIT2(p,i)    (p[(i)>>3] & BIT_MASK_TABLE2[(i)&7])
+
+const uint16_t AUDIO_TABLE_LEN = 120U;
+
+const q15_t AUDIO_TABLE_DATA[] = {
+  0, 214, 428, 641, 851, 1060, 1265, 1468, 1666, 1859, 2048, 2230, 2407, 2577, 2740, 2896, 3043, 3182, 3313, 3434, 3546, 3649,
+  3741, 3823, 3895, 3955, 4006, 4045, 4073, 4089, 4095, 4089, 4073, 4045, 4006, 3955, 3895, 3823, 3741, 3649, 3546, 3434, 3313,
+  3182, 3043, 2896, 2740, 2577, 2407, 2230, 2048, 1859, 1666, 1468, 1265, 1060, 851, 641, 428, 214, 0, -214, -428, -641, -851,
+  -1060, -1265, -1468, -1666, -1859, -2047, -2230, -2407, -2577, -2740, -2896, -3043, -3182, -3313, -3434, -3546, -3649, -3741,
+  -3823, -3895, -3955, -4006, -4045, -4073, -4089, -4095, -4089, -4073, -4045, -4006, -3955, -3895, -3823, -3741, -3649, -3546,
+  -3434, -3313, -3182, -3043, -2896, -2740, -2577, -2407, -2230, -2047, -1859, -1666, -1468, -1265, -1060, -851, -641, -428, -214
+};
+
+CAX25TX::CAX25TX() :
+m_twist(-6),
+m_poBuffer(),
+m_poLen(0U),
+m_poPtr(0U),
+m_txDelay(120U),
+m_tablePtr(0U),
+m_nrzi(false)
+{
+}
+
+void CAX25TX::process()
+{
+  if (m_poLen == 0U)
+    return;
+
+  uint16_t space = io.getSpace();
+
+  while (space > AX25_RADIO_SYMBOL_LENGTH) {
+    bool b = READ_BIT1(m_poBuffer, m_poPtr) != 0U;
+    m_poPtr++;
+
+    writeBit(b);
+
+    space -= AX25_RADIO_SYMBOL_LENGTH;
+
+    if (m_poPtr >= m_poLen) {
+      m_poPtr = 0U;
+      m_poLen = 0U;
+      return;
+    }
+  }
+}
+
+uint8_t CAX25TX::writeData(const uint8_t* data, uint16_t length)
+{
+  CAX25Frame frame(data, length);
+  frame.addCRC();
+
+  m_poLen    = 0U;
+  m_poPtr    = 0U;
+  m_nrzi     = false;
+  m_tablePtr = 0U;
+
+  // Add TX delay (already NRZI)
+  for (uint16_t i = 0U; i < m_txDelay; i++, m_poLen++)
+    WRITE_BIT1(m_poBuffer, m_poLen, false);
+
+  // Add the Start Flag
+  for (uint16_t i = 0U; i < 8U; i++, m_poLen++) {
+    bool b1 = READ_BIT1(START_FLAG, i) != 0U;
+    bool b2 = NRZI(b1);
+    WRITE_BIT1(m_poBuffer, m_poLen, b2);
+  }
+
+  uint8_t ones = 0U;
+  for (uint16_t i = 0U; i < (frame.m_length * 8U); i++) {
+    bool b1 = READ_BIT2(frame.m_data, i) != 0U;
+    bool b2 = NRZI(b1);
+    WRITE_BIT1(m_poBuffer, m_poLen, b2);
+    m_poLen++;
+
+    if (b1) {
+      ones++;
+      if (ones == AX25_MAX_ONES) {
+        // Bit stuffing
+        bool b = NRZI(false);
+        WRITE_BIT1(m_poBuffer, m_poLen, b);
+        m_poLen++;
+        ones = 0U;
+      }
+    } else {
+      ones = 0U;
+    }
+  }
+
+  // Add the End Flag
+  for (uint16_t i = 0U; i < 8U; i++, m_poLen++) {
+    bool b1 = READ_BIT1(END_FLAG, i) != 0U;
+    bool b2 = NRZI(b1);
+    WRITE_BIT1(m_poBuffer, m_poLen, b2);
+  }
+
+  return 0U;
+}
+
+void CAX25TX::writeBit(bool b)
+{
+  q15_t in[AX25_RADIO_SYMBOL_LENGTH];
+  for (uint8_t i = 0U; i < AX25_RADIO_SYMBOL_LENGTH; i++) {
+    in[i] = AUDIO_TABLE_DATA[m_tablePtr];
+    if (b)
+      m_tablePtr += 6U;
+    else
+      m_tablePtr += 11U;
+
+    if (m_tablePtr >= AUDIO_TABLE_LEN)
+      m_tablePtr -= AUDIO_TABLE_LEN;
+  }
+
+  q15_t out[AX25_RADIO_SYMBOL_LENGTH];
+  m_twist.process(in, out, AX25_RADIO_SYMBOL_LENGTH);
+
+  io.write(STATE_AX25, out, AX25_RADIO_SYMBOL_LENGTH);
+}
+
+void CAX25TX::setParams(int8_t twist)
+{
+  m_twist.setTwist(twist);
+}
+
+void CAX25TX::setTXDelay(uint8_t delay)
+{
+  m_txDelay = delay * 12U;
+}
+
+uint8_t CAX25TX::getSpace() const
+{
+  return m_poLen == 0U ? 255U : 0U;
+}
+
+bool CAX25TX::NRZI(bool b)
+{
+    bool result = (b == m_nrzi);
+
+    m_nrzi = b;
+
+    return result;
+}
+

AX25TX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020 by Jonathan Naylor G4KLX
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -16,40 +16,38 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#if !defined(M17TX_H)
+#if !defined(AX25TX_H)
-#define  M17TX_H
+#define  AX25TX_H
 
 #include "Config.h"
 
-#include "SerialRB.h"
+#include "AX25Twist.h"
 
-class CM17TX {
+class CAX25TX {
 public:
-  CM17TX();
+  CAX25TX();
 
-  uint8_t writeData(const uint8_t* data, uint8_t length);
+  uint8_t writeData(const uint8_t* data, uint16_t length);
 
   void process();
 
+  void setParams(int8_t twist);
+
   void setTXDelay(uint8_t delay);
 
   uint8_t getSpace() const;
 
-  void setParams(uint8_t txHang);
-
 private:
-  CSerialRB                        m_buffer;
+  CAX25Twist m_twist;
-  arm_fir_interpolate_instance_q15 m_modFilter;
+  uint8_t    m_poBuffer[600U];
-  q15_t                            m_modState[16U];    // blockSize + phaseLength - 1, 4 + 9 - 1 plus some spare
-  uint8_t                          m_poBuffer[1200U];
   uint16_t   m_poLen;
   uint16_t   m_poPtr;
   uint16_t   m_txDelay;
-  uint32_t                         m_txHang;
+  uint16_t   m_tablePtr;
-  uint32_t                         m_txCount;
+  bool       m_nrzi;
 
-  void writeByte(uint8_t c);
+  void writeBit(bool b);
-  void writeSilence();
+  bool NRZI(bool b);
 };
 
 #endif

AX25Twist.cpp

@@ -0,0 +1,311 @@
+/*
+ *   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 "AX25Twist.h"
+
+// 1200Hz = -12dB, 2200Hz = 0dB; 3381Hz cutoff; cosine.
+q15_t dB12[] = {
+  176,
+  -812,
+  -3916,
+  -7586,
+  23536,
+  -7586,
+  -3916,
+  -812,
+  176
+};
+
+// 1200Hz = -11dB, 2200Hz = 0dB; 3258Hz cutoff; cosine.
+q15_t dB11[] = {
+  121,
+  -957,
+  -3959,
+  -7383,
+  23871,
+  -7383,
+  -3959,
+  -957,
+  121
+};
+
+// 1200Hz = -10dB, 2200Hz = 0dB; 3118Hz cutoff; cosine.
+q15_t dB10[] = {
+  56,
+  -1110,
+  -3987,
+  -7141,
+  24254,
+  -7141,
+  -3987,
+  -1110,
+  56
+};
+
+// 1200Hz = -9dB, 2200Hz = 0dB; 2959Hz cutoff; cosine.
+q15_t dB9[] = {
+  -19,
+  -1268,
+  -3994,
+  -6856,
+  24688,
+  -6856,
+  -3994,
+  -1268,
+  -19
+};
+
+// 1200Hz = -8dB, 2200Hz = 0dB; 2778Hz cutoff; cosine.
+q15_t dB8[] = {
+  -104,
+  -1424,
+  -3968,
+  -6516,
+  25182,
+  -6516,
+  -3968,
+  -1424,
+  -104
+};
+
+// 1200Hz = -7dB, 2200Hz = 0dB; 2573Hz cutoff; cosine.
+q15_t dB7[] = {
+  -196,
+  -1565,
+  -3896,
+  -6114,
+  25742,
+  -6114,
+  -3896,
+  -1565,
+  -196
+};
+
+// 1200Hz = -6dB, 2200Hz = 0dB; 2343Hz cutoff; cosine.
+q15_t dB6[] = {
+  -288,
+  -1676,
+  -3761,
+  -5642,
+  26370,
+  -5642,
+  -3761,
+  -1676,
+  -288
+};
+
+// 1200Hz = -5dB, 2200Hz = 0dB; 2085Hz cutoff; cosine.
+q15_t dB5[] = {
+  -370,
+  -1735,
+  -3545,
+  -5088,
+  27075,
+  -5088,
+  -3545,
+  -1735,
+  -370
+};
+
+// 1200Hz = -4dB, 2200Hz = 0dB; 1790Hz cutoff; cosine.
+q15_t dB4[] = {
+  -432,
+  -1715,
+  -3220,
+  -4427,
+  27880,
+  -4427,
+  -3220,
+  -1715,
+  -432
+};
+
+// 1200Hz = -3dB, 2200Hz = 0dB; 1456Hz cutoff; cosine.
+q15_t dB3[] = {
+  -452,
+  -1582,
+  -2759,
+  -3646,
+  28792,
+  -3646,
+  -2759,
+  -1582,
+  -452
+};
+
+// 1200Hz = -2dB, 2200Hz = 0dB; 1070Hz cutoff; cosine.
+q15_t dB2[] = {
+  -408,
+  -1295,
+  -2123,
+  -2710,
+  29846,
+  -2710,
+  -2123,
+  -1295,
+  -408
+};
+
+// 1200Hz = -1dB, 2200Hz = 0dB; 605Hz cutoff; cosine.
+q15_t dB1[] = {
+  -268,
+  -795,
+  -1244,
+  -1546,
+  31116,
+  -1546,
+  -1244,
+  -795,
+  -268
+};
+
+q15_t dB0[] = {
+  0,
+  0,
+  0,
+  0,
+  32767,
+  0,
+  0,
+  0,
+  0,
+};
+
+// 1200Hz = 0dB, 2200Hz = -1dB; 4130Hz cutoff; cosine.
+q15_t dB_1[] = {
+  -419,
+  -177,
+  3316,
+  8650,
+  11278,
+  8650,
+  3316,
+  -177,
+  -419
+};
+
+// 1200Hz = 0dB, 2200Hz = -2dB; 3190Hz cutoff; cosine.
+q15_t dB_2[] = {
+  -90,
+  1033,
+  3975,
+  7267,
+  8711,
+  7267,
+  3975,
+  1033,
+  -90
+};
+
+// 1200Hz = 0dB, 2200Hz = -3dB; 2330Hz cutoff; cosine.
+q15_t dB_3[] = {
+  292,
+  1680,
+  3752,
+  5615,
+  6362,
+  5615,
+  3752,
+  1680,
+  292
+};
+
+// 1200Hz = 0dB, 2200Hz = -4dB; 2657Hz cutoff; boxcar.
+q15_t dB_4[] = {
+  917,
+  3024,
+  5131,
+  6684,
+  7255,
+  6684,
+  5131,
+  3024,
+  917
+};
+
+// 1200Hz = 0dB, 2200Hz = -5dB; 2360Hz cutoff; boxcar.
+q15_t dB_5[] = {
+  1620,
+  3339,
+  4925,
+  6042,
+  6444,
+  6042,
+  4925,
+  3339,
+  1620
+};
+
+// 1200Hz = 0dB, 2200Hz = -6dB; 2067Hz cutoff; boxcar.
+q15_t dB_6[] = {
+  2161,
+  3472,
+  4605,
+  5373,
+  5644,
+  5373,
+  4605,
+  3472,
+  2161
+};
+
+q15_t* coeffs[] = {
+  dB12,
+  dB11,
+  dB10,
+  dB9,
+  dB8,
+  dB7,
+  dB6,
+  dB5,
+  dB4,
+  dB3,
+  dB2,
+  dB1,
+  dB0,
+  dB_1,
+  dB_2,
+  dB_3,
+  dB_4,
+  dB_5,
+  dB_6
+};
+
+CAX25Twist::CAX25Twist(int8_t n) :
+m_filter(),
+m_state()
+{
+  setTwist(n);
+}
+
+void CAX25Twist::process(q15_t* in, q15_t* out, uint8_t length)
+{
+  ::arm_fir_fast_q15(&m_filter, in, out, length);
+}
+
+void CAX25Twist::setTwist(int8_t n)
+{
+  uint8_t twist = uint8_t(n + 6);
+
+  m_filter.numTaps = 9;
+  m_filter.pState  = m_state;
+  m_filter.pCoeffs = coeffs[twist];
+}
+

AX25Twist.h

@@ -0,0 +1,39 @@
+/*
+ *   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(AX25Twist_H)
+#define  AX25Twist_H
+
+#include "Config.h"
+
+
+class CAX25Twist {
+public:
+  CAX25Twist(int8_t n);
+
+  void process(q15_t* in, q15_t* out, uint8_t length);
+
+  void setTwist(int8_t n);
+
+private:
+  arm_fir_instance_q15 m_filter;
+  q15_t                m_state[40U];   // NoTaps + BlockSize - 1, 9 + 20 - 1 plus some spare
+};
+
+#endif
+

CWIdTX.cpp

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

CWIdTX.h

@@ -1,6 +1,6 @@
 /*
  *   Copyright (C) 2009-2015 by Jonathan Naylor G4KLX
- *   Copyright (C) 2016 by Colin Durbridge G4EML
+ *   Copyright (C) 2016,2020 by Colin Durbridge G4EML
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -28,7 +28,7 @@ public:
 
   void process();
 
-  uint8_t write(const uint8_t* data, uint8_t length);
+  uint8_t write(const uint8_t* data, uint16_t length);
 
   void reset();
 

CalDMR.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2015 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2015,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -208,7 +208,7 @@ void CCalDMR::dmrdmo1k()
   }
 }
 
-uint8_t CCalDMR::write(const uint8_t* data, uint8_t length)
+uint8_t CCalDMR::write(const uint8_t* data, uint16_t length)
 {
   if (length != 1U)
     return 4U;

CalDMR.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2015 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2015,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -41,7 +41,7 @@ public:
   void createData1k(uint8_t n);
   void createDataDMO1k(uint8_t n);
 
-  uint8_t write(const uint8_t* data, uint8_t length);
+  uint8_t write(const uint8_t* data, uint16_t length);
 
 private:
   bool      m_transmit;

CalDStarTX.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2016,2020 by Jonathan Naylor G4KLX
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -162,7 +162,7 @@ void CCalDStarTX::process()
   m_count = (m_count + 1U) % (30U * 21U);
 }
 
-uint8_t CCalDStarTX::write(const uint8_t* data, uint8_t length)
+uint8_t CCalDStarTX::write(const uint8_t* data, uint16_t length)
 {
   if (length != 1U)
     return 4U;

CalDStarTX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2020 by Jonathan Naylor G4KLX
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -26,7 +26,7 @@ class CCalDStarTX {
 public:
   CCalDStarTX();
 
-  uint8_t write(const uint8_t* data, uint8_t length);
+  uint8_t write(const uint8_t* data, uint16_t length);
 
   void process();
 

CalFM.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2015 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2015,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *   Copyright (C) 2020 by Phil Taylor M0VSE
  *
@@ -116,7 +116,7 @@ void CCalFM::process()
 }
 
 
-uint8_t CCalFM::write(const uint8_t* data, uint8_t length)
+uint8_t CCalFM::write(const uint8_t* data, uint16_t length)
 {
   if (length != 1U)
     return 4U;

CalFM.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2015 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2015,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *   Copyright (C) 2020 by Phil Taylor M0VSE
  *
@@ -35,7 +35,7 @@ public:
   void fm25kcal();
   void fm30kcal();
 
-  uint8_t write(const uint8_t* data, uint8_t length);
+  uint8_t write(const uint8_t* data, uint16_t length);
 
 private:
   uint16_t  m_frequency;

CalNXDN.cpp

@@ -1,5 +1,6 @@
 /*
  *   Copyright (C) 2018 by Andy Uribe CA6JAU
+ *   Copyright (C) 2020 by Jonathan Naylor G4KLX
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -79,7 +80,7 @@ void CCalNXDN::process()
   }
 }
 
-uint8_t CCalNXDN::write(const uint8_t* data, uint8_t length)
+uint8_t CCalNXDN::write(const uint8_t* data, uint16_t length)
 {
   if (length != 1U)
     return 4U;

CalNXDN.h

@@ -1,5 +1,6 @@
 /*
  *   Copyright (C) 2018 by Andy Uribe CA6JAU
+ *   Copyright (C) 2020 by Jonathan Naylor G4KLX
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -32,7 +33,7 @@ public:
 
   void process();
 
-  uint8_t write(const uint8_t* data, uint8_t length);
+  uint8_t write(const uint8_t* data, uint16_t length);
 
 private:
   bool      m_transmit;

CalP25.cpp

@@ -1,5 +1,6 @@
 /*
  *   Copyright (C) 2018 by Andy Uribe CA6JAU
+ *   Copyright (C) 2020 by Jonathan Naylor G4KLX
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -82,7 +83,7 @@ void CCalP25::process()
   }
 }
 
-uint8_t CCalP25::write(const uint8_t* data, uint8_t length)
+uint8_t CCalP25::write(const uint8_t* data, uint16_t length)
 {
   if (length != 1U)
     return 4U;

CalP25.h

@@ -1,5 +1,6 @@
 /*
  *   Copyright (C) 2018 by Andy Uribe CA6JAU
+ *   Copyright (C) 2020 by Jonathan Naylor G4KLX
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -34,7 +35,7 @@ public:
 
   void process();
 
-  uint8_t write(const uint8_t* data, uint8_t length);
+  uint8_t write(const uint8_t* data, uint16_t length);
 
 private:
   bool      m_transmit;

CalPOCSAG.cpp

@@ -1,5 +1,6 @@
 /*
  *   Copyright (C) 2019 by Florian Wolters DF2ET
+ *   Copyright (C) 2020 by Jonathan Naylor G4KLX
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -38,7 +39,7 @@ void CCalPOCSAG::process()
   pocsagTX.writeByte(0xAAU);
 }
 
-uint8_t CCalPOCSAG::write(const uint8_t* data, uint8_t length)
+uint8_t CCalPOCSAG::write(const uint8_t* data, uint16_t length)
 {
   if (length != 1U)
     return 4U;

CalPOCSAG.h

@@ -1,5 +1,6 @@
 /*
  *   Copyright (C) 2019 by Florian Wolters DF2ET
+ *   Copyright (C) 2020 by Jonathan Naylor G4KLX
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -32,7 +33,7 @@ public:
 
   void process();
 
-  uint8_t write(const uint8_t* data, uint8_t length);
+  uint8_t write(const uint8_t* data, uint16_t length);
 
 private:
   POCSAGCAL m_state;

Config.h

@@ -36,7 +36,7 @@
 // #define EXTERNAL_OSC 19200000
 
 // Use pins to output the current mode via LEDs
-// #define MODE_LEDS
+#define MODE_LEDS
 
 // For the original Arduino Due pin layout
 // #define ARDUINO_DUE_PAPA
@@ -78,9 +78,6 @@
 // Use the YSF and P25 LEDs for NXDN
 // #define USE_ALTERNATE_NXDN_LEDS
 
-// Use the D-Star and P25 LEDs for M17
-// #define USE_ALTERNATE_M17_LEDS
-
 // Use the D-Star and DMR LEDs for POCSAG
 // #define USE_ALTERNATE_POCSAG_LEDS
 

DMRDMOTX.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2017,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *   Copyright (C) 2017 by Andy Uribe CA6JAU
  *
@@ -104,7 +104,7 @@ void CDMRDMOTX::process()
   }
 }
 
-uint8_t CDMRDMOTX::writeData(const uint8_t* data, uint8_t length)
+uint8_t CDMRDMOTX::writeData(const uint8_t* data, uint16_t length)
 {
   if (length != (DMR_FRAME_LENGTH_BYTES + 1U))
     return 4U;

DMRDMOTX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -29,7 +29,7 @@ class CDMRDMOTX {
 public:
   CDMRDMOTX();
 
-  uint8_t writeData(const uint8_t* data, uint8_t length);
+  uint8_t writeData(const uint8_t* data, uint16_t length);
 
   void process();
 

DMRTX.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2017,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *   Copyright (C) 2017 by Andy Uribe CA6JAU
  *
@@ -144,7 +144,7 @@ void CDMRTX::process()
   }
 }
 
-uint8_t CDMRTX::writeData1(const uint8_t* data, uint8_t length)
+uint8_t CDMRTX::writeData1(const uint8_t* data, uint16_t length)
 {
   if (length != (DMR_FRAME_LENGTH_BYTES + 1U))
     return 4U;
@@ -168,7 +168,7 @@ uint8_t CDMRTX::writeData1(const uint8_t* data, uint8_t length)
   return 0U;
 }
 
-uint8_t CDMRTX::writeData2(const uint8_t* data, uint8_t length)
+uint8_t CDMRTX::writeData2(const uint8_t* data, uint16_t length)
 {
   if (length != (DMR_FRAME_LENGTH_BYTES + 1U))
     return 4U;
@@ -192,7 +192,7 @@ uint8_t CDMRTX::writeData2(const uint8_t* data, uint8_t length)
   return 0U;
 }
 
-uint8_t CDMRTX::writeShortLC(const uint8_t* data, uint8_t length)
+uint8_t CDMRTX::writeShortLC(const uint8_t* data, uint16_t length)
 {
   if (length != 9U)
     return 4U;
@@ -208,7 +208,7 @@ uint8_t CDMRTX::writeShortLC(const uint8_t* data, uint8_t length)
   return 0U;
 }
 
-uint8_t CDMRTX::writeAbort(const uint8_t* data, uint8_t length)
+uint8_t CDMRTX::writeAbort(const uint8_t* data, uint16_t length)
 {
   if (length != 1U)
     return 4U;

DMRTX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2016 by Colin Durbridge G4EML
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -38,11 +38,11 @@ class CDMRTX {
 public:
   CDMRTX();
 
-  uint8_t writeData1(const uint8_t* data, uint8_t length);
+  uint8_t writeData1(const uint8_t* data, uint16_t length);
-  uint8_t writeData2(const uint8_t* data, uint8_t length);
+  uint8_t writeData2(const uint8_t* data, uint16_t length);
 
-  uint8_t writeShortLC(const uint8_t* data, uint8_t length);
+  uint8_t writeShortLC(const uint8_t* data, uint16_t length);
-  uint8_t writeAbort(const uint8_t* data, uint8_t length);
+  uint8_t writeAbort(const uint8_t* data, uint16_t length);
 
   void setStart(bool start);
   void setCal(bool start);

DStarTX.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2017,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2017 by Andy Uribe CA6JAU
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -277,7 +277,7 @@ void CDStarTX::process()
   }
 }
 
-uint8_t CDStarTX::writeHeader(const uint8_t* header, uint8_t length)
+uint8_t CDStarTX::writeHeader(const uint8_t* header, uint16_t length)
 {
   if (length != DSTAR_HEADER_LENGTH_BYTES)
     return 4U;
@@ -296,7 +296,7 @@ uint8_t CDStarTX::writeHeader(const uint8_t* header, uint8_t length)
   return 0U;
 }
 
-uint8_t CDStarTX::writeData(const uint8_t* data, uint8_t length)
+uint8_t CDStarTX::writeData(const uint8_t* data, uint16_t length)
 {
   if (length != DSTAR_DATA_LENGTH_BYTES)
     return 4U;

DStarTX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2020 by Jonathan Naylor G4KLX
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -27,8 +27,8 @@ class CDStarTX {
 public:
   CDStarTX();
 
-  uint8_t writeHeader(const uint8_t* header, uint8_t length);
+  uint8_t writeHeader(const uint8_t* header, uint16_t length);
-  uint8_t writeData(const uint8_t* data, uint8_t length);
+  uint8_t writeData(const uint8_t* data, uint16_t length);
   uint8_t writeEOT();
 
   void process();

Globals.h

@@ -50,8 +50,8 @@ enum MMDVM_STATE {
   STATE_P25       = 4,
   STATE_NXDN      = 5,
   STATE_POCSAG    = 6,
-  STATE_M17       = 7,
   STATE_FM        = 10,
+  STATE_AX25      = 11,
 
   // Dummy states start at 90
   STATE_NXDNCAL1K = 91,
@@ -85,8 +85,6 @@ enum MMDVM_STATE {
 #include "YSFTX.h"
 #include "P25RX.h"
 #include "P25TX.h"
-#include "M17RX.h"
-#include "M17TX.h"
 #include "NXDNRX.h"
 #include "NXDNTX.h"
 #include "POCSAGTX.h"
@@ -99,6 +97,8 @@ enum MMDVM_STATE {
 #include "CalPOCSAG.h"
 #include "CalRSSI.h"
 #include "CWIdTX.h"
+#include "AX25RX.h"
+#include "AX25TX.h"
 #include "Debug.h"
 #include "IO.h"
 #include "FM.h"
@@ -126,8 +126,8 @@ extern bool m_ysfEnable;
 extern bool m_p25Enable;
 extern bool m_nxdnEnable;
 extern bool m_pocsagEnable;
-extern bool m_m17Enable;
 extern bool m_fmEnable;
+extern bool m_ax25Enable;
 
 extern bool m_duplex;
 
@@ -158,10 +158,9 @@ extern CNXDNTX nxdnTX;
 
 extern CPOCSAGTX pocsagTX;
 
-extern CM17RX m17RX;
-extern CM17TX m17TX;
-
 extern CFM     fm;
+extern CAX25RX ax25RX;
+extern CAX25TX ax25TX;
 
 extern CCalDStarRX calDStarRX;
 extern CCalDStarTX calDStarTX;
@@ -175,3 +174,4 @@ extern CCalRSSI    calRSSI;
 extern CCWIdTX cwIdTX;
 
 #endif
+

IO.cpp

@@ -32,12 +32,6 @@ static q15_t RRC_0_2_FILTER[] = {401, 104, -340, -731, -847, -553, 112, 909, 147
                                  -553, -847, -731, -340, 104, 401, 0};
 const uint16_t RRC_0_2_FILTER_LEN = 42U;
 
-// Generated using rcosdesign(0.5, 8, 5, 'sqrt') in MATLAB
-static q15_t RRC_0_5_FILTER[] = {-147, -88, 72, 220, 223, 46, -197, -285, -79, 334, 623, 390, -498, -1691, -2363, -1556, 1284, 5872, 11033,
-				  15109, 16656, 15109, 11033, 5872, 1284, -1556, -2363, -1691, -498, 390, 623, 334, -79, -285, -197, 46, 223,
-				  220, 72, -88, -147, 0};
-const uint16_t RRC_0_5_FILTER_LEN = 42U;
-
 // Generated using rcosdesign(0.2, 8, 10, 'sqrt') in MATLAB
 static q15_t NXDN_0_2_FILTER[] = {284, 198, 73, -78, -240, -393, -517, -590, -599, -533, -391, -181, 79, 364, 643, 880, 1041, 1097, 1026, 819,
                                   483, 39, -477, -1016, -1516, -1915, -2150, -2164, -1914, -1375, -545, 557, 1886, 3376, 4946, 6502, 7946, 9184,
@@ -67,14 +61,12 @@ m_txBuffer(TX_RINGBUFFER_SIZE),
 m_rssiBuffer(RX_RINGBUFFER_SIZE),
 m_dcFilter(),
 m_dcState(),
-m_rrc02Filter(),
+m_rrcFilter(),
-m_rrc05Filter(),
 m_gaussianFilter(),
 m_boxcarFilter(),
 m_nxdnFilter(),
 m_nxdnISincFilter(),
-m_rrc02State(),
+m_rrcState(),
-m_rrc05State(),
 m_gaussianState(),
 m_boxcarState(),
 m_nxdnState(),
@@ -87,9 +79,9 @@ m_dmrTXLevel(128 * 128),
 m_ysfTXLevel(128 * 128),
 m_p25TXLevel(128 * 128),
 m_nxdnTXLevel(128 * 128),
-m_m17TXLevel(128 * 128),
 m_pocsagTXLevel(128 * 128),
 m_fmTXLevel(128 * 128),
+m_ax25TXLevel(128 * 128),
 m_rxDCOffset(DC_OFFSET),
 m_txDCOffset(DC_OFFSET),
 m_useCOSAsLockout(false),
@@ -101,8 +93,7 @@ m_dacOverflow(0U),
 m_watchdog(0U),
 m_lockout(false)
 {
-  ::memset(m_rrc02State,    0x00U,  70U * sizeof(q15_t));
+  ::memset(m_rrcState,      0x00U,  70U * sizeof(q15_t));
-  ::memset(m_rrc05State,    0x00U,  70U * sizeof(q15_t));
   ::memset(m_gaussianState, 0x00U,  40U * sizeof(q15_t));
   ::memset(m_boxcarState,   0x00U,  30U * sizeof(q15_t));
   ::memset(m_nxdnState,     0x00U, 110U * sizeof(q15_t));
@@ -114,13 +105,9 @@ m_lockout(false)
   m_dcFilter.pCoeffs   = DC_FILTER;
   m_dcFilter.postShift = 0;
 
-  m_rrc02Filter.numTaps = RRC_0_2_FILTER_LEN;
+  m_rrcFilter.numTaps = RRC_0_2_FILTER_LEN;
-  m_rrc02Filter.pState  = m_rrc02State;
+  m_rrcFilter.pState  = m_rrcState;
-  m_rrc02Filter.pCoeffs = RRC_0_2_FILTER;
+  m_rrcFilter.pCoeffs = RRC_0_2_FILTER;
-
-  m_rrc05Filter.numTaps = RRC_0_5_FILTER_LEN;
-  m_rrc05Filter.pState  = m_rrc05State;
-  m_rrc05Filter.pCoeffs = RRC_0_5_FILTER;
 
   m_gaussianFilter.numTaps = GAUSSIAN_0_5_FILTER_LEN;
   m_gaussianFilter.pState  = m_gaussianState;
@@ -147,7 +134,7 @@ void CIO::selfTest()
 {
   bool ledValue = false;
 
-  for (uint8_t i = 0U; i < 6U; i++) {
+  for (uint8_t i = 0; i < 6; i++) {
     ledValue = !ledValue;
 
     // We exclude PTT to avoid trigger the transmitter
@@ -158,40 +145,21 @@ void CIO::selfTest()
     setDMRInt(ledValue);
     setYSFInt(ledValue);
     setP25Int(ledValue);
-#if !defined(USE_ALTERNATE_NXDN_LEDS)
     setNXDNInt(ledValue);
-#endif
-#if !defined(USE_ALTERNATE_M17_LEDS)
-    setM17Int(ledValue);
-#endif
-#if !defined(USE_ALTERNATE_POCSAG_LEDS)
     setPOCSAGInt(ledValue);
-#endif
-#if !defined(USE_ALTERNATE_FM_LEDS)
     setFMInt(ledValue);
-#endif
 #endif
     delayInt(250);
   }
 
 #if defined(MODE_LEDS)
-  setDStarInt(false);
+  setDStarInt(true);
   setDMRInt(false);
   setYSFInt(false);
   setP25Int(false);
-#if !defined(USE_ALTERNATE_NXDN_LEDS)
   setNXDNInt(false);
-#endif
-#if !defined(USE_ALTERNATE_M17_LEDS)
-  setM17Int(false);
-#endif
-#if !defined(USE_ALTERNATE_POCSAG_LEDS)
   setPOCSAGInt(false);
-#endif
-#if !defined(USE_ALTERNATE_FM_LEDS)
   setFMInt(false);
-#endif
-  setDStarInt(true);
 
   delayInt(250);
   setDMRInt(true);
@@ -207,11 +175,6 @@ void CIO::selfTest()
   setNXDNInt(true);
 #endif
 
-#if !defined(USE_ALTERNATE_M17_LEDS)
-  delayInt(250);
-  setM17Int(true);
-#endif
-
 #if !defined(USE_ALTERNATE_POCSAG_LEDS)
   delayInt(250);
   setPOCSAGInt(true);
@@ -230,11 +193,6 @@ void CIO::selfTest()
   setPOCSAGInt(false);
 #endif
 
-#if !defined(USE_ALTERNATE_M17_LEDS)
-  delayInt(250);
-  setM17Int(false);
-#endif
-
 #if !defined(USE_ALTERNATE_NXDN_LEDS)
   delayInt(250);
   setNXDNInt(false);
@@ -263,7 +221,7 @@ void CIO::start()
 
   m_started = true;
 
-  setMode(STATE_IDLE);
+  setMode();
 }
 
 void CIO::process()
@@ -272,10 +230,11 @@ void CIO::process()
   if (m_started) {
     // Two seconds timeout
     if (m_watchdog >= 48000U) {
-      if (m_modemState == STATE_DSTAR || m_modemState == STATE_DMR || m_modemState == STATE_YSF || m_modemState == STATE_P25 || m_modemState == STATE_NXDN || m_modemState == STATE_M17 || m_modemState == STATE_POCSAG) {
+      if (m_modemState == STATE_DSTAR || m_modemState == STATE_DMR || m_modemState == STATE_YSF || m_modemState == STATE_P25 || m_modemState == STATE_NXDN || m_modemState == STATE_POCSAG) {
         if (m_modemState == STATE_DMR && m_tx)
           dmrTX.setStart(false);
-        setMode(STATE_IDLE);
+        m_modemState = STATE_IDLE;
+        setMode();
       }
 
       m_watchdog = 0U;
@@ -383,34 +342,19 @@ void CIO::process()
         nxdnRX.samples(NXDNVals, rssi, RX_BLOCK_SIZE);
       }
 
-      if (m_dmrEnable) {
+      if (m_dmrEnable || m_ysfEnable) {
-        q15_t DMRVals[RX_BLOCK_SIZE];
-        ::arm_fir_fast_q15(&m_rrc02Filter, samples, DMRVals, RX_BLOCK_SIZE);
-
-        if (m_duplex)
-          dmrIdleRX.samples(DMRVals, RX_BLOCK_SIZE);
-        else
-          dmrDMORX.samples(DMRVals, rssi, RX_BLOCK_SIZE);
-      }
-
-      if (m_ysfEnable) {
-        q15_t YSFVals[RX_BLOCK_SIZE];
-#if defined(USE_DCBLOCKER)
-        ::arm_fir_fast_q15(&m_rrc02Filter, dcSamples, YSFVals, RX_BLOCK_SIZE);
-#else
-        ::arm_fir_fast_q15(&m_rrc02Filter, samples, YSFVals, RX_BLOCK_SIZE);
-#endif
-        ysfRX.samples(YSFVals, rssi, RX_BLOCK_SIZE);
-      }
-
-      if (m_m17Enable) {
         q15_t RRCVals[RX_BLOCK_SIZE];
-#if defined(USE_DCBLOCKER)
+        ::arm_fir_fast_q15(&m_rrcFilter, samples, RRCVals, RX_BLOCK_SIZE);
-        ::arm_fir_fast_q15(&m_rrc05Filter, dcSamples, RRCVals, RX_BLOCK_SIZE);
+
-#else
+        if (m_ysfEnable)
-        ::arm_fir_fast_q15(&m_rrc05Filter, samples, RRCVals, RX_BLOCK_SIZE);
+          ysfRX.samples(RRCVals, rssi, RX_BLOCK_SIZE);
-#endif
+
-        m17RX.samples(RRCVals, rssi, RX_BLOCK_SIZE);
+        if (m_dmrEnable) {
+          if (m_duplex)
+            dmrIdleRX.samples(RRCVals, RX_BLOCK_SIZE);
+          else
+            dmrDMORX.samples(RRCVals, rssi, RX_BLOCK_SIZE);
+        }
       }
 
       if (m_fmEnable) {
@@ -419,6 +363,14 @@ void CIO::process()
         fm.samples(cos, dcSamples, RX_BLOCK_SIZE);
 #else
         fm.samples(cos, samples, RX_BLOCK_SIZE);
+#endif
+      }
+
+      if (m_ax25Enable) {
+#if defined(USE_DCBLOCKER)
+        ax25RX.samples(dcSamples, RX_BLOCK_SIZE);
+#else
+        ax25RX.samples(samples, RX_BLOCK_SIZE);
 #endif
       }
     } else if (m_modemState == STATE_DSTAR) {
@@ -434,7 +386,7 @@ void CIO::process()
     } else if (m_modemState == STATE_DMR) {
       if (m_dmrEnable) {
         q15_t DMRVals[RX_BLOCK_SIZE];
-        ::arm_fir_fast_q15(&m_rrc02Filter, samples, DMRVals, RX_BLOCK_SIZE);
+        ::arm_fir_fast_q15(&m_rrcFilter, samples, DMRVals, RX_BLOCK_SIZE);
 
         if (m_duplex) {
           // If the transmitter isn't on, use the DMR idle RX to detect the wakeup CSBKs
@@ -450,9 +402,9 @@ void CIO::process()
       if (m_ysfEnable) {
         q15_t YSFVals[RX_BLOCK_SIZE];
 #if defined(USE_DCBLOCKER)
-        ::arm_fir_fast_q15(&m_rrc02Filter, dcSamples, YSFVals, RX_BLOCK_SIZE);
+        ::arm_fir_fast_q15(&m_rrcFilter, dcSamples, YSFVals, RX_BLOCK_SIZE);
 #else
-        ::arm_fir_fast_q15(&m_rrc02Filter, samples, YSFVals, RX_BLOCK_SIZE);
+        ::arm_fir_fast_q15(&m_rrcFilter, samples, YSFVals, RX_BLOCK_SIZE);
 #endif
         ysfRX.samples(YSFVals, rssi, RX_BLOCK_SIZE);
       }
@@ -479,22 +431,16 @@ void CIO::process()
 
         nxdnRX.samples(NXDNVals, rssi, RX_BLOCK_SIZE);
       }
-    } else if (m_modemState == STATE_M17) {
-      if (m_m17Enable) {
-        q15_t M17Vals[RX_BLOCK_SIZE];
-#if defined(USE_DCBLOCKER)
-        ::arm_fir_fast_q15(&m_rrc05Filter, dcSamples, M17Vals, RX_BLOCK_SIZE);
-#else
-        ::arm_fir_fast_q15(&m_rrc05Filter, samples, M17Vals, RX_BLOCK_SIZE);
-#endif
-        m17RX.samples(M17Vals, rssi, RX_BLOCK_SIZE);
-      }
     } else if (m_modemState == STATE_FM) {
       bool cos = getCOSInt();
 #if defined(USE_DCBLOCKER)
       fm.samples(cos, dcSamples, RX_BLOCK_SIZE);
+      if (m_ax25Enable)
+        ax25RX.samples(dcSamples, RX_BLOCK_SIZE);
 #else
       fm.samples(cos, samples, RX_BLOCK_SIZE);
+      if (m_ax25Enable)
+        ax25RX.samples(samples, RX_BLOCK_SIZE);
 #endif
     } else if (m_modemState == STATE_DSTARCAL) {
       q15_t GMSKVals[RX_BLOCK_SIZE];
@@ -538,15 +484,15 @@ void CIO::write(MMDVM_STATE mode, q15_t* samples, uint16_t length, const uint8_t
     case STATE_NXDN:
       txLevel = m_nxdnTXLevel;
       break;
-    case STATE_M17:
-      txLevel = m_m17TXLevel;
-      break;
     case STATE_POCSAG:
       txLevel = m_pocsagTXLevel;
       break;
     case STATE_FM:
       txLevel = m_fmTXLevel;
       break;
+    case STATE_AX25:
+      txLevel = m_ax25TXLevel;
+      break;
     default:
       txLevel = m_cwIdTXLevel;
       break;
@@ -586,39 +532,20 @@ void CIO::setADCDetection(bool detect)
   m_detect = detect;
 }
 
-void CIO::setMode(MMDVM_STATE state)
+void CIO::setMode()
 {
-  if (state == m_modemState)
-    return;
-
 #if defined(MODE_LEDS)
-  switch (m_modemState) {
+  setDStarInt(m_modemState == STATE_DSTAR);
-    case STATE_DSTAR:  setDStarInt(false);  break;
+  setDMRInt(m_modemState   == STATE_DMR);
-    case STATE_DMR:    setDMRInt(false);    break;
+  setYSFInt(m_modemState   == STATE_YSF);
-    case STATE_YSF:    setYSFInt(false);    break;
+  setP25Int(m_modemState   == STATE_P25);
-    case STATE_P25:    setP25Int(false);    break;
+  setNXDNInt(m_modemState  == STATE_NXDN);
-    case STATE_NXDN:   setNXDNInt(false);   break;
+  setPOCSAGInt(m_modemState  == STATE_POCSAG);
-    case STATE_M17:    setM17Int(false);    break;
+  setFMInt(m_modemState == STATE_FM);
-    case STATE_POCSAG: setPOCSAGInt(false); break;
-    case STATE_FM:     setFMInt(false);     break;
-  }
-
-  switch (state) {
-    case STATE_DSTAR:  setDStarInt(true);  break;
-    case STATE_DMR:    setDMRInt(true);    break;
-    case STATE_YSF:    setYSFInt(true);    break;
-    case STATE_P25:    setP25Int(true);    break;
-    case STATE_NXDN:   setNXDNInt(true);   break;
-    case STATE_M17:    setM17Int(true);    break;
-    case STATE_POCSAG: setPOCSAGInt(true); break;
-    case STATE_FM:     setFMInt(true);     break;
-  }
 #endif
-
-  m_modemState = state;
 }
 
-void CIO::setParameters(bool rxInvert, bool txInvert, bool pttInvert, uint8_t rxLevel, uint8_t cwIdTXLevel, uint8_t dstarTXLevel, uint8_t dmrTXLevel, uint8_t ysfTXLevel, uint8_t p25TXLevel, uint8_t nxdnTXLevel, uint8_t m17TXLevel, uint8_t pocsagTXLevel, uint8_t fmTXLevel, int16_t txDCOffset, int16_t rxDCOffset, bool useCOSAsLockout)
+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, uint8_t ax25TXLevel, int16_t txDCOffset, int16_t rxDCOffset, bool useCOSAsLockout)
 {
   m_pttInvert = pttInvert;
 
@@ -629,9 +556,9 @@ void CIO::setParameters(bool rxInvert, bool txInvert, bool pttInvert, uint8_t rx
   m_ysfTXLevel    = q15_t(ysfTXLevel * 128);
   m_p25TXLevel    = q15_t(p25TXLevel * 128);
   m_nxdnTXLevel   = q15_t(nxdnTXLevel * 128);
-  m_m17TXLevel    = q15_t(m17TXLevel * 128);
   m_pocsagTXLevel = q15_t(pocsagTXLevel * 128);
   m_fmTXLevel     = q15_t(fmTXLevel * 128);
+  m_ax25TXLevel   = q15_t(ax25TXLevel * 128);
 
   m_rxDCOffset   = DC_OFFSET + rxDCOffset;
   m_txDCOffset   = DC_OFFSET + txDCOffset;
@@ -647,7 +574,6 @@ void CIO::setParameters(bool rxInvert, bool txInvert, bool pttInvert, uint8_t rx
     m_ysfTXLevel    = -m_ysfTXLevel;
     m_p25TXLevel    = -m_p25TXLevel;
     m_nxdnTXLevel   = -m_nxdnTXLevel;
-    m_m17TXLevel    = -m_m17TXLevel;
     m_pocsagTXLevel = -m_pocsagTXLevel;
   }
 }

IO.h

@@ -38,11 +38,11 @@ public:
 
   void setDecode(bool dcd);
   void setADCDetection(bool detect);
-  void setMode(MMDVM_STATE state);
+  void setMode();
   
   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 m17TXLevel, uint8_t pocsagTXLevel, uint8_t fmTXLevel, int16_t txDCOffset, int16_t rxDCOffset, bool useCOSAsLockout);
+  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, uint8_t ax25TXLevel, int16_t txDCOffset, int16_t rxDCOffset, bool useCOSAsLockout);
 
   void getOverflow(bool& adcOverflow, bool& dacOverflow);
 
@@ -66,14 +66,12 @@ private:
   arm_biquad_casd_df1_inst_q31 m_dcFilter;
   q31_t                        m_dcState[4];
 
-  arm_fir_instance_q15 m_rrc02Filter;
+  arm_fir_instance_q15 m_rrcFilter;
-  arm_fir_instance_q15 m_rrc05Filter;
   arm_fir_instance_q15 m_gaussianFilter;
   arm_fir_instance_q15 m_boxcarFilter;
   arm_fir_instance_q15 m_nxdnFilter;
   arm_fir_instance_q15 m_nxdnISincFilter;
-  q15_t                m_rrc02State[70U];         // NoTaps + BlockSize - 1, 42 + 20 - 1 plus some spare
+  q15_t                m_rrcState[70U];           // NoTaps + BlockSize - 1, 42 + 20 - 1 plus some spare
-  q15_t                m_rrc05State[70U];         // NoTaps + BlockSize - 1, 42 + 20 - 1 plus some spare
   q15_t                m_gaussianState[40U];      // NoTaps + BlockSize - 1, 12 + 20 - 1 plus some spare
   q15_t                m_boxcarState[30U];        // NoTaps + BlockSize - 1, 6 + 20 - 1 plus some spare
   q15_t                m_nxdnState[110U];         // NoTaps + BlockSize - 1, 82 + 20 - 1 plus some spare
@@ -87,9 +85,9 @@ private:
   q15_t                m_ysfTXLevel;
   q15_t                m_p25TXLevel;
   q15_t                m_nxdnTXLevel;
-  q15_t                m_m17TXLevel;
   q15_t                m_pocsagTXLevel;
   q15_t                m_fmTXLevel;
+  q15_t                m_ax25TXLevel;
 
   uint16_t             m_rxDCOffset;
   uint16_t             m_txDCOffset;
@@ -124,7 +122,6 @@ private:
   void setP25Int(bool on);
   void setNXDNInt(bool on);
   void setPOCSAGInt(bool on);
-  void setM17Int(bool on);
   void setFMInt(bool on);
   
   void delayInt(unsigned int dly);

IODue.cpp

@@ -107,9 +107,6 @@ void CIO::initInt()
 #if !defined(USE_ALTERNATE_NXDN_LEDS)
   pinMode(PIN_NXDN,   OUTPUT);
 #endif
-#if !defined(USE_ALTERNATE_M17_LEDS)
-  pinMode(PIN_M17,    OUTPUT);
-#endif
 #if !defined(USE_ALTERNATE_POCSAG_LEDS)
   pinMode(PIN_POCSAG, OUTPUT);
 #endif
@@ -257,16 +254,6 @@ void CIO::setNXDNInt(bool on)
 #endif
 }
 
-void CIO::setM17Int(bool on)
-{
-#if defined(USE_ALTERNATE_M17_LEDS)
-  digitalWrite(PIN_DSTAR, on ? HIGH : LOW);
-  digitalWrite(PIN_P25,   on ? HIGH : LOW);
-#else
-  digitalWrite(PIN_M17, on ? HIGH : LOW);
-#endif
-}
-
 void CIO::setPOCSAGInt(bool on)
 {
 #if defined(USE_ALTERNATE_POCSAG_LEDS)

IOSTM.cpp

@@ -106,14 +106,6 @@ void CIO::initInt()
    GPIO_Init(PORT_NXDN, &GPIO_InitStruct);
 #endif
 
-#if !defined(USE_ALTERNATE_M17_LEDS)
-   // M17 pin
-   RCC_AHB1PeriphClockCmd(RCC_Per_M17, ENABLE);
-   GPIO_InitStruct.GPIO_Pin   = PIN_M17;
-   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
-   GPIO_Init(PORT_M17, &GPIO_InitStruct);
-#endif
-
 #if !defined(USE_ALTERNATE_POCSAG_LEDS)
    // POCSAG pin
    RCC_AHB1PeriphClockCmd(RCC_Per_POCSAG, ENABLE);
@@ -165,14 +157,6 @@ void CIO::initInt()
    GPIO_Init(PORT_MNXDN, &GPIO_InitStruct);
 #endif
 
-#if !defined(USE_ALTERNATE_M17_LEDS)
-   // M17 mode pin
-   RCC_AHB1PeriphClockCmd(RCC_Per_MM17, ENABLE);
-   GPIO_InitStruct.GPIO_Pin   = PIN_MM17;
-   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
-   GPIO_Init(PORT_MM17, &GPIO_InitStruct);
-#endif
-
 #if !defined(USE_ALTERNATE_POCSAG_LEDS)
    // POCSAG mode pin
    RCC_AHB1PeriphClockCmd(RCC_Per_MPOCSAG, ENABLE);
@@ -457,27 +441,6 @@ void CIO::setNXDNInt(bool on)
 #endif
 }
 
-void CIO::setM17Int(bool on)
-{
-#if defined(MODE_LEDS)
-#if defined(USE_ALTERNATE_M17_LEDS)
-   GPIO_WriteBit(PORT_DSTAR, PIN_DSTAR, on ? Bit_SET : Bit_RESET);
-   GPIO_WriteBit(PORT_P25,   PIN_P25, on ? Bit_SET : Bit_RESET);
-#else
-   GPIO_WriteBit(PORT_M17, PIN_M17, on ? Bit_SET : Bit_RESET);
-#endif
-#endif
-
-#if defined(MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && (defined(STM32F4_NUCLEO) || defined(STM32F722_RPT_HAT))
-#if defined(USE_ALTERNATE_M17_LEDS)
-   GPIO_WriteBit(PORT_MDSTAR, PIN_MDSTAR, on ? Bit_SET : Bit_RESET);
-   GPIO_WriteBit(PORT_MP25,   PIN_MP25,   on ? Bit_SET : Bit_RESET);
-#else
-   GPIO_WriteBit(PORT_MM17, PIN_MM17, on ? Bit_SET : Bit_RESET);
-#endif
-#endif
-}
-
 void CIO::setPOCSAGInt(bool on)
 {
 #if defined(MODE_LEDS)

IOSTM_CMSIS.cpp

@@ -225,9 +225,6 @@ static inline void GPIOInit()
 #if !defined(USE_ALTERNATE_NXDN_LEDS)
   GPIOConfigPin(PORT_NXDN,   PIN_NXDN,   GPIO_CRL_MODE0_1);
 #endif
-#if !defined(USE_ALTERNATE_M17_LEDS)
-  GPIOConfigPin(PORT_M17,    PIN_M17,    GPIO_CRL_MODE0_1);
-#endif
 #if !defined(USE_ALTERNATE_POCSAG_LEDS)
   GPIOConfigPin(PORT_POCSAG, PIN_POCSAG, GPIO_CRL_MODE0_1);
 #endif
@@ -453,16 +450,6 @@ void CIO::setNXDNInt(bool on)
 #endif
 }
 
-void CIO::setM17Int(bool on)
-{
-#if defined(USE_ALTERNATE_M17_LEDS)
-  BB_DSTAR = !!on;
-  BB_P25   = !!on;
-#else
-  BB_M17 = !!on;
-#endif
-}
-
 void CIO::setPOCSAGInt(bool on)
 {
 #if defined(USE_ALTERNATE_POCSAG_LEDS)

IOTeensy.cpp

@@ -75,9 +75,6 @@ void CIO::initInt()
 #if !defined(USE_ALTERNATE_NXDN_LEDS)
   pinMode(PIN_NXDN,   OUTPUT);
 #endif
-#if !defined(USE_ALTERNATE_M17_LEDS)
-  pinMode(PIN_M17,    OUTPUT);
-#endif
 #if !defined(USE_ALTERNATE_POCSAG_LEDS)
   pinMode(PIN_POCSAG, OUTPUT);
 #endif
@@ -241,16 +238,6 @@ void CIO::setNXDNInt(bool on)
 #endif
 }
 
-void CIO::setM17Int(bool on)
-{
-#if defined(USE_ALTERNATE_M17_LEDS)
-  digitalWrite(PIN_DSTAR, on ? HIGH : LOW);
-  digitalWrite(PIN_P25,   on ? HIGH : LOW);
-#else
-  digitalWrite(PIN_M17, on ? HIGH : LOW);
-#endif
-}
-
 void CIO::setPOCSAGInt(bool on)
 {
 #if defined(USE_ALTERNATE_POCSAG_LEDS)

M17Defines.h

@@ -1,47 +0,0 @@
-/*
- *   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
- *   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(M17DEFINES_H)
-#define  M17DEFINES_H
-
-const unsigned int M17_RADIO_SYMBOL_LENGTH = 5U;      // At 24 kHz sample rate
-
-const unsigned int M17_FRAME_LENGTH_BITS    = 384U;
-const unsigned int M17_FRAME_LENGTH_BYTES   = M17_FRAME_LENGTH_BITS / 8U;
-const unsigned int M17_FRAME_LENGTH_SYMBOLS = M17_FRAME_LENGTH_BITS / 2U;
-const unsigned int M17_FRAME_LENGTH_SAMPLES = M17_FRAME_LENGTH_SYMBOLS * M17_RADIO_SYMBOL_LENGTH;
-
-const unsigned int M17_SYNC_LENGTH_BITS    = 16U;
-const unsigned int M17_SYNC_LENGTH_SYMBOLS = M17_SYNC_LENGTH_BITS / 2U;
-const unsigned int M17_SYNC_LENGTH_SAMPLES = M17_SYNC_LENGTH_SYMBOLS * M17_RADIO_SYMBOL_LENGTH;
-
-const uint8_t M17_SYNC_BYTES[]      = {0x32U, 0x43U};
-const uint8_t M17_SYNC_BYTES_LENGTH = 2U;
-
-const uint16_t M17_SYNC_BITS      = 0x3243U;
-
-// 3     2      4      3
-// 00 11 00 10  01 00  00 11
-// +1 -3 +1 -1  +3 +1  +1 -3
-
-const int8_t M17_SYNC_SYMBOLS_VALUES[] = {+1, -3, +1, -1, +3, +1, +1, -3};
-
-const uint8_t M17_SYNC_SYMBOLS = 0xAEU;
-
-#endif
-

M17RX.cpp

@@ -1,404 +0,0 @@
-/*
- *   Copyright (C) 2009-2017,2020 by Jonathan Naylor G4KLX
- *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   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 "M17RX.h"
-#include "Utils.h"
-
-const q15_t SCALING_FACTOR = 18750;      // Q15(0.55)
-
-const uint8_t MAX_SYNC_BIT_START_ERRS = 2U;
-const uint8_t MAX_SYNC_BIT_RUN_ERRS   = 4U;
-
-const uint8_t MAX_SYNC_SYMBOLS_ERRS = 3U;
-
-const uint8_t BIT_MASK_TABLE[] = {0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02U, 0x01U};
-
-#define WRITE_BIT1(p,i,b) p[(i)>>3] = (b) ? (p[(i)>>3] | BIT_MASK_TABLE[(i)&7]) : (p[(i)>>3] & ~BIT_MASK_TABLE[(i)&7])
-
-const uint8_t NOAVEPTR = 99U;
-
-const uint16_t NOENDPTR = 9999U;
-
-const unsigned int MAX_SYNC_FRAMES = 1U + 1U;
-
-CM17RX::CM17RX() :
-m_state(M17RXS_NONE),
-m_bitBuffer(),
-m_buffer(),
-m_bitPtr(0U),
-m_dataPtr(0U),
-m_startPtr(NOENDPTR),
-m_endPtr(NOENDPTR),
-m_syncPtr(NOENDPTR),
-m_minSyncPtr(NOENDPTR),
-m_maxSyncPtr(NOENDPTR),
-m_maxCorr(0),
-m_lostCount(0U),
-m_countdown(0U),
-m_centre(),
-m_centreVal(0),
-m_threshold(),
-m_thresholdVal(0),
-m_averagePtr(NOAVEPTR),
-m_rssiAccum(0U),
-m_rssiCount(0U)
-{
-}
-
-void CM17RX::reset()
-{
-  m_state        = M17RXS_NONE;
-  m_dataPtr      = 0U;
-  m_bitPtr       = 0U;
-  m_maxCorr      = 0;
-  m_averagePtr   = NOAVEPTR;
-  m_startPtr     = NOENDPTR;
-  m_endPtr       = NOENDPTR;
-  m_syncPtr      = NOENDPTR;
-  m_minSyncPtr   = NOENDPTR;
-  m_maxSyncPtr   = NOENDPTR;
-  m_centreVal    = 0;
-  m_thresholdVal = 0;
-  m_lostCount    = 0U;
-  m_countdown    = 0U;
-  m_rssiAccum    = 0U;
-  m_rssiCount    = 0U;
-}
-
-void CM17RX::samples(const q15_t* samples, uint16_t* rssi, uint8_t length)
-{
-  for (uint8_t i = 0U; i < length; i++) {
-    q15_t sample = samples[i];
-
-    m_rssiAccum += rssi[i];
-    m_rssiCount++;
-
-    m_bitBuffer[m_bitPtr] <<= 1;
-    if (sample < 0)
-      m_bitBuffer[m_bitPtr] |= 0x01U;
-
-    m_buffer[m_dataPtr] = sample;
-
-    switch (m_state) {
-    case M17RXS_DATA:
-      processData(sample);
-      break;
-    default:
-      processNone(sample);
-      break;
-    }
-
-    m_dataPtr++;
-    if (m_dataPtr >= M17_FRAME_LENGTH_SAMPLES)
-      m_dataPtr = 0U;
-
-    m_bitPtr++;
-    if (m_bitPtr >= M17_RADIO_SYMBOL_LENGTH)
-      m_bitPtr = 0U;
-  }
-}
-
-void CM17RX::processNone(q15_t sample)
-{
-  bool ret = correlateSync();
-  if (ret) {
-    // On the first sync, start the countdown to the state change
-    if (m_countdown == 0U) {
-      m_rssiAccum = 0U;
-      m_rssiCount = 0U;
-
-      io.setDecode(true);
-      io.setADCDetection(true);
-
-      m_averagePtr = NOAVEPTR;
-
-      m_countdown = 5U;
-    }
-  }
-
-  if (m_countdown > 0U)
-    m_countdown--;
-
-  if (m_countdown == 1U) {
-    m_minSyncPtr = m_syncPtr + M17_FRAME_LENGTH_SAMPLES - 1U;
-    if (m_minSyncPtr >= M17_FRAME_LENGTH_SAMPLES)
-      m_minSyncPtr -= M17_FRAME_LENGTH_SAMPLES;
-
-    m_maxSyncPtr = m_syncPtr + 1U;
-    if (m_maxSyncPtr >= M17_FRAME_LENGTH_SAMPLES)
-      m_maxSyncPtr -= M17_FRAME_LENGTH_SAMPLES;
-
-    m_state      = M17RXS_DATA;
-    m_countdown  = 0U;
-  }
-}
-
-void CM17RX::processData(q15_t sample)
-{
-  if (m_minSyncPtr < m_maxSyncPtr) {
-    if (m_dataPtr >= m_minSyncPtr && m_dataPtr <= m_maxSyncPtr)
-      correlateSync();
-  } else {
-    if (m_dataPtr >= m_minSyncPtr || m_dataPtr <= m_maxSyncPtr)
-      correlateSync();
-  }
-
-  if (m_dataPtr == m_endPtr) {
-    // Only update the centre and threshold if they are from a good sync
-    if (m_lostCount == MAX_SYNC_FRAMES) {
-      m_minSyncPtr = m_syncPtr + M17_FRAME_LENGTH_SAMPLES - 1U;
-      if (m_minSyncPtr >= M17_FRAME_LENGTH_SAMPLES)
-        m_minSyncPtr -= M17_FRAME_LENGTH_SAMPLES;
-
-      m_maxSyncPtr = m_syncPtr + 1U;
-      if (m_maxSyncPtr >= M17_FRAME_LENGTH_SAMPLES)
-        m_maxSyncPtr -= M17_FRAME_LENGTH_SAMPLES;
-    }
-
-    calculateLevels(m_startPtr, M17_FRAME_LENGTH_SYMBOLS);
-
-    DEBUG4("M17RX: sync found pos/centre/threshold", m_syncPtr, m_centreVal, m_thresholdVal);
-
-    uint8_t frame[M17_FRAME_LENGTH_BYTES + 3U];
-    samplesToBits(m_startPtr, M17_FRAME_LENGTH_SYMBOLS, frame, 8U, m_centreVal, m_thresholdVal);
-
-    // We've not seen a data sync for too long, signal RXLOST and change to RX_NONE
-    m_lostCount--;
-    if (m_lostCount == 0U) {
-      DEBUG1("M17RX: sync timed out, lost lock");
-
-      io.setDecode(false);
-      io.setADCDetection(false);
-
-      serial.writeM17Lost();
-
-      m_state      = M17RXS_NONE;
-      m_endPtr     = NOENDPTR;
-      m_averagePtr = NOAVEPTR;
-      m_countdown  = 0U;
-      m_maxCorr    = 0;
-    } else {
-      frame[0U] = m_lostCount == (MAX_SYNC_FRAMES - 1U) ? 0x01U : 0x00U;
-      writeRSSIData(frame);
-      m_maxCorr = 0;
-    }
-  }
-}
-
-bool CM17RX::correlateSync()
-{
-  if (countBits8(m_bitBuffer[m_bitPtr] ^ M17_SYNC_SYMBOLS) <= MAX_SYNC_SYMBOLS_ERRS) {
-    uint16_t ptr = m_dataPtr + M17_FRAME_LENGTH_SAMPLES - M17_SYNC_LENGTH_SAMPLES + M17_RADIO_SYMBOL_LENGTH;
-    if (ptr >= M17_FRAME_LENGTH_SAMPLES)
-      ptr -= M17_FRAME_LENGTH_SAMPLES;
-
-    q31_t corr = 0;
-    q15_t min =  16000;
-    q15_t max = -16000;
-
-    for (uint8_t i = 0U; i < M17_SYNC_LENGTH_SYMBOLS; i++) {
-      q15_t val = m_buffer[ptr];
-
-      if (val > max)
-        max = val;
-      if (val < min)
-        min = val;
-
-      switch (M17_SYNC_SYMBOLS_VALUES[i]) {
-      case +3:
-        corr -= (val + val + val);
-        break;
-      case +1:
-        corr -= val;
-        break;
-      case -1:
-        corr += val;
-        break;
-      default:  // -3
-        corr += (val + val + val);
-        break;
-      }
-
-      ptr += M17_RADIO_SYMBOL_LENGTH;
-      if (ptr >= M17_FRAME_LENGTH_SAMPLES)
-        ptr -= M17_FRAME_LENGTH_SAMPLES;
-    }
-
-    if (corr > m_maxCorr) {
-      if (m_averagePtr == NOAVEPTR) {
-        m_centreVal = (max + min) >> 1;
-
-        q31_t v1 = (max - m_centreVal) * SCALING_FACTOR;
-        m_thresholdVal = q15_t(v1 >> 15);
-      }
-
-      uint16_t startPtr = m_dataPtr + M17_FRAME_LENGTH_SAMPLES - M17_SYNC_LENGTH_SAMPLES + M17_RADIO_SYMBOL_LENGTH;
-      if (startPtr >= M17_FRAME_LENGTH_SAMPLES)
-        startPtr -= M17_FRAME_LENGTH_SAMPLES;
-
-      uint8_t sync[M17_SYNC_BYTES_LENGTH];
-      samplesToBits(startPtr, M17_SYNC_LENGTH_SYMBOLS, sync, 0U, m_centreVal, m_thresholdVal);
-
-      uint8_t maxErrs;
-      if (m_state == M17RXS_NONE)
-        maxErrs = MAX_SYNC_BIT_START_ERRS;
-      else
-        maxErrs = MAX_SYNC_BIT_RUN_ERRS;
-
-      uint8_t errs = 0U;
-      for (uint8_t i = 0U; i < M17_SYNC_BYTES_LENGTH; i++)
-        errs += countBits8(sync[i] ^ M17_SYNC_BYTES[i]);
-
-      if (errs <= maxErrs) {
-        m_maxCorr   = corr;
-        m_lostCount = MAX_SYNC_FRAMES;
-        m_syncPtr   = m_dataPtr;
-
-        m_startPtr = startPtr;
-
-        m_endPtr = m_dataPtr + M17_FRAME_LENGTH_SAMPLES - M17_SYNC_LENGTH_SAMPLES - 1U;
-        if (m_endPtr >= M17_FRAME_LENGTH_SAMPLES)
-          m_endPtr -= M17_FRAME_LENGTH_SAMPLES;
-
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
-void CM17RX::calculateLevels(uint16_t start, uint16_t count)
-{
-  q15_t maxPos = -16000;
-  q15_t minPos =  16000;
-  q15_t maxNeg =  16000;
-  q15_t minNeg = -16000;
-
-  for (uint16_t i = 0U; i < count; i++) {
-    q15_t sample = m_buffer[start];
-
-    if (sample > 0) {
-      if (sample > maxPos)
-        maxPos = sample;
-      if (sample < minPos)
-        minPos = sample;
-    } else {
-      if (sample < maxNeg)
-        maxNeg = sample;
-      if (sample > minNeg)
-        minNeg = sample;
-    }
-
-    start += M17_RADIO_SYMBOL_LENGTH;
-    if (start >= M17_FRAME_LENGTH_SAMPLES)
-      start -= M17_FRAME_LENGTH_SAMPLES;
-  }
-
-  q15_t posThresh = (maxPos + minPos) >> 1;
-  q15_t negThresh = (maxNeg + minNeg) >> 1;
-
-  q15_t centre = (posThresh + negThresh) >> 1;
-
-  q15_t threshold = posThresh - centre;
-
-  DEBUG5("M17RX: pos/neg/centre/threshold", posThresh, negThresh, centre, threshold);
-
-  if (m_averagePtr == NOAVEPTR) {
-    for (uint8_t i = 0U; i < 16U; i++) {
-      m_centre[i] = centre;
-      m_threshold[i] = threshold;
-    }
-
-    m_averagePtr = 0U;
-  } else {
-    m_centre[m_averagePtr] = centre;
-    m_threshold[m_averagePtr] = threshold;
-
-    m_averagePtr++;
-    if (m_averagePtr >= 16U)
-      m_averagePtr = 0U;
-  }
-
-  m_centreVal = 0;
-  m_thresholdVal = 0;
-
-  for (uint8_t i = 0U; i < 16U; i++) {
-    m_centreVal += m_centre[i];
-    m_thresholdVal += m_threshold[i];
-  }
-
-  m_centreVal >>= 4;
-  m_thresholdVal >>= 4;
-}
-
-void CM17RX::samplesToBits(uint16_t start, uint16_t count, uint8_t* buffer, uint16_t offset, q15_t centre, q15_t threshold)
-{
-  for (uint16_t i = 0U; i < count; i++) {
-    q15_t sample = m_buffer[start] - centre;
-
-    if (sample < -threshold) {
-      WRITE_BIT1(buffer, offset, false);
-      offset++;
-      WRITE_BIT1(buffer, offset, true);
-      offset++;
-    } else if (sample < 0) {
-      WRITE_BIT1(buffer, offset, false);
-      offset++;
-      WRITE_BIT1(buffer, offset, false);
-      offset++;
-    } else if (sample < threshold) {
-      WRITE_BIT1(buffer, offset, true);
-      offset++;
-      WRITE_BIT1(buffer, offset, false);
-      offset++;
-    } else {
-      WRITE_BIT1(buffer, offset, true);
-      offset++;
-      WRITE_BIT1(buffer, offset, true);
-      offset++;
-    }
-
-    start += M17_RADIO_SYMBOL_LENGTH;
-    if (start >= M17_FRAME_LENGTH_SAMPLES)
-      start -= M17_FRAME_LENGTH_SAMPLES;
-  }
-}
-
-void CM17RX::writeRSSIData(uint8_t* data)
-{
-#if defined(SEND_RSSI_DATA)
-  if (m_rssiCount > 0U) {
-    uint16_t rssi = m_rssiAccum / m_rssiCount;
-
-    data[121U] = (rssi >> 8) & 0xFFU;
-    data[122U] = (rssi >> 0) & 0xFFU;
-
-    serial.writeM17Data(data, M17_FRAME_LENGTH_BYTES + 3U);
-  } else {
-    serial.writeM17Data(data, M17_FRAME_LENGTH_BYTES + 1U);
-  }
-#else
-  serial.writeM17Data(data, M17_FRAME_LENGTH_BYTES + 1U);
-#endif
-
-  m_rssiAccum = 0U;
-  m_rssiCount = 0U;
-}

M17RX.h

@@ -1,69 +0,0 @@
-/*
- *   Copyright (C) 2015,2016,2017,2020 by Jonathan Naylor G4KLX
- *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   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(M17RX_H)
-#define  M17RX_H
-
-#include "Config.h"
-#include "M17Defines.h"
-
-enum M17RX_STATE {
-  M17RXS_NONE,
-  M17RXS_DATA
-};
-
-class CM17RX {
-public:
-  CM17RX();
-
-  void samples(const q15_t* samples, uint16_t* rssi, uint8_t length);
-
-  void reset();
-
-private:
-  M17RX_STATE m_state;
-  uint8_t     m_bitBuffer[M17_RADIO_SYMBOL_LENGTH];
-  q15_t       m_buffer[M17_FRAME_LENGTH_SAMPLES];
-  uint16_t    m_bitPtr;
-  uint16_t    m_dataPtr;
-  uint16_t    m_startPtr;
-  uint16_t    m_endPtr;
-  uint16_t    m_syncPtr;
-  uint16_t    m_minSyncPtr;
-  uint16_t    m_maxSyncPtr;
-  q31_t       m_maxCorr;
-  uint16_t    m_lostCount;
-  uint8_t     m_countdown;
-  q15_t       m_centre[16U];
-  q15_t       m_centreVal;
-  q15_t       m_threshold[16U];
-  q15_t       m_thresholdVal;
-  uint8_t     m_averagePtr;
-  uint32_t    m_rssiAccum;
-  uint16_t    m_rssiCount;
-
-  void processNone(q15_t sample);
-  void processData(q15_t sample);
-  bool correlateSync();
-  void calculateLevels(uint16_t start, uint16_t count);
-  void samplesToBits(uint16_t start, uint16_t count, uint8_t* buffer, uint16_t offset, q15_t centre, q15_t threshold);
-  void writeRSSIData(uint8_t* data);
-};
-
-#endif
-

M17TX.cpp

@@ -1,183 +0,0 @@
-/*
- *   Copyright (C) 2009-2018,2020 by Jonathan Naylor G4KLX
- *   Copyright (C) 2017 by Andy Uribe CA6JAU
- *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#include "Config.h"
-#include "Globals.h"
-#include "M17TX.h"
-
-#include "M17Defines.h"
-
-// Generated using rcosdesign(0.5, 8, 5, 'sqrt') in MATLAB
-static q15_t RRC_0_5_FILTER[] = {0, 0, 0, 0, -290, -174, 142, 432, 438, 90, -387, -561, -155, 658, 1225, 767,
-				  -980, -3326, -4648, -3062, 2527, 11552, 21705, 29724, 32767, 29724, 21705,
-				  11552, 2527, -3062, -4648, -3326, -980, 767, 1225, 658, -155, -561, -387, 90,
-				  438, 432, 142, -174, -290}; // numTaps = 45, L = 5
-const uint16_t RRC_0_5_FILTER_PHASE_LEN = 9U; // phaseLength = numTaps/L
-
-const q15_t M17_LEVELA =  1683;
-const q15_t M17_LEVELB =  561;
-const q15_t M17_LEVELC = -561;
-const q15_t M17_LEVELD = -1683;
-
-const uint8_t M17_START_SYNC = 0x77U;
-const uint8_t M17_END_SYNC   = 0xFFU;
-const uint8_t M17_HANG       = 0x00U;
-
-CM17TX::CM17TX() :
-m_buffer(TX_BUFFER_LEN),
-m_modFilter(),
-m_modState(),
-m_poBuffer(),
-m_poLen(0U),
-m_poPtr(0U),
-m_txDelay(240U),      // 200ms
-m_txHang(4800U),      // 4s
-m_txCount(0U)
-{
-  ::memset(m_modState, 0x00U, 16U * sizeof(q15_t));
-
-  m_modFilter.L           = M17_RADIO_SYMBOL_LENGTH;
-  m_modFilter.phaseLength = RRC_0_5_FILTER_PHASE_LEN;
-  m_modFilter.pCoeffs     = RRC_0_5_FILTER;
-  m_modFilter.pState      = m_modState;
-}
-
-void CM17TX::process()
-{
-  // If we have M17 data to transmit, do so.
-  if (m_poLen == 0U && m_buffer.getData() > 0U) {
-    if (!m_tx) {
-      for (uint16_t i = 0U; i < m_txDelay; i++)
-        m_poBuffer[m_poLen++] = M17_START_SYNC;
-    } else {
-      for (uint8_t i = 0U; i < M17_FRAME_LENGTH_BYTES; i++) {
-        uint8_t c = m_buffer.get();
-        m_poBuffer[m_poLen++] = c;
-      }
-    }
-
-    m_poPtr = 0U;
-  }
-
-  if (m_poLen > 0U) {
-    // Transmit M17 data.
-    uint16_t space = io.getSpace();
-
-    while (space > (4U * M17_RADIO_SYMBOL_LENGTH)) {
-      uint8_t c = m_poBuffer[m_poPtr++];
-      writeByte(c);
-
-      // Reduce space and reset the hang timer.
-      space -= 4U * M17_RADIO_SYMBOL_LENGTH;
-      if (m_duplex)
-        m_txCount = m_txHang;
-
-      if (m_poPtr >= m_poLen) {
-        m_poPtr = 0U;
-        m_poLen = 0U;
-        return;
-      }
-    }
-  } else if (m_txCount > 0U) {
-    // Transmit silence until the hang timer has expired.
-    uint16_t space = io.getSpace();
-
-    while (space > (4U * M17_RADIO_SYMBOL_LENGTH)) {
-      writeSilence();
-
-      space -= 4U * M17_RADIO_SYMBOL_LENGTH;
-      m_txCount--;
-
-      if (m_txCount == 0U)
-        return;
-    }
-  }
-}
-
-uint8_t CM17TX::writeData(const uint8_t* data, uint8_t length)
-{
-  if (length != (M17_FRAME_LENGTH_BYTES + 1U))
-    return 4U;
-
-  uint16_t space = m_buffer.getSpace();
-  if (space < M17_FRAME_LENGTH_BYTES)
-    return 5U;
-
-  for (uint8_t i = 0U; i < M17_FRAME_LENGTH_BYTES; i++)
-    m_buffer.put(data[i + 1U]);
-
-  return 0U;
-}
-
-void CM17TX::writeByte(uint8_t c)
-{
-  q15_t inBuffer[4U];
-  q15_t outBuffer[M17_RADIO_SYMBOL_LENGTH * 4U];
-
-  const uint8_t MASK = 0xC0U;
-
-  for (uint8_t i = 0U; i < 4U; i++, c <<= 2) {
-    switch (c & MASK) {
-      case 0xC0U:
-        inBuffer[i] = M17_LEVELA;
-        break;
-      case 0x80U:
-        inBuffer[i] = M17_LEVELB;
-        break;
-      case 0x00U:
-        inBuffer[i] = M17_LEVELC;
-        break;
-      default:
-        inBuffer[i] = M17_LEVELD;
-        break;
-    }
-  }
-
-  ::arm_fir_interpolate_q15(&m_modFilter, inBuffer, outBuffer, 4U);
-
-  io.write(STATE_M17, outBuffer, M17_RADIO_SYMBOL_LENGTH * 4U);
-}
-
-void CM17TX::writeSilence()
-{
-  q15_t inBuffer[4U] = {0x00U, 0x00U, 0x00U, 0x00U};
-  q15_t outBuffer[M17_RADIO_SYMBOL_LENGTH * 4U];
-
-  ::arm_fir_interpolate_q15(&m_modFilter, inBuffer, outBuffer, 4U);
-
-  io.write(STATE_M17, outBuffer, M17_RADIO_SYMBOL_LENGTH * 4U);
-}
-
-void CM17TX::setTXDelay(uint8_t delay)
-{
-  m_txDelay = 600U + uint16_t(delay) * 12U;        // 500ms + tx delay
-
-  if (m_txDelay > 1200U)
-    m_txDelay = 1200U;
-}
-
-uint8_t CM17TX::getSpace() const
-{
-  return m_buffer.getSpace() / M17_FRAME_LENGTH_BYTES;
-}
-
-void CM17TX::setParams(uint8_t txHang)
-{
-  m_txHang = txHang * 1200U;
-}

MMDVM.cpp

@@ -31,9 +31,9 @@ bool m_dmrEnable    = true;
 bool m_ysfEnable    = true;
 bool m_p25Enable    = true;
 bool m_nxdnEnable   = true;
-bool m_m17Enable    = true;
 bool m_pocsagEnable = true;
 bool m_fmEnable     = true;
+bool m_ax25Enable   = true;
 
 bool m_duplex = true;
 
@@ -59,12 +59,11 @@ CP25TX     p25TX;
 CNXDNRX    nxdnRX;
 CNXDNTX    nxdnTX;
 
-CM17RX     m17RX;
-CM17TX     m17TX;
-
 CPOCSAGTX  pocsagTX;
 
 CFM        fm;
+CAX25RX    ax25RX;
+CAX25TX    ax25TX;
 
 CCalDStarRX calDStarRX;
 CCalDStarTX calDStarTX;
@@ -111,12 +110,12 @@ void loop()
   if (m_nxdnEnable && m_modemState == STATE_NXDN)
     nxdnTX.process();
 
-  if (m_m17Enable && m_modemState == STATE_M17)
-    m17TX.process();
-
   if (m_pocsagEnable && (m_modemState == STATE_POCSAG || pocsagTX.busy()))
     pocsagTX.process();
 
+  if (m_ax25Enable && (m_modemState == STATE_IDLE || m_modemState == STATE_FM))
+    ax25TX.process();
+
   if (m_fmEnable && m_modemState == STATE_FM)
     fm.process();
 

MMDVM.ino

@@ -28,9 +28,9 @@ bool m_dmrEnable    = true;
 bool m_ysfEnable    = true;
 bool m_p25Enable    = true;
 bool m_nxdnEnable   = true;
-bool m_m17Enable    = true;
 bool m_pocsagEnable = true;
 bool m_fmEnable     = true;
+bool m_ax25Enable   = true;
 
 bool m_duplex = true;
 
@@ -56,12 +56,11 @@ CP25TX     p25TX;
 CNXDNRX    nxdnRX;
 CNXDNTX    nxdnTX;
 
-CM17RX     m17RX;
-CM17TX     m17TX;
-
 CPOCSAGTX  pocsagTX;
 
 CFM        fm;
+CAX25RX    ax25RX;
+CAX25      ax25TX;
 
 CCalDStarRX calDStarRX;
 CCalDStarTX calDStarTX;
@@ -108,12 +107,12 @@ void loop()
   if (m_nxdnEnable && m_modemState == STATE_NXDN)
     nxdnTX.process();
 
-  if (m_m17Enable && m_modemState == STATE_M17)
-    m17TX.process();
-
   if (m_pocsagEnable && (m_modemState == STATE_POCSAG || pocsagTX.busy()))
     pocsagTX.process();
 
+  if (m_ax25Enable && (m_modemState == STATE_IDLE || m_modemState == STATE_FM))
+    ax25TX.process();
+
   if (m_fmEnable && m_modemState == STATE_FM)
     fm.process();
 

NXDNTX.cpp

@@ -122,7 +122,7 @@ void CNXDNTX::process()
   }
 }
 
-uint8_t CNXDNTX::writeData(const uint8_t* data, uint8_t length)
+uint8_t CNXDNTX::writeData(const uint8_t* data, uint16_t length)
 {
   if (length != (NXDN_FRAME_LENGTH_BYTES + 1U))
     return 4U;

NXDNTX.h

@@ -27,7 +27,7 @@ class CNXDNTX {
 public:
   CNXDNTX();
 
-  uint8_t writeData(const uint8_t* data, uint8_t length);
+  uint8_t writeData(const uint8_t* data, uint16_t length);
 
   void process();
 

P25TX.cpp

@@ -118,7 +118,7 @@ void CP25TX::process()
   }
 }
 
-uint8_t CP25TX::writeData(const uint8_t* data, uint8_t length)
+uint8_t CP25TX::writeData(const uint8_t* data, uint16_t length)
 {
   if (length < (P25_TERM_FRAME_LENGTH_BYTES + 1U))
     return 4U;

P25TX.h

@@ -27,7 +27,7 @@ class CP25TX {
 public:
   CP25TX();
 
-  uint8_t writeData(const uint8_t* data, uint8_t length);
+  uint8_t writeData(const uint8_t* data, uint16_t length);
 
   void process();
 

POCSAGTX.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2018 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2018,2020 by Jonathan Naylor G4KLX
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -95,7 +95,7 @@ bool CPOCSAGTX::busy()
     return false;
 }
 
-uint8_t CPOCSAGTX::writeData(const uint8_t* data, uint8_t length)
+uint8_t CPOCSAGTX::writeData(const uint8_t* data, uint16_t length)
 {
   if (length != POCSAG_FRAME_LENGTH_BYTES)
     return 4U;

POCSAGTX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015-2019 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015-2020 by Jonathan Naylor G4KLX
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -27,7 +27,7 @@ class CPOCSAGTX {
 public:
   CPOCSAGTX();
 
-  uint8_t writeData(const uint8_t* data, uint8_t length);
+  uint8_t writeData(const uint8_t* data, uint16_t length);
 
   void writeByte(uint8_t c);
 

SerialPort.cpp

@@ -63,11 +63,10 @@ const uint8_t MMDVM_P25_LOST     = 0x32U;
 const uint8_t MMDVM_NXDN_DATA    = 0x40U;
 const uint8_t MMDVM_NXDN_LOST    = 0x41U;
 
-const uint8_t MMDVM_M17_DATA     = 0x45U;
-const uint8_t MMDVM_M17_LOST     = 0x46U;
-
 const uint8_t MMDVM_POCSAG_DATA  = 0x50U;
 
+const uint8_t MMDVM_AX25_DATA    = 0x55U;
+
 const uint8_t MMDVM_FM_PARAMS1   = 0x60U;
 const uint8_t MMDVM_FM_PARAMS2   = 0x61U;
 const uint8_t MMDVM_FM_PARAMS3   = 0x62U;
@@ -106,7 +105,7 @@ const uint8_t MMDVM_DEBUG5       = 0xF5U;
 #define	HW_TYPE	"MMDVM"
 #endif
 
-#define DESCRIPTION "20201015 (D-Star/DMR/System Fusion/P25/NXDN/M17/POCSAG/FM)"
+#define DESCRIPTION "20200714 (D-Star/DMR/System Fusion/P25/NXDN/POCSAG/FM/AX.25)"
 
 #if defined(GITVERSION)
 #define concat(h, a, b, c) h " " a " " b " GitID #" c ""
@@ -161,7 +160,7 @@ void CSerialPort::getStatus()
 
   // Send all sorts of interesting internal values
   reply[0U]  = MMDVM_FRAME_START;
-  reply[1U]  = 14U;
+  reply[1U]  = 13U;
   reply[2U]  = MMDVM_GET_STATUS;
 
   reply[3U]  = 0x00U;
@@ -179,7 +178,7 @@ void CSerialPort::getStatus()
     reply[3U] |= 0x20U;
   if (m_fmEnable)
     reply[3U] |= 0x40U;
-  if (m_m17Enable)
+  if (m_ax25Enable)
     reply[3U] |= 0x80U;
 
   reply[4U]  = uint8_t(m_modemState);
@@ -245,8 +244,8 @@ void CSerialPort::getStatus()
   else
     reply[12U] = 0U;
 
-  if (m_m17Enable)
+  if (m_ax25Enable)
-    reply[13U] = m17TX.getSpace();
+    reply[13U] = ax25TX.getSpace();
   else
     reply[13U] = 0U;
 
@@ -272,9 +271,9 @@ void CSerialPort::getVersion()
   writeInt(1U, reply, count);
 }
 
-uint8_t CSerialPort::setConfig(const uint8_t* data, uint8_t length)
+uint8_t CSerialPort::setConfig(const uint8_t* data, uint16_t length)
 {
-  if (length < 23U)
+  if (length < 24U)
     return 4U;
 
   bool rxInvert        = (data[0U] & 0x01U) == 0x01U;
@@ -293,7 +292,7 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint8_t length)
   bool nxdnEnable   = (data[1U] & 0x10U) == 0x10U;
   bool pocsagEnable = (data[1U] & 0x20U) == 0x20U;
   bool fmEnable     = (data[1U] & 0x40U) == 0x40U;
-  bool m17Enable    = (data[1U] & 0x80U) == 0x80U;
+  bool ax25Enable   = (data[1U] & 0x80U) == 0x80U;
 
   uint8_t txDelay = data[2U];
   if (txDelay > 50U)
@@ -301,7 +300,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_M17 && modemState != STATE_POCSAG && modemState != STATE_FM && modemState != STATE_DSTARCAL && modemState != STATE_DMRCAL && modemState != STATE_RSSICAL && modemState != STATE_LFCAL && modemState != STATE_DMRCAL1K && modemState != STATE_P25CAL1K && modemState != STATE_DMRDMO1K && modemState != STATE_NXDNCAL1K && modemState != STATE_POCSAGCAL && modemState != STATE_FMCAL10K && modemState != STATE_FMCAL12K && modemState != STATE_FMCAL15K && modemState != STATE_FMCAL20K && modemState != STATE_FMCAL25K && modemState != STATE_FMCAL30K)
+  if (modemState != STATE_IDLE && modemState != STATE_DSTAR && modemState != STATE_DMR && modemState != STATE_YSF && modemState != STATE_P25 && modemState != STATE_NXDN && modemState != STATE_POCSAG && modemState != STATE_FM && modemState != STATE_DSTARCAL && modemState != STATE_DMRCAL && modemState != STATE_RSSICAL && modemState != STATE_LFCAL && modemState != STATE_DMRCAL1K && modemState != STATE_P25CAL1K && modemState != STATE_DMRDMO1K && modemState != STATE_NXDNCAL1K && modemState != STATE_POCSAGCAL && modemState != STATE_FMCAL10K && modemState != STATE_FMCAL12K && modemState != STATE_FMCAL15K && modemState != STATE_FMCAL20K && modemState != STATE_FMCAL25K && modemState != STATE_FMCAL30K)
     return 4U;
   if (modemState == STATE_DSTAR && !dstarEnable)
     return 4U;
@@ -313,8 +312,6 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint8_t length)
     return 4U;
   if (modemState == STATE_NXDN && !nxdnEnable)
     return 4U;
-  if (modemState == STATE_M17 && !m17Enable)
-    return 4U;
   if (modemState == STATE_POCSAG && !pocsagEnable)
     return 4U;
   if (modemState == STATE_FM && !fmEnable)
@@ -349,8 +346,15 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint8_t length)
 
   uint8_t nxdnTXHang    = data[20U];
 
-  uint8_t m17TXLevel    = data[21U];
+  uint8_t ax25TXLevel   = data[21U];
-  uint8_t m17TXHang     = data[22U];
+
+  int8_t ax25RXTwist    = int8_t(data[22U]) - 128;
+  if (ax25RXTwist < -4 || ax25RXTwist > 10)
+    return 4U;
+
+  int8_t ax25TXTwist    = int8_t(data[23U]) - 128;
+  if (ax25TXTwist < -4 || ax25TXTwist > 10)
+    return 4U;
 
   setMode(modemState);
 
@@ -359,9 +363,9 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint8_t length)
   m_ysfEnable    = ysfEnable;
   m_p25Enable    = p25Enable;
   m_nxdnEnable   = nxdnEnable;
-  m_m17Enable    = m17Enable;
   m_pocsagEnable = pocsagEnable;
   m_fmEnable     = fmEnable;
+  m_ax25Enable   = ax25Enable;
   m_duplex       = !simplex;
 
   dstarTX.setTXDelay(txDelay);
@@ -369,8 +373,8 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint8_t length)
   p25TX.setTXDelay(txDelay);
   dmrDMOTX.setTXDelay(txDelay);
   nxdnTX.setTXDelay(txDelay);
-  m17TX.setTXDelay(txDelay);
   pocsagTX.setTXDelay(txDelay);
+  ax25TX.setTXDelay(txDelay);
 
   dmrTX.setColorCode(colorCode);
   dmrRX.setColorCode(colorCode);
@@ -381,16 +385,17 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint8_t length)
   ysfTX.setParams(ysfLoDev, ysfTXHang);
   p25TX.setParams(p25TXHang);
   nxdnTX.setParams(nxdnTXHang);
-  m17TX.setParams(m17TXHang);
+  ax25RX.setParams(ax25RXTwist);
+  ax25TX.setParams(ax25TXTwist);
 
-  io.setParameters(rxInvert, txInvert, pttInvert, rxLevel, cwIdTXLevel, dstarTXLevel, dmrTXLevel, ysfTXLevel, p25TXLevel, nxdnTXLevel, m17TXLevel, pocsagTXLevel, fmTXLevel, txDCOffset, rxDCOffset, useCOSAsLockout);
+  io.setParameters(rxInvert, txInvert, pttInvert, rxLevel, cwIdTXLevel, dstarTXLevel, dmrTXLevel, ysfTXLevel, p25TXLevel, nxdnTXLevel, pocsagTXLevel, fmTXLevel, ax25TXLevel, txDCOffset, rxDCOffset, useCOSAsLockout);
 
   io.start();
 
   return 0U;
 }
 
-uint8_t CSerialPort::setFMParams1(const uint8_t* data, uint8_t length)
+uint8_t CSerialPort::setFMParams1(const uint8_t* data, uint16_t length)
 {
   if (length < 8U)
     return 4U;
@@ -415,7 +420,7 @@ uint8_t CSerialPort::setFMParams1(const uint8_t* data, uint8_t length)
   return fm.setCallsign(callsign, speed, frequency, time, holdoff, highLevel, lowLevel, callAtStart, callAtEnd, callAtLatch);
 }
 
-uint8_t CSerialPort::setFMParams2(const uint8_t* data, uint8_t length)
+uint8_t CSerialPort::setFMParams2(const uint8_t* data, uint16_t length)
 {
   if (length < 6U)
     return 4U;
@@ -435,7 +440,7 @@ uint8_t CSerialPort::setFMParams2(const uint8_t* data, uint8_t length)
   return fm.setAck(ack, speed, frequency, minTime, delay, level);
 }
 
-uint8_t CSerialPort::setFMParams3(const uint8_t* data, uint8_t length)
+uint8_t CSerialPort::setFMParams3(const uint8_t* data, uint16_t length)
 {
   if (length < 12U)
     return 4U;
@@ -461,7 +466,7 @@ uint8_t CSerialPort::setFMParams3(const uint8_t* data, uint8_t length)
   return fm.setMisc(timeout, timeoutLevel, ctcssFrequency, ctcssHighThreshold, ctcssLowThreshold, ctcssLevel, kerchunkTime, hangTime, accessMode, cosInvert, rfAudioBoost, maxDev, rxLevel);
 }
 
-uint8_t CSerialPort::setMode(const uint8_t* data, uint8_t length)
+uint8_t CSerialPort::setMode(const uint8_t* data, uint16_t length)
 {
   if (length < 1U)
     return 4U;
@@ -471,7 +476,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_M17 && modemState != STATE_POCSAG && modemState != STATE_FM && modemState != STATE_DSTARCAL && modemState != STATE_DMRCAL && modemState != STATE_RSSICAL && modemState != STATE_LFCAL && modemState != STATE_DMRCAL1K && modemState != STATE_P25CAL1K && modemState != STATE_DMRDMO1K && modemState != STATE_NXDNCAL1K && modemState != STATE_POCSAGCAL && modemState != STATE_FMCAL10K  && modemState != STATE_FMCAL12K && modemState != STATE_FMCAL15K && modemState != STATE_FMCAL20K && modemState != STATE_FMCAL25K && modemState != STATE_FMCAL30K)
+  if (modemState != STATE_IDLE && modemState != STATE_DSTAR && modemState != STATE_DMR && modemState != STATE_YSF && modemState != STATE_P25 && modemState != STATE_NXDN && modemState != STATE_POCSAG && modemState != STATE_FM && modemState != STATE_DSTARCAL && modemState != STATE_DMRCAL && modemState != STATE_RSSICAL && modemState != STATE_LFCAL && modemState != STATE_DMRCAL1K && modemState != STATE_P25CAL1K && modemState != STATE_DMRDMO1K && modemState != STATE_NXDNCAL1K && modemState != STATE_POCSAGCAL && modemState != STATE_FMCAL10K  && modemState != STATE_FMCAL12K && modemState != STATE_FMCAL15K && modemState != STATE_FMCAL20K && modemState != STATE_FMCAL25K && modemState != STATE_FMCAL30K)
     return 4U;
   if (modemState == STATE_DSTAR && !m_dstarEnable)
     return 4U;
@@ -483,8 +488,6 @@ uint8_t CSerialPort::setMode(const uint8_t* data, uint8_t length)
     return 4U;
   if (modemState == STATE_NXDN && !m_nxdnEnable)
     return 4U;
-  if (modemState == STATE_M17 && !m_m17Enable)
-    return 4U;
   if (modemState == STATE_POCSAG && !m_pocsagEnable)
     return 4U;
   if (modemState == STATE_FM && !m_fmEnable)
@@ -513,9 +516,6 @@ void CSerialPort::setMode(MMDVM_STATE modemState)
     case STATE_NXDN:
       DEBUG1("Mode set to NXDN");
       break;
-    case STATE_M17:
-      DEBUG1("Mode set to M17");
-      break;
     case STATE_POCSAG:
       DEBUG1("Mode set to POCSAG");
       break;
@@ -587,15 +587,14 @@ void CSerialPort::setMode(MMDVM_STATE modemState)
   if (modemState != STATE_NXDN)
     nxdnRX.reset();
 
-  if (modemState != STATE_M17)
-    m17RX.reset();
-
   if (modemState != STATE_FM)
     fm.reset();
 
   cwIdTX.reset();
 
-  io.setMode(modemState);
+  m_modemState = modemState;
+
+  io.setMode();
 }
 
 void CSerialPort::start()
@@ -618,15 +617,25 @@ void CSerialPort::process()
         m_buffer[0U] = c;
         m_ptr = 1U;
         m_len = 0U;
-      }
+      } else {
-      else {
         m_ptr = 0U;
         m_len = 0U;
       }
     } else if (m_ptr == 1U) {
-      // Handle the frame length
+      // Handle the frame length, 1/2
       m_len = m_buffer[m_ptr] = c;
       m_ptr = 2U;
+    } else if (m_ptr == 2U) {
+      // Handle the frame length, 2/2
+      m_buffer[m_ptr] = c;
+      m_ptr = 3U;
+
+      if (m_len == 0U)
+        m_len = c + 255U;
+
+      // The full packet has been received, process it
+      if (m_ptr == m_len)
+        processMessage(m_buffer + 3U, m_len - 3U);
     } else {
       // Any other bytes are added to the buffer
       m_buffer[m_ptr] = c;
@@ -634,6 +643,41 @@ void CSerialPort::process()
 
       // The full packet has been received, process it
       if (m_ptr == m_len) {
+        if (m_len > 255U)
+          processMessage(m_buffer + 4U, m_len - 4U);
+        else
+          processMessage(m_buffer + 3U, m_len - 3U);
+      }
+    }
+  }
+
+  if (io.getWatchdog() >= 48000U) {
+    m_ptr = 0U;
+    m_len = 0U;
+  }
+
+#if defined(SERIAL_REPEATER)
+  // Write any outgoing serial data
+  uint16_t space = m_repeat.getData();
+  if (space > 0U) {
+    int avail = availableForWriteInt(3U);
+    if (avail < space)
+      space = avail;
+
+    for (uint16_t i = 0U; i < space; i++) {
+      uint8_t c = m_repeat.get();
+      writeInt(3U, &c, 1U);
+    }
+  }
+
+  // Read any incoming serial data
+  while (availableInt(3U))
+    readInt(3U);
+#endif
+}
+
+void CSerialPort::processMessage(const uint8_t* buffer, uint16_t length)
+{
   uint8_t err = 2U;
 
   switch (m_buffer[2U]) {
@@ -646,7 +690,7 @@ void CSerialPort::process()
       break;
 
     case MMDVM_SET_CONFIG:
-            err = setConfig(m_buffer + 3U, m_len - 3U);
+      err = setConfig(buffer, length);
       if (err == 0U)
         sendACK();
       else
@@ -654,7 +698,7 @@ void CSerialPort::process()
       break;
 
     case MMDVM_SET_MODE:
-            err = setMode(m_buffer + 3U, m_len - 3U);
+      err = setMode(buffer, length);
       if (err == 0U)
         sendACK();
       else
@@ -666,7 +710,7 @@ void CSerialPort::process()
       break;
 
     case MMDVM_FM_PARAMS1:
-            err = setFMParams1(m_buffer + 3U, m_len - 3U);
+      err = setFMParams1(buffer, length);
       if (err == 0U) {
         sendACK();
       } else {
@@ -676,7 +720,7 @@ void CSerialPort::process()
       break;
 
     case MMDVM_FM_PARAMS2:
-            err = setFMParams2(m_buffer + 3U, m_len - 3U);
+      err = setFMParams2(buffer, length);
       if (err == 0U) {
         sendACK();
       } else {
@@ -686,7 +730,7 @@ void CSerialPort::process()
       break;
 
     case MMDVM_FM_PARAMS3:
-            err = setFMParams3(m_buffer + 3U, m_len - 3U);
+      err = setFMParams3(buffer, length);
       if (err == 0U) {
         sendACK();
       } else {
@@ -697,17 +741,17 @@ void CSerialPort::process()
 
     case MMDVM_CAL_DATA:
       if (m_modemState == STATE_DSTARCAL)
-              err = calDStarTX.write(m_buffer + 3U, m_len - 3U);
+        err = calDStarTX.write(buffer, length);
       if (m_modemState == STATE_DMRCAL || m_modemState == STATE_LFCAL || m_modemState == STATE_DMRCAL1K || m_modemState == STATE_DMRDMO1K)
-              err = calDMR.write(m_buffer + 3U, m_len - 3U);
+        err = calDMR.write(buffer, length);
       if (m_modemState == STATE_FMCAL10K || m_modemState == STATE_FMCAL12K || m_modemState == STATE_FMCAL15K || m_modemState == STATE_FMCAL20K || m_modemState == STATE_FMCAL25K || m_modemState == STATE_FMCAL30K)
-              err = calFM.write(m_buffer + 3U, m_len - 3U);
+        err = calFM.write(buffer, length);
       if (m_modemState == STATE_P25CAL1K)
-              err = calP25.write(m_buffer + 3U, m_len - 3U);
+        err = calP25.write(buffer, length);
       if (m_modemState == STATE_NXDNCAL1K)
-              err = calNXDN.write(m_buffer + 3U, m_len - 3U);
+        err = calNXDN.write(buffer, length);
       if (m_modemState == STATE_POCSAGCAL)
-              err = calPOCSAG.write(m_buffer + 3U, m_len - 3U);
+        err = calPOCSAG.write(buffer, length);
       if (err == 0U) {
         sendACK();
       } else {
@@ -719,7 +763,7 @@ void CSerialPort::process()
     case MMDVM_SEND_CWID:
       err = 5U;
       if (m_modemState == STATE_IDLE)
-              err = cwIdTX.write(m_buffer + 3U, m_len - 3U);
+        err = cwIdTX.write(buffer, length);
       if (err != 0U) {
         DEBUG2("Invalid CW Id data", err);
         sendNAK(err);
@@ -729,7 +773,7 @@ void CSerialPort::process()
     case MMDVM_DSTAR_HEADER:
       if (m_dstarEnable) {
         if (m_modemState == STATE_IDLE || m_modemState == STATE_DSTAR)
-                err = dstarTX.writeHeader(m_buffer + 3U, m_len - 3U);
+          err = dstarTX.writeHeader(buffer, length);
       }
       if (err == 0U) {
         if (m_modemState == STATE_IDLE)
@@ -743,7 +787,7 @@ void CSerialPort::process()
     case MMDVM_DSTAR_DATA:
       if (m_dstarEnable) {
         if (m_modemState == STATE_IDLE || m_modemState == STATE_DSTAR)
-                err = dstarTX.writeData(m_buffer + 3U, m_len - 3U);
+          err = dstarTX.writeData(buffer, length);
       }
       if (err == 0U) {
         if (m_modemState == STATE_IDLE)
@@ -772,7 +816,7 @@ void CSerialPort::process()
       if (m_dmrEnable) {
         if (m_modemState == STATE_IDLE || m_modemState == STATE_DMR) {
           if (m_duplex)
-                  err = dmrTX.writeData1(m_buffer + 3U, m_len - 3U);
+            err = dmrTX.writeData1(buffer, length);
         }
       }
       if (err == 0U) {
@@ -788,9 +832,9 @@ void CSerialPort::process()
       if (m_dmrEnable) {
         if (m_modemState == STATE_IDLE || m_modemState == STATE_DMR) {
           if (m_duplex)
-                  err = dmrTX.writeData2(m_buffer + 3U, m_len - 3U);
+            err = dmrTX.writeData2(buffer, length);
           else
-                  err = dmrDMOTX.writeData(m_buffer + 3U, m_len - 3U);
+            err = dmrDMOTX.writeData(buffer, length);
         }
       }
       if (err == 0U) {
@@ -825,7 +869,7 @@ void CSerialPort::process()
 
     case MMDVM_DMR_SHORTLC:
       if (m_dmrEnable)
-              err = dmrTX.writeShortLC(m_buffer + 3U, m_len - 3U);
+        err = dmrTX.writeShortLC(buffer, length);
       if (err != 0U) {
         DEBUG2("Received invalid DMR Short LC", err);
         sendNAK(err);
@@ -834,7 +878,7 @@ void CSerialPort::process()
 
     case MMDVM_DMR_ABORT:
       if (m_dmrEnable)
-              err = dmrTX.writeAbort(m_buffer + 3U, m_len - 3U);
+        err = dmrTX.writeAbort(buffer, length);
       if (err != 0U) {
         DEBUG2("Received invalid DMR Abort", err);
         sendNAK(err);
@@ -844,7 +888,7 @@ void CSerialPort::process()
     case MMDVM_YSF_DATA:
       if (m_ysfEnable) {
         if (m_modemState == STATE_IDLE || m_modemState == STATE_YSF)
-                err = ysfTX.writeData(m_buffer + 3U, m_len - 3U);
+          err = ysfTX.writeData(buffer, length);
       }
       if (err == 0U) {
         if (m_modemState == STATE_IDLE)
@@ -858,7 +902,7 @@ void CSerialPort::process()
     case MMDVM_P25_HDR:
       if (m_p25Enable) {
         if (m_modemState == STATE_IDLE || m_modemState == STATE_P25)
-                err = p25TX.writeData(m_buffer + 3U, m_len - 3U);
+          err = p25TX.writeData(buffer, length);
       }
       if (err == 0U) {
         if (m_modemState == STATE_IDLE)
@@ -872,7 +916,7 @@ void CSerialPort::process()
     case MMDVM_P25_LDU:
       if (m_p25Enable) {
         if (m_modemState == STATE_IDLE || m_modemState == STATE_P25)
-                err = p25TX.writeData(m_buffer + 3U, m_len - 3U);
+          err = p25TX.writeData(buffer, length);
       }
       if (err == 0U) {
         if (m_modemState == STATE_IDLE)
@@ -886,7 +930,7 @@ void CSerialPort::process()
     case MMDVM_NXDN_DATA:
       if (m_nxdnEnable) {
         if (m_modemState == STATE_IDLE || m_modemState == STATE_NXDN)
-                err = nxdnTX.writeData(m_buffer + 3U, m_len - 3U);
+          err = nxdnTX.writeData(buffer, length);
       }
       if (err == 0U) {
         if (m_modemState == STATE_IDLE)
@@ -897,24 +941,10 @@ void CSerialPort::process()
       }
       break;
 
-          case MMDVM_M17_DATA:
-            if (m_m17Enable) {
-              if (m_modemState == STATE_IDLE || m_modemState == STATE_M17)
-                err = m17TX.writeData(m_buffer + 3U, m_len - 3U);
-            }
-            if (err == 0U) {
-              if (m_modemState == STATE_IDLE)
-                setMode(STATE_M17);
-            } else {
-              DEBUG2("Received invalid M17 data", err);
-              sendNAK(err);
-            }
-            break;
-
     case MMDVM_POCSAG_DATA:
       if (m_pocsagEnable) {
         if (m_modemState == STATE_IDLE || m_modemState == STATE_POCSAG)
-                err = pocsagTX.writeData(m_buffer + 3U, m_len - 3U);
+          err = pocsagTX.writeData(buffer, length);
       }
       if (err == 0U) {
         if (m_modemState == STATE_IDLE)
@@ -925,6 +955,17 @@ void CSerialPort::process()
       }
       break;
 
+    case MMDVM_AX25_DATA:
+      if (m_ax25Enable) {
+        if (m_modemState == STATE_IDLE || m_modemState == STATE_FM)
+          err = ax25TX.writeData(buffer, length);
+      }
+      if (err != 0U) {
+        DEBUG2("Received invalid AX.25 data", err);
+        sendNAK(err);
+      }
+      break;
+
     case MMDVM_TRANSPARENT:
     case MMDVM_QSO_INFO:
       // Do nothing on the MMDVM.
@@ -946,33 +987,6 @@ void CSerialPort::process()
 
   m_ptr = 0U;
   m_len = 0U;
-      }
-    }
-  }
-
-  if (io.getWatchdog() >= 48000U) {
-    m_ptr = 0U;
-    m_len = 0U;
-  }
-
-#if defined(SERIAL_REPEATER)
-  // Write any outgoing serial data
-  uint16_t space = m_repeat.getData();
-  if (space > 0U) {
-    int avail = availableForWriteInt(3U);
-    if (avail < space)
-      space = avail;
-
-    for (uint16_t i = 0U; i < space; i++) {
-      uint8_t c = m_repeat.get();
-      writeInt(3U, &c, 1U);
-    }
-  }
-
-  // Read any incoming serial data
-  while (availableInt(3U))
-    readInt(3U);
-#endif
 }
 
 void CSerialPort::writeDStarHeader(const uint8_t* header, uint8_t length)
@@ -1237,44 +1251,36 @@ void CSerialPort::writeNXDNLost()
   writeInt(1U, reply, 3);
 }
 
-void CSerialPort::writeM17Data(const uint8_t* data, uint8_t length)
+void CSerialPort::writeAX25Data(const uint8_t* data, uint16_t length)
 {
-  if (m_modemState != STATE_M17 && m_modemState != STATE_IDLE)
+  if (m_modemState != STATE_FM && m_modemState != STATE_IDLE)
     return;
 
-  if (!m_m17Enable)
+  if (!m_ax25Enable)
     return;
 
-  uint8_t reply[130U];
+  uint8_t reply[512U];
 
   reply[0U] = MMDVM_FRAME_START;
+
+  if (length > 252U) {
     reply[1U] = 0U;
-  reply[2U] = MMDVM_M17_DATA;
+    reply[2U] = (length + 4U) - 255U;
+    reply[3U] = MMDVM_AX25_DATA;
 
-  uint8_t count = 3U;
+    for (uint8_t i = 0U; i < length; i++)
-  for (uint8_t i = 0U; i < length; i++, count++)
+      reply[i + 4U] = data[i];
-    reply[count] = data[i];
 
-  reply[1U] = count;
+    writeInt(1U, reply, length + 4U);
+  } else {
+    reply[1U] = length + 3U;
+    reply[2U] = MMDVM_AX25_DATA;
 
-  writeInt(1U, reply, count);
+    for (uint8_t i = 0U; i < length; i++)
-}
+      reply[i + 3U] = data[i];
 
-void CSerialPort::writeM17Lost()
+    writeInt(1U, reply, length + 3U);
-{
+  }
-  if (m_modemState != STATE_M17 && m_modemState != STATE_IDLE)
-    return;
-
-  if (!m_m17Enable)
-    return;
-
-  uint8_t reply[3U];
-
-  reply[0U] = MMDVM_FRAME_START;
-  reply[1U] = 3U;
-  reply[2U] = MMDVM_M17_LOST;
-
-  writeInt(1U, reply, 3);
 }
 
 void CSerialPort::writeCalData(const uint8_t* data, uint8_t length)

SerialPort.h

@@ -50,8 +50,7 @@ public:
   void writeNXDNData(const uint8_t* data, uint8_t length);
   void writeNXDNLost();
 
-  void writeM17Data(const uint8_t* data, uint8_t length);
+  void writeAX25Data(const uint8_t* data, uint16_t length);
-  void writeM17Lost();
 
   void writeCalData(const uint8_t* data, uint8_t length);
   void writeRSSIData(const uint8_t* data, uint8_t length);
@@ -63,9 +62,9 @@ public:
   void writeDebug(const char* text, int16_t n1, int16_t n2, int16_t n3, int16_t n4);
 
 private:
-  uint8_t   m_buffer[256U];
+  uint8_t   m_buffer[512U];
-  uint8_t   m_ptr;
+  uint16_t  m_ptr;
-  uint8_t   m_len;
+  uint16_t  m_len;
   bool      m_debug;
   CSerialRB m_repeat;
 
@@ -73,12 +72,13 @@ private:
   void    sendNAK(uint8_t err);
   void    getStatus();
   void    getVersion();
-  uint8_t setConfig(const uint8_t* data, uint8_t length);
+  uint8_t setConfig(const uint8_t* data, uint16_t length);
-  uint8_t setMode(const uint8_t* data, uint8_t length);
+  uint8_t setMode(const uint8_t* data, uint16_t length);
   void    setMode(MMDVM_STATE modemState);
-  uint8_t setFMParams1(const uint8_t* data, uint8_t length);
+  uint8_t setFMParams1(const uint8_t* data, uint16_t length);
-  uint8_t setFMParams2(const uint8_t* data, uint8_t length);
+  uint8_t setFMParams2(const uint8_t* data, uint16_t length);
-  uint8_t setFMParams3(const uint8_t* data, uint8_t length);
+  uint8_t setFMParams3(const uint8_t* data, uint16_t length);
+  void    processMessage(const uint8_t* data, uint16_t length);
 
   // Hardware versions
   void    beginInt(uint8_t n, int speed);

Utils.cpp

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

Utils.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -32,8 +32,6 @@
 
 uint8_t countBits8(uint8_t bits);
 
-uint8_t countBits16(uint16_t bits);
-
 uint8_t countBits32(uint32_t bits);
 
 uint8_t countBits64(uint64_t bits);

YSFTX.cpp

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2009-2018 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2009-2018,2020 by Jonathan Naylor G4KLX
  *   Copyright (C) 2017 by Andy Uribe CA6JAU
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -116,7 +116,7 @@ void CYSFTX::process()
   }
 }
 
-uint8_t CYSFTX::writeData(const uint8_t* data, uint8_t length)
+uint8_t CYSFTX::writeData(const uint8_t* data, uint16_t length)
 {
   if (length != (YSF_FRAME_LENGTH_BYTES + 1U))
     return 4U;

YSFTX.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2020 by Jonathan Naylor G4KLX
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -27,7 +27,7 @@ class CYSFTX {
 public:
   CYSFTX();
 
-  uint8_t writeData(const uint8_t* data, uint8_t length);
+  uint8_t writeData(const uint8_t* data, uint16_t length);
 
   void process();