Add the ST-Micro licences.

Add the LL library files and clean up some indentation.
Remove the submodules.
2026-10-15 16:24:11 +02:00 · 2023-10-29 20:32:18 +00:00 · 2023-10-28 20:30:36 +01:00 · 2023-10-28 16:32:48 +01:00 · 2023-10-27 16:23:49 +01:00 · 2023-10-10 20:06:50 +01:00
270 changed files with 159192 additions and 74467 deletions
@@ -1,3 +1,5 @@
-.pio
-.vscode
-
+*.o
+obj/
+bin/
+GitVersion.h
+build/
@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020,2023 by Jonathan Naylor G4KLX
 *   Copyright 2015-2019 Mobilinkd LLC <rob@mobilinkd.com>
 *
 *   This program is free software; you can redistribute it and/or modify
@@ -25,11 +25,12 @@
 #include "AX25Demodulator.h"
 #include "AX25Defines.h"

-const uint32_t SYMBOL_RATE = 1200U;
+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 = float32_t(SAMPLE_RATE / SYMBOL_RATE);
+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 = 48U;
@@ -84,7 +85,9 @@ m_hdlcOnes(0U),
 m_hdlcFlag(false),
 m_hdlcBuffer(0U),
 m_hdlcBits(0U),
-m_hdlcState(AX25_IDLE)
+m_hdlcState(AX25_IDLE),
+m_rssiAccum(0U),
+m_rssiCount(0U)
 {
  m_delayLine = new bool[DELAY_LEN];

@@ -100,7 +103,7 @@ m_hdlcState(AX25_IDLE)
    m_iirHistory[i] = 0.0F;
 }

-bool CAX25Demodulator::process(q15_t* samples, uint8_t length, CAX25Frame& frame)
+bool CAX25Demodulator::process(q15_t* samples, const uint16_t* rssi, uint8_t length, CAX25Frame& frame)
 {
  bool result = false;

@@ -118,6 +121,9 @@ bool CAX25Demodulator::process(q15_t* samples, uint8_t length, CAX25Frame& frame
  ::arm_fir_fast_q15(&m_lpfFilter, buffer, fc, RX_BLOCK_SIZE);

  for (uint8_t i = 0; i < length; i++) {
+    m_rssiAccum += rssi[i];
+    m_rssiCount++;
+
    bool bit = fc[i] >= 0;
    bool sample = PLL(bit);

@@ -265,6 +271,8 @@ bool CAX25Demodulator::HDLC(bool b)
        // Start of frame data.
        m_hdlcState = AX25_RECEIVE;
        m_frame.append(m_hdlcBuffer);
+        m_rssiAccum = 0U;
+        m_rssiCount = 0U;
        m_hdlcBits = 0U;
      }
      break;
@@ -314,5 +322,19 @@ float32_t CAX25Demodulator::iir(float32_t input)
  return result;
 }

+uint16_t CAX25Demodulator::getRSSI()
+{
+  if (m_rssiCount > 0U) {
+    uint16_t rssi = m_rssiAccum / m_rssiCount;
+
+    m_rssiAccum = 0U;
+    m_rssiCount = 0U;
+
+    return rssi;
+  }
+
+  return 0U;
+}
+
 #endif

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020,2023 by Jonathan Naylor G4KLX
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
@@ -36,12 +36,14 @@ class CAX25Demodulator {
 public:
  CAX25Demodulator(int8_t n);

-  bool process(q15_t* samples, uint8_t length, CAX25Frame& frame);
+  bool process(q15_t* samples, const uint16_t* rssi, uint8_t length, CAX25Frame& frame);

  void setTwist(int8_t n);

  bool isDCD();

+  uint16_t getRSSI();
+
 private:
  CAX25Frame           m_frame;
  CAX25Twist           m_twist;
@@ -63,6 +65,8 @@ private:
  uint16_t             m_hdlcBuffer;
  uint16_t             m_hdlcBits;
  AX25_STATE           m_hdlcState;
+  uint32_t             m_rssiAccum;
+  uint16_t             m_rssiCount;

  bool delay(bool b);
  bool NRZI(bool b);
@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020,2023 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
@@ -86,7 +86,7 @@ m_c(0xF6U)
  initRand();
 }

-void CAX25RX::samples(q15_t* samples, uint8_t length)
+void CAX25RX::samples(q15_t* samples, const uint16_t* rssi, uint8_t length)
 {
  q15_t output[RX_BLOCK_SIZE];
  ::arm_fir_fast_q15(&m_filter, samples, output, RX_BLOCK_SIZE);
@@ -95,32 +95,56 @@ void CAX25RX::samples(q15_t* samples, uint8_t length)

  CAX25Frame frame;

-  bool ret = m_demod1.process(output, length, frame);
+  bool ret = m_demod1.process(output, rssi, length, frame);
  if (ret) {
    if (frame.m_fcs != m_lastFCS || m_count > 2U) {
      m_lastFCS = frame.m_fcs;
      m_count   = 0U;
+#if defined(SEND_RSSI_DATA)
+      uint16_t rssi = m_demod1.getRSSI();
+      if (rssi > 0U)
+        serial.writeAX25DataEx(rssi, frame.m_data, frame.m_length - 2U);
+      else
+        serial.writeAX25Data(frame.m_data, frame.m_length - 2U);
+#else
      serial.writeAX25Data(frame.m_data, frame.m_length - 2U);
+#endif
    }
    DEBUG1("Decoder 1 reported");
  }

-  ret = m_demod2.process(output, length, frame);
+  ret = m_demod2.process(output, rssi, length, frame);
  if (ret) {
    if (frame.m_fcs != m_lastFCS || m_count > 2U) {
      m_lastFCS = frame.m_fcs;
      m_count   = 0U;
+#if defined(SEND_RSSI_DATA)
+      uint16_t rssi = m_demod2.getRSSI();
+      if (rssi > 0U)
+        serial.writeAX25DataEx(rssi, frame.m_data, frame.m_length - 2U);
+      else
+        serial.writeAX25Data(frame.m_data, frame.m_length - 2U);
+#else
      serial.writeAX25Data(frame.m_data, frame.m_length - 2U);
+#endif
    }
    DEBUG1("Decoder 2 reported");
  }

-  ret = m_demod3.process(output, length, frame);
+  ret = m_demod3.process(output, rssi, length, frame);
  if (ret) {
    if (frame.m_fcs != m_lastFCS || m_count > 2U) {
      m_lastFCS = frame.m_fcs;
      m_count   = 0U;
+#if defined(SEND_RSSI_DATA)
+      uint16_t rssi = m_demod3.getRSSI();
+      if (rssi > 0U)
+        serial.writeAX25DataEx(rssi, frame.m_data, frame.m_length - 2U);
+      else
+        serial.writeAX25Data(frame.m_data, frame.m_length - 2U);
+#else
      serial.writeAX25Data(frame.m_data, frame.m_length - 2U);
+#endif
    }
    DEBUG1("Decoder 3 reported");
  }
@@ -193,7 +217,7 @@ void CAX25RX::initRand() //Can also be used to seed the rng with more entropy du
 {
  m_a = (m_a ^ m_c ^ m_x);
  m_b = (m_b + m_a);
-  m_c = (m_c + ((m_b >> 1) ^ m_a));
+  m_c = (m_c + (m_b >> 1) ^ m_a);
 }

 uint8_t CAX25RX::rand()
@@ -202,7 +226,7 @@ uint8_t CAX25RX::rand()

  m_a = (m_a ^ m_c ^ m_x);         //note the mix of addition and XOR
  m_b = (m_b + m_a);               //And the use of very few instructions
-  m_c = (m_c + ((m_b >> 1) ^ m_a));  //the right shift is to ensure that high-order bits from b can affect  
+  m_c = (m_c + (m_b >> 1) ^ m_a);  //the right shift is to ensure that high-order bits from b can affect  

  return uint8_t(m_c);             //low order bits of other variables
 }
@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2020 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020,2023 by Jonathan Naylor G4KLX
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
@@ -29,7 +29,7 @@ class CAX25RX {
 public:
  CAX25RX();

-  void samples(q15_t* samples, uint8_t length);
+  void samples(q15_t* samples, const uint16_t* rssi, uint8_t length);

  void setParams(int8_t twist, uint8_t slotTime, uint8_t pPersist);

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018,2020,2024 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020,2023 by Jonathan Naylor G4KLX
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
@@ -20,7 +20,7 @@
 #define  CONFIG_H

 // Allow for the selection of which modes to compile into the firmware. This is particularly useful for processors
-// which have limited code space and processing power.
+// which have limited code space and processing power like the STM32F103, which is found on older/cheaper boards.

 // Enable D-Star support.
 #define MODE_DSTAR
@@ -50,40 +50,53 @@
 // Enable AX.25 support, this is only enabled if FM is also enabled.
 #define MODE_AX25

+// Allow for the use of high quality external clock oscillators
+// The number is the frequency of the oscillator in Hertz.
+//
+// The frequency of the TCXO must be an integer multiple of 48000.
+// Frequencies such as 12.0 Mhz (48000 * 250) and 14.4 Mhz (48000 * 300) are suitable.
+// Frequencies such as 10.0 Mhz (48000 * 208.333) or 20 Mhz (48000 * 416.666) are not suitable.
+//
+// For 12 MHz
+#define EXTERNAL_OSC 12000000
+// For 12.288 MHz
+// #define EXTERNAL_OSC 12288000
+// For 14.4 MHz
+// #define EXTERNAL_OSC 14400000
+// For 19.2 MHz
+// #define EXTERNAL_OSC 19200000
+
 // Select a baud rate for host communication. The faster speeds are needed for external FM to work.
-// #define SERIAL_SPEED 115200 // Suitable for most older boards. External FM will NOT work with this!
-// #define SERIAL_SPEED 230400 // Only works on newer boards like fast M4, M7. External FM might work with this
-#define SERIAL_SPEED 460800	// Only works on newer boards like fast M4, M7. External FM will work with this
+// #define SERIAL_SPEED 115200 // Suitable for most older boards (Arduino Due, STM32F1_POG, etc). External FM will NOT work with this!
+// #define SERIAL_SPEED 230400 // Only works on newer boards like fast M4, M7, Teensy 3.x. External FM might work with this
+#define SERIAL_SPEED 460800	// Only works on newer boards like fast M4, M7, Teensy 3.x. External FM should work with this
 //#define SERIAL_SPEED 500000  // Used with newer boards and Armbian on AllWinner SOCs (H2, H3) that do not support 460800

 // Use pins to output the current mode via LEDs
 #define MODE_LEDS

+// For ST Nucleo-64 STM32F446RE board
+// #define STM32F4_NUCLEO_MORPHO_HEADER
+// #define STM32F4_NUCLEO_ARDUINO_HEADER
+
+// Use separate mode pins to switch external channel/filters/bandwidth for example
+// #define MODE_PINS
+
+// For the VK6MST Pi3 Shield communicating over i2c. i2c address & speed defined in i2cTeensy.cpp
+// #define VK6MST_TEENSY_PI3_SHIELD_I2C
+
 // Pass RSSI information to the host
 #define SEND_RSSI_DATA

 // Use the modem as a serial repeater for Nextion displays
 #define SERIAL_REPEATER

-// Set the baud rate of the modem serial repeater for Nextion displays
-#define SERIAL_REPEATER_BAUD_RATE 9600
-
 // Use the modem as an I2C repeater for OLED displays
 // #define I2C_REPEATER

 // To reduce CPU load, you can remove the DC blocker by commenting out the next line
 #define USE_DCBLOCKER

-// Choose the type of modem board in use, only one.
-// The KI6ZUM v0.9 Pi hat, STM32F446 CPU
-#define ZUM_V09_PI
-// The KI6ZUM v1.0 Pi hat, STM32F722 CPU
-// #define ZUM_V10_PI
-// The Repeater Builder V3 board, STM32F446 CPU
-// #define RB_V3_PI
-// The Repeater Builder V5 board, STM32F722 CPU
-// #define RB_V5_PI
-
 // Constant Service LED once repeater is running 
 // Do not use if employing an external hardware watchdog 
 // #define CONSTANT_SRV_LED
@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2020,2021 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020,2021,2023 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
@@ -28,6 +28,19 @@ const uint16_t FM_SERIAL_BLOCK_SIZE = 80U;//this is the number of sample pairs t
                                          //three times this value shall never exceed 252
 const uint16_t FM_SERIAL_BLOCK_SIZE_BYTES = FM_SERIAL_BLOCK_SIZE * 3U;

+const uint8_t FS_LISTENING         = 0U;
+const uint8_t FS_KERCHUNK_RF       = 1U;
+const uint8_t FS_RELAYING_RF       = 2U;
+const uint8_t FS_RELAYING_WAIT_RF  = 3U;
+const uint8_t FS_TIMEOUT_RF        = 4U;
+const uint8_t FS_TIMEOUT_WAIT_RF   = 5U;
+const uint8_t FS_KERCHUNK_EXT      = 6U;
+const uint8_t FS_RELAYING_EXT      = 7U;
+const uint8_t FS_RELAYING_WAIT_EXT = 8U;
+const uint8_t FS_TIMEOUT_EXT       = 9U;
+const uint8_t FS_TIMEOUT_WAIT_EXT  = 10U;
+const uint8_t FS_HANG              = 11U;
+

 CFM::CFM() :
 m_callsign(),
@@ -48,7 +61,6 @@ m_kerchunkTimer(),
 m_ackMinTimer(),
 m_ackDelayTimer(),
 m_hangTimer(),
-m_statusTimer(),
 m_reverseTimer(),
 m_needReverse(false),
 m_filterStage1(  724,   1448,   724, 32768, -37895, 21352),//3rd order Cheby Filter 300 to 2700Hz, 0.2dB passband ripple, sampling rate 24kHz
@@ -68,23 +80,24 @@ m_inputRFRB(2401U),   // 100ms of audio + 1 sample
 m_outputRFRB(2400U),  // 100ms of audio
 m_inputExtRB(),
 m_rfSignal(false),
-m_extSignal(false)
+m_extSignal(false),
+m_rssiAccum(0U),
+m_rssiCount(0U)
 {
-  m_statusTimer.setTimeout(1U, 0U);
  m_reverseTimer.setTimeout(0U, 150U);

  insertDelay(100U);
 }

-void CFM::samples(bool cos, q15_t* samples, uint8_t length)
+void CFM::samples(bool cos, q15_t* samples, const uint16_t* rssi, uint8_t length)
 {
  if (m_linkMode)
    linkSamples(cos, samples, length);
  else
-    repeaterSamples(cos, samples, length);
+    repeaterSamples(cos, samples, rssi, length);
 }

-void CFM::repeaterSamples(bool cos, q15_t* samples, uint8_t length)
+void CFM::repeaterSamples(bool cos, q15_t* samples, const uint16_t* rssi, uint8_t length)
 {
  if (m_cosInvert)
    cos = !cos;
@@ -93,6 +106,11 @@ void CFM::repeaterSamples(bool cos, q15_t* samples, uint8_t length)

  uint8_t i = 0U;
  for (; i < length; i++) {
+    if (m_state == FS_RELAYING_RF) {
+      m_rssiAccum += rssi[i];
+      m_rssiCount++;
+    }
+
    // ARMv7-M has hardware integer division 
    q15_t currentRFSample = q15_t((q31_t(samples[i]) << 8) / m_rxLevel);

@@ -370,6 +388,7 @@ void CFM::process()
 void CFM::reset()
 {
  m_state = FS_LISTENING;
+  serial.writeFMStatus(m_state);

  m_callsignTimer.stop();
  m_timeoutTimer.stop();
@@ -377,7 +396,6 @@ void CFM::reset()
  m_ackMinTimer.stop();
  m_ackDelayTimer.stop();
  m_hangTimer.stop();
-  m_statusTimer.stop();
  m_reverseTimer.stop();

  m_ctcssRX.reset();
@@ -583,13 +601,7 @@ void CFM::clock(uint8_t length)
  m_ackMinTimer.clock(length);
  m_ackDelayTimer.clock(length);
  m_hangTimer.clock(length);
-  m_statusTimer.clock(length);
  m_reverseTimer.clock(length);
-
-  if (m_statusTimer.isRunning() && m_statusTimer.hasExpired()) {
-    serial.writeFMStatus(m_state);
-    m_statusTimer.start();
-  }
 }

 void CFM::listeningStateDuplex(bool validRFSignal, bool validExtSignal)
@@ -598,12 +610,19 @@ void CFM::listeningStateDuplex(bool validRFSignal, bool validExtSignal)
    if (m_kerchunkTimer.getTimeout() > 0U) {
      DEBUG1("State to KERCHUNK_RF");
      m_state = FS_KERCHUNK_RF;
+      serial.writeFMStatus(m_state);
+
      m_kerchunkTimer.start();
      if (m_callsignAtStart && !m_callsignAtLatch)
        sendCallsign();
    } else {
      DEBUG1("State to RELAYING_RF");
      m_state = FS_RELAYING_RF;
+      serial.writeFMStatus(m_state);
+
+      m_rssiAccum = 0U;
+      m_rssiCount = 0U;
+
      if (m_callsignAtStart)
        sendCallsign();
    }
@@ -618,20 +637,21 @@ void CFM::listeningStateDuplex(bool validRFSignal, bool validExtSignal)

      io.setDecode(true);
      io.setADCDetection(true);
-
-      m_statusTimer.start();
-      serial.writeFMStatus(m_state);
    }
  } else if (validExtSignal) {
    if (m_kerchunkTimer.getTimeout() > 0U) {
      DEBUG1("State to KERCHUNK_EXT");
      m_state = FS_KERCHUNK_EXT;
+      serial.writeFMStatus(m_state);
+
      m_kerchunkTimer.start();
      if (m_callsignAtStart && !m_callsignAtLatch)
        sendCallsign();
    } else {
      DEBUG1("State to RELAYING_EXT");
      m_state = FS_RELAYING_EXT;
+      serial.writeFMStatus(m_state);
+
      if (m_callsignAtStart)
        sendCallsign();
    }
@@ -643,9 +663,6 @@ void CFM::listeningStateDuplex(bool validRFSignal, bool validExtSignal)

      m_callsignTimer.start();
      m_reverseTimer.stop();
-
-      m_statusTimer.start();
-      serial.writeFMStatus(m_state);
    }
  }
 }
@@ -655,26 +672,22 @@ void CFM::listeningStateSimplex(bool validRFSignal, bool validExtSignal)
  if (validRFSignal) {
    DEBUG1("State to RELAYING_RF");
    m_state = FS_RELAYING_RF;
+    serial.writeFMStatus(m_state);

    io.setDecode(true);
    io.setADCDetection(true);

    m_timeoutTimer.start();
    m_reverseTimer.stop();
-
-    m_statusTimer.start();
-    serial.writeFMStatus(m_state);
  } else if (validExtSignal) {
    DEBUG1("State to RELAYING_EXT");
    m_state = FS_RELAYING_EXT;
+    serial.writeFMStatus(m_state);

    insertSilence(50U);

    m_timeoutTimer.start();
    m_reverseTimer.stop();
-
-    m_statusTimer.start();
-    serial.writeFMStatus(m_state);
  }
 }

@@ -684,6 +697,11 @@ void CFM::kerchunkRFStateDuplex(bool validSignal)
    if (m_kerchunkTimer.hasExpired()) {
      DEBUG1("State to RELAYING_RF");
      m_state = FS_RELAYING_RF;
+      serial.writeFMStatus(m_state);
+
+      m_rssiAccum = 0U;
+      m_rssiCount = 0U;
+
      m_kerchunkTimer.stop();
      if (m_callsignAtStart && m_callsignAtLatch) {
        sendCallsign();
@@ -696,11 +714,12 @@ void CFM::kerchunkRFStateDuplex(bool validSignal)

    DEBUG1("State to LISTENING");
    m_state = FS_LISTENING;
+    serial.writeFMStatus(m_state);
+
    m_kerchunkTimer.stop();
    m_timeoutTimer.stop();
    m_ackMinTimer.stop();
    m_callsignTimer.stop();
-    m_statusTimer.stop();
    m_needReverse = true;
    if (m_extEnabled)
      serial.writeFMEOT();
@@ -710,9 +729,21 @@ void CFM::kerchunkRFStateDuplex(bool validSignal)
 void CFM::relayingRFStateDuplex(bool validSignal)
 {
  if (validSignal) {
+#if defined(SEND_RSSI_DATA)
+    if (m_rssiCount >= 24000U) {
+      uint16_t rssi = m_rssiAccum / m_rssiCount;
+      serial.writeFMRSSI(rssi);
+
+      m_rssiAccum = 0U;
+      m_rssiCount = 0U;
+    }
+#endif
+
    if (m_timeoutTimer.isRunning() && m_timeoutTimer.hasExpired()) {
      DEBUG1("State to TIMEOUT_RF");
      m_state = FS_TIMEOUT_RF;
+      serial.writeFMStatus(m_state);
+
      m_ackMinTimer.stop();
      m_timeoutTimer.stop();
      m_timeoutTone.start();
@@ -726,6 +757,8 @@ void CFM::relayingRFStateDuplex(bool validSignal)

    DEBUG1("State to RELAYING_WAIT_RF");
    m_state = FS_RELAYING_WAIT_RF;
+    serial.writeFMStatus(m_state);
+
    m_ackDelayTimer.start();

    if (m_extEnabled)
@@ -744,6 +777,7 @@ void CFM::relayingRFStateSimplex(bool validSignal)
    if (m_timeoutTimer.isRunning() && m_timeoutTimer.hasExpired()) {
      DEBUG1("State to TIMEOUT_RF");
      m_state = FS_TIMEOUT_RF;
+      serial.writeFMStatus(m_state);

      m_timeoutTimer.stop();

@@ -756,6 +790,8 @@ void CFM::relayingRFStateSimplex(bool validSignal)

    DEBUG1("State to RELAYING_WAIT_RF");
    m_state = FS_RELAYING_WAIT_RF;
+    serial.writeFMStatus(m_state);
+
    m_ackDelayTimer.start();

    if (m_extEnabled)
@@ -771,11 +807,17 @@ void CFM::relayingRFWaitStateDuplex(bool validSignal)

    DEBUG1("State to RELAYING_RF");
    m_state = FS_RELAYING_RF;
+    serial.writeFMStatus(m_state);
+
+    m_rssiAccum = 0U;
+    m_rssiCount = 0U;
+
    m_ackDelayTimer.stop();
  } else {
    if (m_ackDelayTimer.isRunning() && m_ackDelayTimer.hasExpired()) {
      DEBUG1("State to HANG");
      m_state = FS_HANG;
+      serial.writeFMStatus(m_state);

      if (m_ackMinTimer.isRunning()) {
        if (m_ackMinTimer.hasExpired()) {
@@ -809,11 +851,15 @@ void CFM::relayingRFWaitStateSimplex(bool validSignal)

    DEBUG1("State to RELAYING_RF");
    m_state = FS_RELAYING_RF;
+    serial.writeFMStatus(m_state);
+
    m_ackDelayTimer.stop();
  } else {
    if (m_ackDelayTimer.isRunning() && m_ackDelayTimer.hasExpired()) {
      DEBUG1("State to LISTENING");
      m_state = FS_LISTENING;
+      serial.writeFMStatus(m_state);
+
      m_ackDelayTimer.stop();
      m_timeoutTimer.stop();
    }
@@ -826,6 +872,8 @@ void CFM::kerchunkExtStateDuplex(bool validSignal)
    if (m_kerchunkTimer.hasExpired()) {
      DEBUG1("State to RELAYING_EXT");
      m_state = FS_RELAYING_EXT;
+      serial.writeFMStatus(m_state);
+
      m_kerchunkTimer.stop();
      if (m_callsignAtStart && m_callsignAtLatch) {
        sendCallsign();
@@ -835,11 +883,12 @@ void CFM::kerchunkExtStateDuplex(bool validSignal)
  } else {
    DEBUG1("State to LISTENING");
    m_state = FS_LISTENING;
+    serial.writeFMStatus(m_state);
+
    m_kerchunkTimer.stop();
    m_timeoutTimer.stop();
    m_ackMinTimer.stop();
    m_callsignTimer.stop();
-    m_statusTimer.stop();
    m_needReverse = true;
  }
 }
@@ -850,6 +899,8 @@ void CFM::relayingExtStateDuplex(bool validSignal)
    if (m_timeoutTimer.isRunning() && m_timeoutTimer.hasExpired()) {
      DEBUG1("State to TIMEOUT_EXT");
      m_state = FS_TIMEOUT_EXT;
+      serial.writeFMStatus(m_state);
+
      m_ackMinTimer.stop();
      m_timeoutTimer.stop();
      m_timeoutTone.start();
@@ -857,6 +908,7 @@ void CFM::relayingExtStateDuplex(bool validSignal)
  } else {
    DEBUG1("State to RELAYING_WAIT_EXT");
    m_state = FS_RELAYING_WAIT_EXT;
+    serial.writeFMStatus(m_state);
    m_ackDelayTimer.start();
  }

@@ -872,12 +924,14 @@ void CFM::relayingExtStateSimplex(bool validSignal)
    if (m_timeoutTimer.isRunning() && m_timeoutTimer.hasExpired()) {
      DEBUG1("State to TIMEOUT_EXT");
      m_state = FS_TIMEOUT_EXT;
+      serial.writeFMStatus(m_state);

      m_timeoutTimer.stop();
    }
  } else {
    DEBUG1("State to RELAYING_WAIT_EXT");
    m_state = FS_RELAYING_WAIT_EXT;
+    serial.writeFMStatus(m_state);
    m_ackDelayTimer.start();
  }
 }
@@ -887,11 +941,13 @@ void CFM::relayingExtWaitStateDuplex(bool validSignal)
  if (validSignal) {
    DEBUG1("State to RELAYING_EXT");
    m_state = FS_RELAYING_EXT;
+    serial.writeFMStatus(m_state);
    m_ackDelayTimer.stop();
  } else {
    if (m_ackDelayTimer.isRunning() && m_ackDelayTimer.hasExpired()) {
      DEBUG1("State to HANG");
      m_state = FS_HANG;
+      serial.writeFMStatus(m_state);

      if (m_ackMinTimer.isRunning()) {
        if (m_ackMinTimer.hasExpired()) {
@@ -922,11 +978,14 @@ void CFM::relayingExtWaitStateSimplex(bool validSignal)
  if (validSignal) {
    DEBUG1("State to RELAYING_EXT");
    m_state = FS_RELAYING_EXT;
+    serial.writeFMStatus(m_state);
    m_ackDelayTimer.stop();
  } else {
    if (m_ackDelayTimer.isRunning() && m_ackDelayTimer.hasExpired()) {
      DEBUG1("State to LISTENING");
      m_state = FS_LISTENING;
+      serial.writeFMStatus(m_state);
+
      m_ackDelayTimer.stop();
      m_timeoutTimer.stop();
      m_needReverse = true;
@@ -942,6 +1001,11 @@ void CFM::hangStateDuplex(bool validRFSignal, bool validExtSignal)

    DEBUG1("State to RELAYING_RF");
    m_state = FS_RELAYING_RF;
+    serial.writeFMStatus(m_state);
+
+    m_rssiAccum = 0U;
+    m_rssiCount = 0U;
+
    DEBUG1("Stop ack");
    m_rfAck.stop();
    m_extAck.stop();
@@ -949,6 +1013,8 @@ void CFM::hangStateDuplex(bool validRFSignal, bool validExtSignal)
  } else if (validExtSignal) {
    DEBUG1("State to RELAYING_EXT");
    m_state = FS_RELAYING_EXT;
+    serial.writeFMStatus(m_state);
+
    DEBUG1("Stop ack");
    m_rfAck.stop();
    m_extAck.stop();
@@ -957,8 +1023,9 @@ void CFM::hangStateDuplex(bool validRFSignal, bool validExtSignal)
    if (m_hangTimer.isRunning() && m_hangTimer.hasExpired()) {
      DEBUG1("State to LISTENING");
      m_state = FS_LISTENING;
+      serial.writeFMStatus(m_state);
+
      m_hangTimer.stop();
-      m_statusTimer.stop();

      if (m_callsignAtEnd)
        sendCallsign();
@@ -982,6 +1049,7 @@ void CFM::timeoutRFStateDuplex(bool validSignal)

    DEBUG1("State to TIMEOUT_WAIT_RF");
    m_state = FS_TIMEOUT_WAIT_RF;
+    serial.writeFMStatus(m_state);

    if (m_callsignAtEnd)
        sendCallsign();
@@ -1003,6 +1071,7 @@ void CFM::timeoutRFStateSimplex(bool validSignal)

    DEBUG1("State to TIMEOUT_WAIT_RF");
    m_state = FS_TIMEOUT_WAIT_RF;
+    serial.writeFMStatus(m_state);

    m_ackDelayTimer.start();
  }
@@ -1016,11 +1085,14 @@ void CFM::timeoutRFWaitStateDuplex(bool validSignal)

    DEBUG1("State to TIMEOUT_RF");
    m_state = FS_TIMEOUT_RF;
+    serial.writeFMStatus(m_state);
    m_ackDelayTimer.stop();
  } else {
    if (m_ackDelayTimer.isRunning() && m_ackDelayTimer.hasExpired()) {
      DEBUG1("State to HANG");
      m_state = FS_HANG;
+      serial.writeFMStatus(m_state);
+
      m_timeoutTone.stop();
      DEBUG1("Send RF ack");
      m_rfAck.start();
@@ -1045,11 +1117,14 @@ void CFM::timeoutRFWaitStateSimplex(bool validSignal)

    DEBUG1("State to TIMEOUT_RF");
    m_state = FS_TIMEOUT_RF;
+    serial.writeFMStatus(m_state);
    m_ackDelayTimer.stop();
  } else {
    if (m_ackDelayTimer.isRunning() && m_ackDelayTimer.hasExpired()) {
      DEBUG1("State to LISTENING");
      m_state = FS_LISTENING;
+      serial.writeFMStatus(m_state);
+
      m_ackDelayTimer.stop();
      m_timeoutTimer.stop();
    }
@@ -1061,6 +1136,7 @@ void CFM::timeoutExtStateDuplex(bool validSignal)
  if (!validSignal) {
    DEBUG1("State to TIMEOUT_WAIT_EXT");
    m_state = FS_TIMEOUT_WAIT_EXT;
+    serial.writeFMStatus(m_state);
    m_ackDelayTimer.start();
  }

@@ -1075,6 +1151,7 @@ void CFM::timeoutExtStateSimplex(bool validSignal)
  if (!validSignal) {
    DEBUG1("State to TIMEOUT_WAIT_EXT");
    m_state = FS_TIMEOUT_WAIT_EXT;
+    serial.writeFMStatus(m_state);
    m_ackDelayTimer.start();
  }
 }
@@ -1084,11 +1161,14 @@ void CFM::timeoutExtWaitStateDuplex(bool validSignal)
  if (validSignal) {
    DEBUG1("State to TIMEOUT_EXT");
    m_state = FS_TIMEOUT_EXT;
+    serial.writeFMStatus(m_state);
    m_ackDelayTimer.stop();
  } else {
    if (m_ackDelayTimer.isRunning() && m_ackDelayTimer.hasExpired()) {
      DEBUG1("State to HANG");
      m_state = FS_HANG;
+      serial.writeFMStatus(m_state);
+
      m_timeoutTone.stop();
      DEBUG1("Send Ext ack");
      m_extAck.start();
@@ -1110,11 +1190,14 @@ void CFM::timeoutExtWaitStateSimplex(bool validSignal)
  if (validSignal) {
    DEBUG1("State to TIMEOUT_EXT");
    m_state = FS_TIMEOUT_EXT;
+    serial.writeFMStatus(m_state);
    m_ackDelayTimer.stop();
  } else {
    if (m_ackDelayTimer.isRunning() && m_ackDelayTimer.hasExpired()) {
      DEBUG1("State to LISTENING");
      m_state = FS_LISTENING;
+      serial.writeFMStatus(m_state);
+
      m_ackDelayTimer.stop();
      m_timeoutTimer.stop();
      m_needReverse = true;
@@ -1131,7 +1214,6 @@ void CFM::linkStateMachine(bool validRFSignal, bool validExtSignal)
    if (!m_extSignal) {
      DEBUG1("State to RELAYING_RF");
      m_state = FS_RELAYING_RF;
-      m_statusTimer.start();
      serial.writeFMStatus(m_state);
    }

@@ -1142,7 +1224,6 @@ void CFM::linkStateMachine(bool validRFSignal, bool validExtSignal)
    if (!m_rfSignal) {
      DEBUG1("State to RELAYING_EXT");
      m_state = FS_RELAYING_EXT;
-      m_statusTimer.start();
      serial.writeFMStatus(m_state);
    }

@@ -1158,7 +1239,7 @@ void CFM::linkStateMachine(bool validRFSignal, bool validExtSignal)
    if (!m_extSignal) {
      DEBUG1("State to LISTENING");
      m_state = FS_LISTENING;
-      m_statusTimer.stop();
+      serial.writeFMStatus(m_state);
    }

    m_rfSignal = false;
@@ -1171,7 +1252,7 @@ void CFM::linkStateMachine(bool validRFSignal, bool validExtSignal)
    if (!m_rfSignal) {
      DEBUG1("State to LISTENING");
      m_state = FS_LISTENING;
-      m_statusTimer.stop();
+      serial.writeFMStatus(m_state);
    }

    m_needReverse = true;
@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2020,2021 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2020,2021,2023 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
@@ -35,27 +35,12 @@
 #include "FMUpSampler.h"
 #include "FMNoiseSquelch.h"

-enum FM_STATE {
-  FS_LISTENING,
-  FS_KERCHUNK_RF,
-  FS_RELAYING_RF,
-  FS_RELAYING_WAIT_RF,
-  FS_TIMEOUT_RF,
-  FS_TIMEOUT_WAIT_RF,
-  FS_KERCHUNK_EXT,
-  FS_RELAYING_EXT,
-  FS_RELAYING_WAIT_EXT,
-  FS_TIMEOUT_EXT,
-  FS_TIMEOUT_WAIT_EXT,
-  FS_HANG
-};
-

 class CFM {
 public:
  CFM();

-  void samples(bool cos, q15_t* samples, uint8_t length);
+  void samples(bool cos, q15_t* samples, const uint16_t* rssi, uint8_t length);

  void process();

@@ -78,7 +63,7 @@ private:
  CFMCTCSSTX           m_ctcssTX;
  CFMNoiseSquelch      m_squelch;
  CFMTimeout           m_timeoutTone;
-  FM_STATE             m_state;
+  uint8_t              m_state;
  bool                 m_callsignAtStart;
  bool                 m_callsignAtEnd;
  bool                 m_callsignAtLatch;
@@ -89,7 +74,6 @@ private:
  CFMTimer             m_ackMinTimer;
  CFMTimer             m_ackDelayTimer;
  CFMTimer             m_hangTimer;
-  CFMTimer             m_statusTimer;
  CFMTimer             m_reverseTimer;
  bool                 m_needReverse;
  CFMDirectFormI       m_filterStage1;
@@ -110,10 +94,12 @@ private:
  CFMUpSampler         m_inputExtRB;
  bool                 m_rfSignal;
  bool                 m_extSignal;
+  uint32_t             m_rssiAccum;
+  uint16_t             m_rssiCount;

  void stateMachine(bool validRFSignal, bool validExtSignal);

-  void repeaterSamples(bool cos, q15_t* samples, uint8_t length);
+  void repeaterSamples(bool cos, q15_t* samples, const uint16_t* rssi, uint8_t length);
  void linkSamples(bool cos, q15_t* samples, uint8_t length);

  void duplexStateMachine(bool validRFSignal, bool validExtSignal);
@@ -42,7 +42,8 @@ class CFMDirectFormI
 public:

 	// convenience function which takes the a0 argument but ignores it!
-	CFMDirectFormI(const q31_t b0, const q31_t b1, const q31_t b2, const q31_t, const q31_t a1, const q31_t a2)
+	CFMDirectFormI(const q31_t b0, const q31_t b1, const q31_t b2,
+			const q31_t, const q31_t a1, const q31_t a2)
 	{
 		// FIR coefficients
 		c_b0 = b0;
@@ -56,21 +57,21 @@ public:

 	CFMDirectFormI(const CFMDirectFormI &my)
 	{
-		// delay line
+	// delay line
 		m_x2 = my.m_x2; // x[n-2]
 		m_y2 = my.m_y2; // y[n-2]
 		m_x1 = my.m_x1; // x[n-1]
 		m_y1 = my.m_y1; // y[n-1]

-		// coefficients
+	// coefficients
 		c_b0 = my.c_b0;
 		c_b1 = my.c_b1;
 		c_b2 = my.c_b2; // FIR
 		c_a1 = my.c_a1;
 		c_a2 = my.c_a2; // IIR
-	}
+    }

-	void reset()
+	void reset ()
 	{
 		m_x1 = 0;
 		m_x2 = 0;
@@ -82,7 +83,11 @@ public:
 	inline q15_t filter(const q15_t in)
 	{
 		// calculate the output
-		q31_t out_upscaled = c_b0 * in + c_b1 * m_x1 + c_b2 * m_x2 - c_a1 * m_y1 - c_a2 * m_y2;
+		register q31_t out_upscaled = c_b0 * in
+									+ c_b1 * m_x1
+									+ c_b2 * m_x2
+									- c_a1 * m_y1
+									- c_a2 * m_y2;

 		q15_t out = __SSAT(out_upscaled >> 15, 15);

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018,2020,2021,2024 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020,2021,2023 by Jonathan Naylor G4KLX
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
@@ -19,8 +19,22 @@
 #if !defined(GLOBALS_H)
 #define  GLOBALS_H

+#if defined(STM32F4XX)
+#include "stm32f4xx.h"
+#elif defined(STM32F7XX)
+#include "stm32f7xx.h"
+#else
 #include <Arduino.h>
 #undef PI //Undefine PI to get rid of annoying warning as it is also defined in arm_math.h.
+#endif
+
+#if defined(STM32F7XX)
+#define  ARM_MATH_CM7
+#elif defined(STM32F4XX) || defined(__MK20DX256__) || defined(__MK64FX512__) || defined(__MK66FX1M0__)
+#define  ARM_MATH_CM4
+#else
+#error "Unknown processor type"
+#endif

 #include <arm_math.h>

@@ -58,38 +72,37 @@ enum MMDVM_STATE {
 };

 #include "SerialPort.h"
-
-#include "POCSAG/CalPOCSAG.h"
-#include "DStar/CalDStarRX.h"
-#include "DStar/CalDStarTX.h"
-#include "POCSAG/POCSAGTX.h"
-#include "DStar/DStarRX.h"
-#include "DStar/DStarTX.h"
-#include "DMR/DMRIdleRX.h"
-#include "DMR/DMRDMORX.h"
-#include "DMR/DMRDMOTX.h"
-#include "NXDN/CalNXDN.h"
-#include "NXDN/NXDNRX.h"
-#include "NXDN/NXDNTX.h"
-#include "AX25/AX25RX.h"
-#include "AX25/AX25TX.h"
-#include "DMR/CalDMR.h"
-#include "P25/CalP25.h"
-#include "M17/CalM17.h"
-#include "DMR/DMRRX.h"
-#include "DMR/DMRTX.h"
-#include "YSF/YSFRX.h"
-#include "YSF/YSFTX.h"
-#include "P25/P25RX.h"
-#include "P25/P25TX.h"
-#include "M17/M17RX.h"
-#include "M17/M17TX.h"
-#include "FM/CalFM.h"
+#include "DMRIdleRX.h"
+#include "DMRDMORX.h"
+#include "DMRDMOTX.h"
+#include "DStarRX.h"
+#include "DStarTX.h"
+#include "DMRRX.h"
+#include "DMRTX.h"
+#include "YSFRX.h"
+#include "YSFTX.h"
+#include "P25RX.h"
+#include "P25TX.h"
+#include "M17RX.h"
+#include "M17TX.h"
+#include "NXDNRX.h"
+#include "NXDNTX.h"
+#include "POCSAGTX.h"
+#include "CalDStarRX.h"
+#include "CalDStarTX.h"
+#include "CalFM.h"
+#include "CalDMR.h"
+#include "CalP25.h"
+#include "CalNXDN.h"
+#include "CalPOCSAG.h"
 #include "CalRSSI.h"
 #include "CWIdTX.h"
-#include "FM/FM.h"
+#include "AX25RX.h"
+#include "AX25TX.h"
+#include "CalM17.h"
 #include "Debug.h"
 #include "IO.h"
+#include "FM.h"

 const uint8_t  MARK_SLOT1 = 0x08U;
 const uint8_t  MARK_SLOT2 = 0x04U;
@@ -100,9 +113,7 @@ const uint16_t RX_BLOCK_SIZE = 2U;
 const uint16_t TX_RINGBUFFER_SIZE = 500U;
 const uint16_t RX_RINGBUFFER_SIZE = 600U;

-const uint32_t SAMPLE_RATE = 24000U;
-
-#if defined(__MK20DX256__)
+#if defined(STM32F105xC) || defined(__MK20DX256__)
 const uint16_t TX_BUFFER_LEN = 2000U;
 #else
 const uint16_t TX_BUFFER_LEN = 4000U;
@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018,2020,2021,2024 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020,2021,2023 by Jonathan Naylor G4KLX
 *   Copyright (C) 2015 by Jim Mclaughlin KI6ZUM
 *   Copyright (C) 2016 by Colin Durbridge G4EML
 *
@@ -20,7 +20,6 @@

 #include "Config.h"
 #include "Globals.h"
-#include "IOPins.h"
 #include "IO.h"

 #if defined(USE_DCBLOCKER)
@@ -80,7 +79,6 @@ const uint16_t BOXCAR5_FILTER_LEN = 6U;
 const uint16_t DC_OFFSET = 2048U;

 CIO::CIO() :
-m_timer(TIM2),
 m_started(false),
 m_rxBuffer(RX_RINGBUFFER_SIZE),
 m_txBuffer(TX_RINGBUFFER_SIZE),
@@ -206,7 +204,7 @@ m_lockout(false)
  m_rrc05Filter.pCoeffs = RRC_0_5_FILTER;
 #endif

-  initHardware();
+  initInt();
  
  selfTest();
 }
@@ -219,106 +217,106 @@ void CIO::selfTest()
    ledValue = !ledValue;

    // We exclude PTT to avoid trigger the transmitter
-    setLED(ledValue);
-    setCOS(ledValue);
+    setLEDInt(ledValue);
+    setCOSInt(ledValue);
 #if defined(MODE_LEDS)
-    setDStar(ledValue);
-    setDMR(ledValue);
-    setYSF(ledValue);
-    setP25(ledValue);
+    setDStarInt(ledValue);
+    setDMRInt(ledValue);
+    setYSFInt(ledValue);
+    setP25Int(ledValue);
 #if !defined(USE_ALTERNATE_NXDN_LEDS)
-    setNXDN(ledValue);
+    setNXDNInt(ledValue);
 #endif
 #if !defined(USE_ALTERNATE_M17_LEDS)
-    setM17(ledValue);
+    setM17Int(ledValue);
 #endif
 #if !defined(USE_ALTERNATE_POCSAG_LEDS)
-    setPOCSAG(ledValue);
+    setPOCSAGInt(ledValue);
 #endif
 #if !defined(USE_ALTERNATE_FM_LEDS)
-    setFM(ledValue);
+    setFMInt(ledValue);
 #endif
 #endif
-    ::delay(250);
+    delayInt(250);
  }

 #if defined(MODE_LEDS)
-  setDStar(false);
-  setDMR(false);
-  setYSF(false);
-  setP25(false);
+  setDStarInt(false);
+  setDMRInt(false);
+  setYSFInt(false);
+  setP25Int(false);
 #if !defined(USE_ALTERNATE_NXDN_LEDS)
-  setNXDN(false);
+  setNXDNInt(false);
 #endif
 #if !defined(USE_ALTERNATE_M17_LEDS)
-  setM17(false);
+  setM17Int(false);
 #endif
 #if !defined(USE_ALTERNATE_POCSAG_LEDS)
-  setPOCSAG(false);
+  setPOCSAGInt(false);
 #endif
 #if !defined(USE_ALTERNATE_FM_LEDS)
-  setFM(false);
+  setFMInt(false);
 #endif
-  setDStar(true);
+  setDStarInt(true);

-  ::delay(250);
-  setDMR(true);
+  delayInt(250);
+  setDMRInt(true);

-  ::delay(250);
-  setYSF(true);
+  delayInt(250);
+  setYSFInt(true);

-  ::delay(250);
-  setP25(true);
+  delayInt(250);
+  setP25Int(true);

 #if !defined(USE_ALTERNATE_NXDN_LEDS)
-  ::delay(250);
-  setNXDN(true);
+  delayInt(250);
+  setNXDNInt(true);
 #endif

 #if !defined(USE_ALTERNATE_M17_LEDS)
-  ::delay(250);
-  setM17(true);
+  delayInt(250);
+  setM17Int(true);
 #endif

 #if !defined(USE_ALTERNATE_POCSAG_LEDS)
-  ::delay(250);
-  setPOCSAG(true);
+  delayInt(250);
+  setPOCSAGInt(true);
 #endif

 #if !defined(USE_ALTERNATE_FM_LEDS)
-  ::delay(250);
-  setFM(true);
+  delayInt(250);
+  setFMInt(true);

-  ::delay(250);
-  setFM(false);
+  delayInt(250);
+  setFMInt(false);
 #endif

 #if !defined(USE_ALTERNATE_POCSAG_LEDS)
-  ::delay(250);
-  setPOCSAG(false);
+  delayInt(250);
+  setPOCSAGInt(false);
 #endif

 #if !defined(USE_ALTERNATE_M17_LEDS)
-  ::delay(250);
-  setM17(false);
+  delayInt(250);
+  setM17Int(false);
 #endif

 #if !defined(USE_ALTERNATE_NXDN_LEDS)
-  ::delay(250);
-  setNXDN(false);
+  delayInt(250);
+  setNXDNInt(false);
 #endif

-  ::delay(250);
-  setP25(false);
+  delayInt(250);
+  setP25Int(false);

-  ::delay(250);
-  setYSF(false);
+  delayInt(250);
+  setYSFInt(false);

-  ::delay(250);
-  setDMR(false);
+  delayInt(250);
+  setDMRInt(false);

-  ::delay(250);
-  setDStar(false);
+  delayInt(250);
+  setDStarInt(false);
 #endif
 }

@@ -327,7 +325,7 @@ void CIO::start()
  if (m_started)
    return;

-  startHardware();
+  startInt();

  m_started = true;

@@ -336,6 +334,7 @@ void CIO::start()

 void CIO::process()
 {
+  m_ledCount++;
  if (m_started) {
    // Two seconds timeout
    if (m_watchdog >= 48000U) {
@@ -351,31 +350,30 @@ void CIO::process()
    }

 #if defined(CONSTANT_SRV_LED)
-    setLED(true);
+    setLEDInt(true);
 #else
    if (m_ledCount >= 24000U) {
      m_ledCount = 0U;
      m_ledValue = !m_ledValue;
-      setLED(m_ledValue);
+      setLEDInt(m_ledValue);
    }
 #endif
  } else {
-    m_ledCount++;
    if (m_ledCount >= 240000U) {
      m_ledCount = 0U;
      m_ledValue = !m_ledValue;
-      setLED(m_ledValue);
+      setLEDInt(m_ledValue);
    }
    return;
  }

  if (m_useCOSAsLockout)
-    m_lockout = getCOS();
+    m_lockout = getCOSInt();

  // Switch off the transmitter if needed
  if (m_txBuffer.getData() == 0U && m_tx) {
    m_tx = false;
-    setPTT(m_pttInvert ? true : false);
+    setPTTInt(m_pttInvert ? true : false);
    DEBUG1("TX OFF");
  }

@@ -506,11 +504,11 @@ void CIO::process()

 #if defined(MODE_FM)
      if (m_fmEnable) {
-        bool cos = getCOS();
+        bool cos = getCOSInt();
 #if defined(USE_DCBLOCKER)
-        fm.samples(cos, dcSamples, RX_BLOCK_SIZE);
+        fm.samples(cos, dcSamples, rssi, RX_BLOCK_SIZE);
 #else
-        fm.samples(cos, samples, RX_BLOCK_SIZE);
+        fm.samples(cos, samples, rssi, RX_BLOCK_SIZE);
 #endif
      }
 #endif
@@ -518,9 +516,9 @@ void CIO::process()
 #if defined(MODE_FM) && defined(MODE_AX25)
      if (m_ax25Enable) {
 #if defined(USE_DCBLOCKER)
-        ax25RX.samples(dcSamples, RX_BLOCK_SIZE);
+        ax25RX.samples(dcSamples, rssi, RX_BLOCK_SIZE);
 #else
-        ax25RX.samples(samples, RX_BLOCK_SIZE);
+        ax25RX.samples(samples, rssi, RX_BLOCK_SIZE);
 #endif
      }
 #endif
@@ -627,20 +625,20 @@ void CIO::process()

 #if defined(MODE_FM)
    else if (m_modemState == STATE_FM) {
-      bool cos = getCOS();
+      bool cos = getCOSInt();
 #if defined(USE_DCBLOCKER)
-      fm.samples(cos, dcSamples, RX_BLOCK_SIZE);
+      fm.samples(cos, dcSamples, rssi, RX_BLOCK_SIZE);

 #if defined(MODE_AX25)
      if (m_ax25Enable)
-        ax25RX.samples(dcSamples, RX_BLOCK_SIZE);
+        ax25RX.samples(dcSamples, rssi, RX_BLOCK_SIZE);
 #endif
 #else
-      fm.samples(cos, samples, RX_BLOCK_SIZE);
+      fm.samples(cos, samples, rssi, RX_BLOCK_SIZE);

 #if defined(MODE_AX25)
      if (m_ax25Enable)
-        ax25RX.samples(samples, RX_BLOCK_SIZE);
+        ax25RX.samples(samples, rssi, RX_BLOCK_SIZE);
 #endif
 #endif
    }
@@ -672,7 +670,7 @@ void CIO::write(MMDVM_STATE mode, q15_t* samples, uint16_t length, const uint8_t
  // Switch the transmitter on if needed
  if (!m_tx) {
    m_tx = true;
-    setPTT(m_pttInvert ? false : true);
+    setPTTInt(m_pttInvert ? false : true);
    DEBUG1("TX ON");
  }

@@ -734,7 +732,7 @@ uint16_t CIO::getSpace() const
 void CIO::setDecode(bool dcd)
 {
  if (dcd != m_dcd)
-    setCOS(dcd ? true : false);
+    setCOSInt(dcd ? true : false);

  m_dcd = dcd;
 }
@@ -751,26 +749,26 @@ void CIO::setMode(MMDVM_STATE state)

 #if defined(MODE_LEDS)
  switch (m_modemState) {
-    case STATE_DSTAR:  setDStar(false);  break;
-    case STATE_DMR:    setDMR(false);    break;
-    case STATE_YSF:    setYSF(false);    break;
-    case STATE_P25:    setP25(false);    break;
-    case STATE_NXDN:   setNXDN(false);   break;
-    case STATE_M17:    setM17(false);    break;
-    case STATE_POCSAG: setPOCSAG(false); break;
-    case STATE_FM:     setFM(false);     break;
+    case STATE_DSTAR:  setDStarInt(false);  break;
+    case STATE_DMR:    setDMRInt(false);    break;
+    case STATE_YSF:    setYSFInt(false);    break;
+    case STATE_P25:    setP25Int(false);    break;
+    case STATE_NXDN:   setNXDNInt(false);   break;
+    case STATE_M17:    setM17Int(false);    break;
+    case STATE_POCSAG: setPOCSAGInt(false); break;
+    case STATE_FM:     setFMInt(false);     break;
    default: break;
  }

  switch (state) {
-    case STATE_DSTAR:  setDStar(true);  break;
-    case STATE_DMR:    setDMR(true);    break;
-    case STATE_YSF:    setYSF(true);    break;
-    case STATE_P25:    setP25(true);    break;
-    case STATE_NXDN:   setNXDN(true);   break;
-    case STATE_M17:    setM17(true);    break;
-    case STATE_POCSAG: setPOCSAG(true); break;
-    case STATE_FM:     setFM(true);     break;
+    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;
    default: break;
  }
 #endif
@@ -846,190 +844,3 @@ bool CIO::hasLockout() const
 {
  return m_lockout;
 }
-
-void IRQHandler()
-{
-  io.interrupt();
-}
-
-void CIO::interrupt()
-{
-  TSample sample = {DC_OFFSET, MARK_NONE};
-  uint16_t rawRSSI = 0U;
-
-  m_txBuffer.get(sample);
-  ::analogWrite(PIN_TX, sample.sample);
-
-  sample.sample = ::analogRead(PIN_RX);
-
-#if defined(SEND_RSSI_DATA)
-  rawRSSI = ::analogRead(PIN_RSSI);
-#endif
-
-  m_rxBuffer.put(sample);
-  m_rssiBuffer.put(rawRSSI);
-
-  m_ledCount++;
-  m_watchdog++;
-}
-
-void CIO::initHardware()
-{
-#if defined(PIN_COS)
-  ::pinMode(PIN_COS, INPUT);
-#endif
-
-#if defined(PIN_LED)
-  ::pinMode(PIN_LED, OUTPUT);
-#endif
-#if defined(PIN_PTT)
-  ::pinMode(PIN_PTT, OUTPUT);
-#endif
-#if defined(PIN_COSLED)
-  ::pinMode(PIN_COSLED, OUTPUT);
-#endif
-
-#if defined(MODE_LEDS)
-#if defined(PIN_DSTAR)
-  ::pinMode(PIN_DSTAR, OUTPUT);
-#endif
-#if defined(PIN_DMR)
-  ::pinMode(PIN_DMR, OUTPUT);
-#endif
-#if defined(PIN_YSF)
-  ::pinMode(PIN_YSF, OUTPUT);
-#endif
-#if defined(PIN_P25)
-  ::pinMode(PIN_P25, OUTPUT);
-#endif
-#if defined(PIN_NXDN) && !defined(USE_ALTERNATE_NXDN_LEDS)
-  ::pinMode(PIN_NXDN, OUTPUT);
-#endif
-#if defined(PIN_POCSAG) && !defined(USE_ALTERNATE_POCSAG_LEDS)
-  ::pinMode(PIN_POCSAG, OUTPUT);
-#endif
-#if defined(PIN_FM) && !defined(USE_ALTERNATE_FM_LEDS)
-  ::pinMode(PIN_FM, OUTPUT);
-#endif
-#if defined(PIN_M17) && !defined(USE_ALTERNATE_M17_LEDS)
-  ::pinMode(PIN_M17, OUTPUT);
-#endif
-#endif
-
-  ::analogReadResolution(12);
-  ::analogWriteResolution(12);
-
-  m_timer.setPrescaleFactor((SystemCoreClock / (6 * SAMPLE_RATE)) - 1);
-  m_timer.setOverflow(2);
-  m_timer.attachInterrupt(IRQHandler);
-  m_timer.refresh();              // Make register changes take effect
-}
-
-void CIO::startHardware()
-{
-  m_timer.resume();
-}
-
-bool CIO::getCOS()
-{
-  return ::digitalRead(PIN_COS) == HIGH;
-}
-
-void CIO::setLED(bool on)
-{
-   ::digitalWrite(PIN_LED, on ? HIGH : LOW);
-}
-
-void CIO::setPTT(bool on)
-{
-   ::digitalWrite(PIN_PTT, on ? HIGH : LOW);
-}
-
-void CIO::setCOS(bool on)
-{
-   ::digitalWrite(PIN_COSLED, on ? HIGH : LOW);
-}
-
-void CIO::setDStar(bool on)
-{
-#if defined(MODE_LEDS) && defined(PIN_DSTAR)
-   ::digitalWrite(PIN_DSTAR, on ? HIGH : LOW);
-#endif
-}
-
-void CIO::setDMR(bool on)
-{
-#if defined(MODE_LEDS) && defined(PIN_DMR)
-   ::digitalWrite(PIN_DMR, on ? HIGH : LOW);
-#endif
-}
-
-void CIO::setYSF(bool on)
-{
-#if defined(MODE_LEDS) && defined(PIN_YSF)
-   ::digitalWrite(PIN_YSF, on ? HIGH : LOW);
-#endif
-}
-
-void CIO::setP25(bool on)
-{
-#if defined(MODE_LEDS) && defined(PIN_P25)
-   ::digitalWrite(PIN_P25, on ? HIGH : LOW);
-#endif
-}
-
-void CIO::setNXDN(bool on)
-{
-#if defined(MODE_LEDS)
-#if defined(USE_ALTERNATE_NXDN_LEDS)
-   ::digitalWrite(PIN_YSF, on ? HIGH : LOW);
-   ::digitalWrite(PIN_P25, on ? HIGH : LOW);
-#else
-#if defined(PIN_NXDN)
-   ::digitalWrite(PIN_NXDN, on ? HIGH : LOW);
-#endif
-#endif
-#endif
-}
-
-void CIO::setM17(bool on)
-{
-#if defined(MODE_LEDS)
-#if defined(USE_ALTERNATE_M17_LEDS)
-   ::digitalWrite(PIN_DSTAR, on ? HIGH : LOW);
-   ::digitalWrite(PIN_P25, on ? HIGH : LOW);
-#else
-#if defined(PIN_M17)
-   ::digitalWrite(PIN_M17, on ? HIGH : LOW);
-#endif
-#endif
-#endif
-}
-
-void CIO::setPOCSAG(bool on)
-{
-#if defined(MODE_LEDS)
-#if defined(USE_ALTERNATE_POCSAG_LEDS)
-   ::digitalWrite(PIN_DSTAR, on ? HIGH : LOW);
-   ::digitalWrite(PIN_DMR, on ? HIGH : LOW);
-#else
-#if defined(PIN_POCSAG)
-   ::digitalWrite(PIN_POCSAG, on ? HIGH : LOW);
-#endif
-#endif
-#endif
-}
-
-void CIO::setFM(bool on)
-{
-#if defined(MODE_LEDS)
-#if defined(USE_ALTERNATE_FM_LEDS)
-   ::digitalWrite(PIN_DSTAR, on ? HIGH : LOW);
-   ::digitalWrite(PIN_YSF, on ? HIGH : LOW);
-#else
-#if defined(PIN_FM)
-   ::digitalWrite(PIN_FM, on ? HIGH : LOW);
-#endif
-#endif
-#endif
-}
@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016,2017,2018,2020,2021,2024 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017,2018,2020,2021 by Jonathan Naylor G4KLX
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
@@ -58,11 +58,13 @@ public:
  void resetWatchdog();
  uint32_t getWatchdog();
  
+  uint8_t getCPU() const;
+
+  void getUDID(uint8_t* buffer);
+
  void selfTest();

 private:
-  HardwareTimer         m_timer;
-
  bool                  m_started;

  CRingBuffer<TSample>  m_rxBuffer;
@@ -141,24 +143,26 @@ private:

  bool                 m_lockout;

-  // Hardware access routines
-  void initHardware();
-  void startHardware();
+  // Hardware specific routines
+  void initInt();
+  void startInt();

-  bool getCOS();
+  bool getCOSInt();

-  void setLED(bool on);
-  void setPTT(bool on);
-  void setCOS(bool on);
+  void setLEDInt(bool on);
+  void setPTTInt(bool on);
+  void setCOSInt(bool on);

-  void setDStar(bool on);
-  void setDMR(bool on);
-  void setYSF(bool on);
-  void setP25(bool on);
-  void setNXDN(bool on);
-  void setPOCSAG(bool on);
-  void setM17(bool on);
-  void setFM(bool on);
+  void setDStarInt(bool on);
+  void setDMRInt(bool on);
+  void setYSFInt(bool on);
+  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);
 };

 #endif
@@ -0,0 +1,79 @@
+/*
+ *   Copyright (C) 2019,2020 by BG5HHP
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef _IO_PINS_H
+#define _IO_PINS_H
+
+#if !defined(CONFIG_H)
+#error "Requires Config.h to be included first!"
+#endif
+
+#if defined(STM32F4_RPT_HAT_TGO)
+    #include "pins/pins_f4_rpt_tgo.h"
+
+#elif defined(STM32F4_DISCOVERY)
+    #include "pins/pins_f4_discovery.h"
+
+#elif defined(STM32F4_PI)
+    #include "pins/pins_f4_pi.h"
+
+#elif defined(STM32F722_PI)
+    #include "pins/pins_f7_pi.h"
+
+#elif defined(STM32F4_F4M)
+    #include "pins/pins_f4_f4m.h"
+
+#elif defined(STM32F722_F7M)
+    #include "pins/pins_f7_f7m.h"
+
+#elif defined(STM32F722_RPT_HAT)
+    #include "pins/pins_f7_rpt_hat.h"
+
+#elif defined(STM32F4_NUCLEO)
+    #if defined(STM32F4_NUCLEO_MORPHO_HEADER)
+        #include "pins/pins_f4_nucleo_morpho.h"
+    #elif defined(STM32F4_NUCLEO_ARDUINO_HEADER)
+        #include "pins/pins_f4_nucleo_arduino.h"
+    #else
+        #error "Either STM32F4_NUCLEO_MORPHO_HEADER or STM32F4_NUCLEO_ARDUINO_HEADER need to be defined"
+    #endif
+
+#elif defined(STM32F7_NUCLEO)
+    #include "pins/pins_f7_nucleo.h"
+
+#elif defined(STM32F4_DVM)
+    #include "pins/pins_f4_stm32dvm_v3.h"
+
+#elif defined(STM32F7_DVM)
+    #include "pins/pins_f7_stm32dvm_v5.h"
+
+#elif defined(DRCC_DVM_NQF)
+    #include "pins/pins_f4_drcc_nqf.h"
+
+#elif defined(DRCC_DVM_HHP446)
+    #include "pins/pins_f4_drcc_hhp446.h"
+
+#elif defined(STM32F4_EDA_405) || defined(STM32F4_EDA_446)
+    #include "pins/pins_f4_stm32eda.h"
+
+#else
+    #error "A valid board type macro need to be defined."
+
+#endif
+
+#endif  //#ifndef _IO_PINS_H
@@ -0,0 +1,571 @@
+/*
+ *   Copyright (C) 2016 by Jim McLaughlin KI6ZUM
+ *   Copyright (C) 2016,2017,2018 by Andy Uribe CA6JAU
+ *   Copyright (C) 2017,2018,2020,2023 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2019,2020 by BG5HHP
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "Config.h"
+#include "Globals.h"
+#include "IO.h"
+
+#if defined(STM32F4XX) || defined(STM32F7XX)
+#include "IOPins.h"
+
+
+const uint16_t DC_OFFSET = 2048U;
+
+// Sampling frequency
+#define SAMP_FREQ   24000
+
+extern "C" {
+   void TIM2_IRQHandler() {
+      if (TIM_GetITStatus(TIM2, TIM_IT_Update) != RESET) {
+         TIM_ClearITPendingBit(TIM2, TIM_IT_Update);
+         io.interrupt();
+      }
+   }
+}
+
+void CIO::initInt()
+{
+   GPIO_InitTypeDef GPIO_InitStruct;
+   GPIO_StructInit(&GPIO_InitStruct);
+   GPIO_InitStruct.GPIO_Speed = GPIO_Fast_Speed;
+   GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
+   GPIO_InitStruct.GPIO_PuPd  = GPIO_PuPd_DOWN;
+
+   // PTT pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_PTT, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_PTT;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_PTT, &GPIO_InitStruct);
+
+   // COSLED pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_COSLED, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_COSLED;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_COSLED, &GPIO_InitStruct);
+
+   // LED pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_LED, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_LED;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_LED, &GPIO_InitStruct);
+
+   // Init the input pins PIN_COS
+   RCC_AHB1PeriphClockCmd(RCC_Per_COS, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_COS;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_IN;
+   GPIO_Init(PORT_COS, &GPIO_InitStruct);
+
+#if defined(MODE_LEDS)
+   // DSTAR pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_DSTAR, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_DSTAR;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_DSTAR, &GPIO_InitStruct);
+
+   // DMR pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_DMR, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_DMR;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_DMR, &GPIO_InitStruct);
+
+   // YSF pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_YSF, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_YSF;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_YSF, &GPIO_InitStruct);
+
+   // P25 pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_P25, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_P25;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_P25, &GPIO_InitStruct);
+
+#if !defined(USE_ALTERNATE_NXDN_LEDS)
+   // NXDN pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_NXDN, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_NXDN;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_NXDN, &GPIO_InitStruct);
+#endif
+
+#if !defined(USE_ALTERNATE_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);
+   GPIO_InitStruct.GPIO_Pin   = PIN_POCSAG;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_POCSAG, &GPIO_InitStruct);
+#endif
+
+#if !defined(USE_ALTERNATE_FM_LEDS)
+   // FM pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_FM, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_FM;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_FM, &GPIO_InitStruct);
+#endif
+
+#endif
+
+#if defined(MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && (defined(STM32F4_NUCLEO) || defined(STM32F722_RPT_HAT))
+   // DSTAR mode pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_MDSTAR, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_MDSTAR;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_MDSTAR, &GPIO_InitStruct);
+
+   // DMR mode pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_MDMR, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_MDMR;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_MDMR, &GPIO_InitStruct);
+
+   // YSF mode pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_MYSF, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_MYSF;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_MYSF, &GPIO_InitStruct);
+
+   // P25 mode pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_MP25, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_MP25;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_MP25, &GPIO_InitStruct);
+
+#if !defined(USE_ALTERNATE_NXDN_LEDS)
+   // NXDN mode pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_MNXDN, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_MNXDN;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_MNXDN, &GPIO_InitStruct);
+#endif
+
+#if !defined(USE_ALTERNATE_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);
+   GPIO_InitStruct.GPIO_Pin   = PIN_MPOCSAG;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_MPOCSAG, &GPIO_InitStruct);
+#endif
+
+#if !defined(USE_ALTERNATE_FM_LEDS)
+   // FM mode pin
+   RCC_AHB1PeriphClockCmd(RCC_Per_MFM, ENABLE);
+   GPIO_InitStruct.GPIO_Pin   = PIN_MFM;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_OUT;
+   GPIO_Init(PORT_MFM, &GPIO_InitStruct);
+#endif
+
+#endif
+}
+
+void CIO::startInt()
+{
+   if ((ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) != RESET))
+      io.interrupt();
+
+   // Init the ADC
+   GPIO_InitTypeDef        GPIO_InitStruct;
+   ADC_InitTypeDef         ADC_InitStructure;
+   ADC_CommonInitTypeDef   ADC_CommonInitStructure;
+
+   GPIO_StructInit(&GPIO_InitStruct);
+   ADC_CommonStructInit(&ADC_CommonInitStructure);
+   ADC_StructInit(&ADC_InitStructure);
+
+   // Enable ADC1 clock
+   RCC_AHB1PeriphClockCmd(RCC_Per_RX, ENABLE);
+   RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);
+   // Enable ADC1 GPIO
+   GPIO_InitStruct.GPIO_Pin  = PIN_RX;
+   GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AN;
+   GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL ;
+   GPIO_Init(PORT_RX, &GPIO_InitStruct);
+
+#if defined(SEND_RSSI_DATA)
+   // Enable ADC2 clock
+   RCC_AHB1PeriphClockCmd(RCC_Per_RSSI, ENABLE);
+   RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC2, ENABLE);
+   // Enable ADC2 GPIO
+   GPIO_InitStruct.GPIO_Pin  = PIN_RSSI;
+   GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AN;
+   GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL ;
+   GPIO_Init(PORT_RSSI, &GPIO_InitStruct);
+#endif
+
+   // Init ADCs in dual mode (RSSI), div clock by two
+#if defined(SEND_RSSI_DATA)
+   ADC_CommonInitStructure.ADC_Mode             = ADC_DualMode_RegSimult;
+#else
+   ADC_CommonInitStructure.ADC_Mode             = ADC_Mode_Independent;
+#endif
+   ADC_CommonInitStructure.ADC_Prescaler        = ADC_Prescaler_Div2;
+   ADC_CommonInitStructure.ADC_DMAAccessMode    = ADC_DMAAccessMode_Disabled;
+   ADC_CommonInitStructure.ADC_TwoSamplingDelay = ADC_TwoSamplingDelay_5Cycles;
+   ADC_CommonInit(&ADC_CommonInitStructure);
+
+   // Init ADC1 and ADC2: 12bit, single-conversion
+   ADC_InitStructure.ADC_Resolution           = ADC_Resolution_12b;
+   ADC_InitStructure.ADC_ScanConvMode         = DISABLE;
+   ADC_InitStructure.ADC_ContinuousConvMode   = DISABLE;
+   ADC_InitStructure.ADC_ExternalTrigConvEdge = 0;
+   ADC_InitStructure.ADC_ExternalTrigConv     = 0;
+   ADC_InitStructure.ADC_DataAlign            = ADC_DataAlign_Right;
+   ADC_InitStructure.ADC_NbrOfConversion      = 1;
+
+   ADC_Init(ADC1, &ADC_InitStructure);
+
+   ADC_EOCOnEachRegularChannelCmd(ADC1, ENABLE);
+   ADC_RegularChannelConfig(ADC1, PIN_RX_CH, 1, ADC_SampleTime_3Cycles);
+
+   // Enable ADC1
+   ADC_Cmd(ADC1, ENABLE);
+
+#if defined(SEND_RSSI_DATA)
+   ADC_Init(ADC2, &ADC_InitStructure);
+
+   ADC_EOCOnEachRegularChannelCmd(ADC2, ENABLE);
+   ADC_RegularChannelConfig(ADC2, PIN_RSSI_CH, 1, ADC_SampleTime_3Cycles);
+
+   // Enable ADC2
+   ADC_Cmd(ADC2, ENABLE);
+#endif
+
+   // Init the DAC
+   DAC_InitTypeDef DAC_InitStructure;
+
+   GPIO_StructInit(&GPIO_InitStruct);
+   DAC_StructInit(&DAC_InitStructure);
+
+   // GPIOA clock enable
+   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
+
+   // DAC Periph clock enable
+   RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC, ENABLE);
+
+   // GPIO CONFIGURATION of DAC Pin
+   GPIO_InitStruct.GPIO_Pin   = PIN_TX;
+   GPIO_InitStruct.GPIO_Mode  = GPIO_Mode_AN;
+   GPIO_InitStruct.GPIO_PuPd  = GPIO_PuPd_NOPULL;
+   GPIO_Init(GPIOA, &GPIO_InitStruct);
+
+   DAC_InitStructure.DAC_Trigger = DAC_Trigger_None;
+   DAC_InitStructure.DAC_WaveGeneration = DAC_WaveGeneration_None;
+   DAC_InitStructure.DAC_OutputBuffer = DAC_OutputBuffer_Enable;
+   DAC_Init(PIN_TX_CH, &DAC_InitStructure);
+   DAC_Cmd(PIN_TX_CH, ENABLE);
+
+   // Init the timer
+   RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
+
+#if defined(EXTERNAL_OSC) && !(defined(STM32F4_PI) || defined(STM32F722_PI))
+   // Configure a GPIO as external TIM2 clock source
+   GPIO_PinAFConfig(PORT_EXT_CLK, SRC_EXT_CLK, GPIO_AF_TIM2);
+   GPIO_InitStruct.GPIO_Pin = PIN_EXT_CLK;
+   GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
+   GPIO_Init(PORT_EXT_CLK, &GPIO_InitStruct);
+#endif
+
+   TIM_TimeBaseInitTypeDef timerInitStructure;
+   TIM_TimeBaseStructInit (&timerInitStructure);
+
+   // TIM2 output frequency
+#if defined(EXTERNAL_OSC) && !(defined(STM32F4_PI) || defined(STM32F722_PI))
+   timerInitStructure.TIM_Prescaler = (uint16_t) ((EXTERNAL_OSC/(2*SAMP_FREQ)) - 1);
+   timerInitStructure.TIM_Period = 1;
+#else
+   timerInitStructure.TIM_Prescaler = (uint16_t) ((SystemCoreClock/(6*SAMP_FREQ)) - 1);
+   timerInitStructure.TIM_Period = 2;
+#endif
+
+   timerInitStructure.TIM_CounterMode       = TIM_CounterMode_Up;
+   timerInitStructure.TIM_ClockDivision     = TIM_CKD_DIV1;
+   timerInitStructure.TIM_RepetitionCounter = 0;
+   TIM_TimeBaseInit(TIM2, &timerInitStructure);
+
+#if defined(EXTERNAL_OSC) && !(defined(STM32F4_PI) || defined(STM32F722_PI))
+   // Enable external clock
+   TIM_ETRClockMode2Config(TIM2, TIM_ExtTRGPSC_OFF, TIM_ExtTRGPolarity_NonInverted, 0x00);
+#else
+   // Enable internal clock
+   TIM_InternalClockConfig(TIM2);
+#endif
+
+   // Enable TIM2
+   TIM_Cmd(TIM2, ENABLE);
+   // Enable TIM2 interrupt
+   TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);
+
+   NVIC_InitTypeDef nvicStructure;
+   nvicStructure.NVIC_IRQChannel                   = TIM2_IRQn;
+   nvicStructure.NVIC_IRQChannelPreemptionPriority = 0;
+   nvicStructure.NVIC_IRQChannelSubPriority        = 1;
+   nvicStructure.NVIC_IRQChannelCmd                = ENABLE;
+   NVIC_Init(&nvicStructure);
+
+   GPIO_ResetBits(PORT_COSLED, PIN_COSLED);
+   GPIO_SetBits(PORT_LED, PIN_LED);
+}
+
+void CIO::interrupt()
+{
+   TSample sample = {DC_OFFSET, MARK_NONE};
+   uint16_t rawRSSI = 0U;
+
+   m_txBuffer.get(sample);
+
+   // Send the value to the DAC
+#if defined(STM32F4_NUCLEO) && defined(STM32F4_NUCLEO_ARDUINO_HEADER)
+   DAC_SetChannel2Data(DAC_Align_12b_R, sample.sample);
+#else
+   DAC_SetChannel1Data(DAC_Align_12b_R, sample.sample);
+#endif
+
+   // Read value from ADC1 and ADC2
+   if ((ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET)) {
+      // shouldn't be still in reset at this point so null the sample value?
+      sample.sample  = 0U;
+   } else {
+      sample.sample  = ADC_GetConversionValue(ADC1);
+#if defined(SEND_RSSI_DATA)
+      rawRSSI = ADC_GetConversionValue(ADC2);
+#endif
+   }
+
+   // Trigger next ADC1
+   ADC_ClearFlag(ADC1, ADC_FLAG_EOC);
+   ADC_SoftwareStartConv(ADC1);
+
+#if defined(SEND_RSSI_DATA)
+   // Trigger next ADC2
+   ADC_ClearFlag(ADC2, ADC_FLAG_EOC);
+   ADC_SoftwareStartConv(ADC2);
+#endif
+
+   m_rxBuffer.put(sample);
+   m_rssiBuffer.put(rawRSSI);
+
+   m_watchdog++;
+}
+
+bool CIO::getCOSInt()
+{
+   return GPIO_ReadInputDataBit(PORT_COS, PIN_COS) == Bit_SET;
+}
+
+void CIO::setLEDInt(bool on)
+{
+   GPIO_WriteBit(PORT_LED, PIN_LED, on ? Bit_SET : Bit_RESET);
+}
+
+void CIO::setPTTInt(bool on)
+{
+   GPIO_WriteBit(PORT_PTT, PIN_PTT, on ? Bit_SET : Bit_RESET);
+}
+
+void CIO::setCOSInt(bool on)
+{
+   GPIO_WriteBit(PORT_COSLED, PIN_COSLED, on ? Bit_SET : Bit_RESET);
+}
+
+void CIO::setDStarInt(bool on)
+{
+#if defined(MODE_LEDS)
+   GPIO_WriteBit(PORT_DSTAR, PIN_DSTAR, on ? Bit_SET : Bit_RESET);
+#endif
+#if defined(MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && (defined(STM32F4_NUCLEO) || defined(STM32F722_RPT_HAT))
+   GPIO_WriteBit(PORT_MDSTAR, PIN_MDSTAR, on ? Bit_SET : Bit_RESET);
+#endif
+}
+
+void CIO::setDMRInt(bool on)
+{
+#if defined(MODE_LEDS)
+   GPIO_WriteBit(PORT_DMR, PIN_DMR, on ? Bit_SET : Bit_RESET);
+#endif
+#if defined(MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && (defined(STM32F4_NUCLEO) || defined(STM32F722_RPT_HAT))
+   GPIO_WriteBit(PORT_MDMR, PIN_MDMR, on ? Bit_SET : Bit_RESET);
+#endif
+}
+
+void CIO::setYSFInt(bool on)
+{
+#if defined(MODE_LEDS)
+   GPIO_WriteBit(PORT_YSF, PIN_YSF, on ? Bit_SET : Bit_RESET);
+#endif
+#if defined(MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && (defined(STM32F4_NUCLEO) || defined(STM32F722_RPT_HAT))
+   GPIO_WriteBit(PORT_MYSF, PIN_MYSF, on ? Bit_SET : Bit_RESET);
+#endif
+}
+
+void CIO::setP25Int(bool on)
+{
+#if defined(MODE_LEDS)
+   GPIO_WriteBit(PORT_P25, PIN_P25, on ? Bit_SET : Bit_RESET);
+#endif
+#if defined(MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && (defined(STM32F4_NUCLEO) || defined(STM32F722_RPT_HAT))
+   GPIO_WriteBit(PORT_MP25, PIN_MP25, on ? Bit_SET : Bit_RESET);
+#endif
+}
+
+void CIO::setNXDNInt(bool on)
+{
+#if defined(MODE_LEDS)
+#if defined(USE_ALTERNATE_NXDN_LEDS)
+   GPIO_WriteBit(PORT_YSF, PIN_YSF, on ? Bit_SET : Bit_RESET);
+   GPIO_WriteBit(PORT_P25, PIN_P25, on ? Bit_SET : Bit_RESET);
+#else
+   GPIO_WriteBit(PORT_NXDN, PIN_NXDN, on ? Bit_SET : Bit_RESET);
+#endif
+#endif
+
+#if defined(MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && (defined(STM32F4_NUCLEO) || defined(STM32F722_RPT_HAT))
+#if defined(USE_ALTERNATE_NXDN_LEDS)
+   GPIO_WriteBit(PORT_MYSF, PIN_MYSF, on ? Bit_SET : Bit_RESET);
+   GPIO_WriteBit(PORT_MP25, PIN_MP25, on ? Bit_SET : Bit_RESET);
+#else
+   GPIO_WriteBit(PORT_MNXDN, PIN_MNXDN, on ? Bit_SET : Bit_RESET);
+#endif
+#endif
+}
+
+void CIO::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)
+#if defined(USE_ALTERNATE_POCSAG_LEDS)
+   GPIO_WriteBit(PORT_DSTAR, PIN_DSTAR, on ? Bit_SET : Bit_RESET);
+   GPIO_WriteBit(PORT_DMR,   PIN_DMR,   on ? Bit_SET : Bit_RESET);
+#else
+   GPIO_WriteBit(PORT_POCSAG,  PIN_POCSAG, on ? Bit_SET : Bit_RESET);
+#endif
+#endif
+
+#if defined(MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && (defined(STM32F4_NUCLEO) || defined(STM32F722_RPT_HAT))
+#if defined(USE_ALTERNATE_POCSAG_LEDS)
+   GPIO_WriteBit(PORT_MDSTAR, PIN_MDSTAR, on ? Bit_SET : Bit_RESET);
+   GPIO_WriteBit(PORT_MDMR,   PIN_MDMR,   on ? Bit_SET : Bit_RESET);
+#else
+   GPIO_WriteBit(PORT_MPOCSAG, PIN_MPOCSAG, on ? Bit_SET : Bit_RESET);
+#endif
+#endif
+}
+
+void CIO::setFMInt(bool on)
+{
+#if defined(MODE_LEDS)
+#if defined(USE_ALTERNATE_FM_LEDS)
+   GPIO_WriteBit(PORT_DSTAR, PIN_DSTAR, on ? Bit_SET : Bit_RESET);
+   GPIO_WriteBit(PORT_YSF,   PIN_YSF,   on ? Bit_SET : Bit_RESET);
+#else
+   GPIO_WriteBit(PORT_FM,  PIN_FM, on ? Bit_SET : Bit_RESET);
+#endif
+#endif
+
+#if defined(MODE_PINS) && defined(STM32F4_NUCLEO_MORPHO_HEADER) && (defined(STM32F4_NUCLEO) || defined(STM32F722_RPT_HAT))
+#if defined(USE_ALTERNATE_FM_LEDS)
+   GPIO_WriteBit(PORT_MDSTAR, PIN_MDSTAR, on ? Bit_SET : Bit_RESET);
+   GPIO_WriteBit(PORT_MYSF,   PIN_MYSF,   on ? Bit_SET : Bit_RESET);
+#else
+   GPIO_WriteBit(PORT_MFM, PIN_MFM, on ? Bit_SET : Bit_RESET);
+#endif
+#endif
+}
+
+// Simple delay function for STM32
+// Example from: http://thehackerworkshop.com/?p=1209
+void CIO::delayInt(unsigned int dly)
+{
+#if defined(STM32F7XX)
+  unsigned int loopsPerMillisecond = (SystemCoreClock/1000);
+#else
+  unsigned int loopsPerMillisecond = (SystemCoreClock/1000) / 3;
+#endif
+
+  for (; dly > 0; dly--)
+  {
+    asm volatile //this routine waits (approximately) one millisecond
+    (
+      "mov r3, %[loopsPerMillisecond] \n\t" //load the initial loop counter
+      "loop: \n\t"
+        "subs r3, #1 \n\t"
+        "bne loop \n\t"
+
+      : //empty output list
+      : [loopsPerMillisecond] "r" (loopsPerMillisecond) //input to the asm routine
+      : "r3", "cc" //clobber list
+    );
+  }
+}
+
+uint8_t CIO::getCPU() const
+{
+  return 2U;
+}
+
+void CIO::getUDID(uint8_t* buffer)
+{
+#if defined(STM32F4XX)
+  ::memcpy(buffer, (void *)0x1FFF7A10, 12U);
+#elif defined(STM32F722xx)
+  ::memcpy(buffer, (void *)0x1FF07A10, 12U);
+#elif defined(STM32F767xx)
+  ::memcpy(buffer, (void *)0x1FF0F420, 12U);
+#endif
+}
+
+#endif
+
@@ -160,7 +160,7 @@ void CM17TX::writeByte(uint8_t c)

 void CM17TX::writeSilence()
 {
-  q15_t inBuffer[4U] = {0x00U, 0x00U, 0x00U, 0x00U};
+  q15_t inBuffer[4U] = {0, 0, 0, 0};
  q15_t outBuffer[M17_RADIO_SYMBOL_LENGTH * 4U];

  ::arm_fir_interpolate_q15(&m_modFilter, inBuffer, outBuffer, 4U);
@@ -18,6 +18,8 @@
 *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

+#if defined(STM32F4XX) || defined(STM32F7XX) || defined(STM32F105xC)
+
 #include "Config.h"
 #include "Globals.h"

@@ -205,3 +207,13 @@ void loop()
  if (m_modemState == STATE_IDLE)
    cwIdTX.process();
 }
+
+int main()
+{
+  setup();
+
+  for (;;)
+    loop();
+}
+
+#endif
@@ -0,0 +1,413 @@
+#  Copyright (C) 2016,2017,2018 by Andy Uribe CA6JAU
+#  Copyright (C) 2016 by Jim McLaughlin KI6ZUM
+
+#  This program is free software; you can redistribute it and/or modify
+#  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.
+
+# MMDVM source files
+MMDVM_PATH=.
+
+# STM32 library paths
+F4_LIB_PATH=./STM32F4XX_Lib
+F7_LIB_PATH=./STM32F7XX_Lib
+
+# MCU external clock frequency (Hz)
+CLK_MMDVM_PI=12000000
+CLK_NUCLEO=8000000
+CLK_12MHZ=12000000
+
+# Directory Structure
+BINDIR=bin
+OBJDIR_F4=obj_f4
+OBJDIR_F7=obj_f7
+
+# Output files
+BINELF_F4=mmdvm_f4.elf
+BINHEX_F4=mmdvm_f4.hex
+BINBIN_F4=mmdvm_f4.bin
+BINELF_F7=mmdvm_f7.elf
+BINHEX_F7=mmdvm_f7.hex
+BINBIN_F7=mmdvm_f7.bin
+
+# Header directories
+INC_F4= . $(F4_LIB_PATH)/CMSIS/Include/ $(F4_LIB_PATH)/Device/ $(F4_LIB_PATH)/STM32F4xx_StdPeriph_Driver/include/
+INCLUDES_F4=$(INC_F4:%=-I%)
+INC_F7= . $(F7_LIB_PATH)/CMSIS/Include/ $(F7_LIB_PATH)/Device/ $(F7_LIB_PATH)/STM32F7xx_StdPeriph_Driver/inc/
+INCLUDES_F7=$(INC_F7:%=-I%)
+
+# CMSIS libraries
+INCLUDES_LIBS_F4=$(F4_LIB_PATH)/CMSIS/Lib/GCC/libarm_cortexM4lf_math.a
+INCLUDES_LIBS_F7=$(F7_LIB_PATH)/CMSIS/Lib/GCC/libarm_cortexM7lfsp_math.a
+
+# STM32F4 Standard Peripheral Libraries source path
+STD_LIB_F4=$(F4_LIB_PATH)/STM32F4xx_StdPeriph_Driver/source
+
+# STM32F7 Standard Peripheral Libraries source path
+STD_LIB_F7=$(F7_LIB_PATH)/STM32F7xx_StdPeriph_Driver/src
+
+# STM32F4 system source path
+SYS_DIR_F4=$(F4_LIB_PATH)/Device
+STARTUP_DIR_F4=$(F4_LIB_PATH)/Device/startup
+
+# STM32F7 system source path
+SYS_DIR_F7=$(F7_LIB_PATH)/Device
+STARTUP_DIR_F7=$(F7_LIB_PATH)/Device/startup
+
+# GNU ARM Embedded Toolchain
+CC=arm-none-eabi-gcc
+CXX=arm-none-eabi-g++
+LD=arm-none-eabi-ld
+AR=arm-none-eabi-ar
+AS=arm-none-eabi-as
+CP=arm-none-eabi-objcopy
+OD=arm-none-eabi-objdump
+NM=arm-none-eabi-nm
+SIZE=arm-none-eabi-size
+A2L=arm-none-eabi-addr2line
+
+# "SystemRoot" is only defined in Windows
+ifdef SYSTEMROOT
+	CLEANCMD=del /S *.o *.hex *.bin *.elf GitVersion.h
+	MDDIRS=md $@
+else ifdef SystemRoot
+	CLEANCMD=del /S *.o *.hex *.bin *.elf GitVersion.h
+	MDDIRS=md $@
+else
+	CLEANCMD=rm -f $(OBJ_F4) $(OBJ_F7) $(BINDIR)/*.hex $(BINDIR)/*.bin $(BINDIR)/*.elf GitVersion.h
+	MDDIRS=mkdir $@
+endif
+
+# Default reference oscillator frequencies
+ifndef $(OSC)
+	ifeq ($(MAKECMDGOALS),pi)
+		OSC=$(CLK_MMDVM_PI)
+	else ifeq ($(MAKECMDGOALS),pi-f722)
+		OSC=$(CLK_MMDVM_PI)
+	else ifeq ($(MAKECMDGOALS),drcc_nqf)
+		OSC=$(CLK_12MHZ)
+	else
+		OSC=$(CLK_NUCLEO)
+	endif
+endif
+
+# Build object lists
+CXXSRC=$(wildcard $(MMDVM_PATH)/*.cpp)
+CSRC_STD_F4=$(wildcard $(STD_LIB_F4)/*.c)
+SYS_F4=$(wildcard $(SYS_DIR_F4)/*.c)
+STARTUP_F4=$(wildcard $(STARTUP_DIR_F4)/*.c)
+CSRC_STD_F7=$(wildcard $(STD_LIB_F7)/*.c)
+SYS_F7=$(wildcard $(SYS_DIR_F7)/*.c)
+STARTUP_F7=$(wildcard $(STARTUP_DIR_F7)/*.c)
+OBJ_F4=$(CXXSRC:$(MMDVM_PATH)/%.cpp=$(OBJDIR_F4)/%.o) $(CSRC_STD_F4:$(STD_LIB_F4)/%.c=$(OBJDIR_F4)/%.o) $(SYS_F4:$(SYS_DIR_F4)/%.c=$(OBJDIR_F4)/%.o) $(STARTUP_F4:$(STARTUP_DIR_F4)/%.c=$(OBJDIR_F4)/%.o)
+OBJ_F7=$(CXXSRC:$(MMDVM_PATH)/%.cpp=$(OBJDIR_F7)/%.o) $(CSRC_STD_F7:$(STD_LIB_F7)/%.c=$(OBJDIR_F7)/%.o) $(SYS_F7:$(SYS_DIR_F7)/%.c=$(OBJDIR_F7)/%.o) $(STARTUP_F7:$(STARTUP_DIR_F7)/%.c=$(OBJDIR_F7)/%.o)
+
+# MCU flags
+MCFLAGS_F4=-mcpu=cortex-m4 -mthumb -mlittle-endian -mfpu=fpv4-sp-d16 -mfloat-abi=hard -mthumb-interwork
+MCFLAGS_F7=-mcpu=cortex-m7 -mthumb -mlittle-endian -mfpu=fpv5-sp-d16 -mfloat-abi=hard -mthumb-interwork
+
+# Compile flags
+# STM32F4 Discovery board:
+DEFS_DIS=-DUSE_STDPERIPH_DRIVER -DSTM32F4XX -DSTM32F40_41xxx -DSTM32F4_DISCOVERY -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
+# MMDVM-Pi board:
+DEFS_PI=-DUSE_STDPERIPH_DRIVER -DSTM32F4XX -DSTM32F446xx -DSTM32F4_PI -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
+# MMDVM-F4M F0DEI board:
+DEFS_F4M=-DUSE_STDPERIPH_DRIVER -DSTM32F4XX -DSTM32F446xx -DSTM32F4_F4M -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
+# STM32F4 Nucleo-64 F446RE board:
+DEFS_NUCLEO=-DUSE_STDPERIPH_DRIVER -DSTM32F4XX -DSTM32F446xx -DSTM32F4_NUCLEO -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
+# STM32F7 Nucleo-144 F767ZI board:
+DEFS_NUCLEO_F767=-DUSE_HAL_DRIVER -DSTM32F767xx -DSTM32F7XX -DSTM32F7_NUCLEO -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
+# MMDVM-Pi F722 board:
+DEFS_PI_F722=-DUSE_HAL_DRIVER -DSTM32F722xx -DSTM32F7XX -DSTM32F722_PI -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
+# MMDVM-F7M F0DEI board:
+DEFS_F7M=-DUSE_HAL_DRIVER -DSTM32F722xx -DSTM32F7XX -DSTM32F722_F7M -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
+# MMDVM_RPT_Hat F0DEI, DB9MAT, DF2ET board:
+DEFS_RPT_HAT=-DUSE_HAL_DRIVER -DSTM32F722xx -DSTM32F7XX -DSTM32F722_RPT_HAT -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
+# RB STM32F4_DVM board:
+DEFS_DVM=-DUSE_STDPERIPH_DRIVER -DSTM32F4XX -DSTM32F446xx -DSTM32F4_DVM -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
+# RB STM32F7 DVM board:
+DEFS_DVM722=-DUSE_HAL_DRIVER -DSTM32F722xx -DSTM32F7XX -DSTM32F7_DVM -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
+# MMDVM_RPT_Hat BG4TGO, BG5HHP board:
+DEFS_RPT_HAT_TGO=-DUSE_STDPERIPH_DRIVER -DSTM32F4XX -DSTM32F40_41xxx -DSTM32F4_RPT_HAT_TGO -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
+# DRCC_DVM BG7NQF board:
+DEFS_DRCC_DVM=-DUSE_STDPERIPH_DRIVER -DSTM32F4XX -DSTM32F446xx -DDRCC_DVM -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
+# WA0EDA F405 MTR2K, MASTR3 board:
+DEFS_EDA_405=-DUSE_STDPERIPH_DRIVER -DSTM32F4XX -DSTM32F40_41xxx -DSTM32F4_EDA_405 -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
+# WA0EDA F446 MTR2K, MASTR3 board:
+DEFS_EDA_446=-DUSE_STDPERIPH_DRIVER -DSTM32F4XX -DSTM32F446xx -DSTM32F4_EDA_446 -DHSE_VALUE=$(OSC) -DMADEBYMAKEFILE
+
+
+# Build compiler flags
+CFLAGS_F4=-c $(MCFLAGS_F4) $(INCLUDES_F4)
+CXXFLAGS_F4=-c $(MCFLAGS_F4) $(INCLUDES_F4)
+CFLAGS_F7=-c $(MCFLAGS_F7) $(INCLUDES_F7)
+CXXFLAGS_F7=-c $(MCFLAGS_F7) $(INCLUDES_F7)
+
+# Linker flags
+LDFLAGS_F4 =-T stm32f4xx_link.ld $(MCFLAGS_F4) --specs=nosys.specs $(INCLUDES_LIBS_F4)
+LDFLAGS_F767 =-T stm32f767_link.ld $(MCFLAGS_F7) --specs=nosys.specs $(INCLUDES_LIBS_F7)
+LDFLAGS_F722 =-T stm32f722_link.ld $(MCFLAGS_F7) --specs=nosys.specs $(INCLUDES_LIBS_F7)
+
+# Common flags
+CFLAGS=-Os -ffunction-sections -fdata-sections -fno-builtin -Wno-implicit -DCUSTOM_NEW -DNO_EXCEPTIONS
+CXXFLAGS=-Os -fno-exceptions -ffunction-sections -fdata-sections -fno-builtin -fno-rtti -DCUSTOM_NEW -DNO_EXCEPTIONS
+LDFLAGS=-Os --specs=nano.specs -Wl,-Map=bin/mmdvm.map
+
+# Build Rules
+.PHONY: all release dis pi pi-f722 f4m nucleo f767 dvm drcc_nqf clean
+
+# Default target: Nucleo-64 F446RE board
+all: nucleo
+
+pi: GitVersion.h
+pi: CFLAGS+=$(CFLAGS_F4) $(DEFS_PI)
+pi: CXXFLAGS+=$(CXXFLAGS_F4) $(DEFS_PI)
+pi: LDFLAGS+=$(LDFLAGS_F4)
+pi: release_f4
+
+pi-f722: GitVersion.h
+pi-f722: CFLAGS+=$(CFLAGS_F7) $(DEFS_PI_F722)
+pi-f722: CXXFLAGS+=$(CXXFLAGS_F7) $(DEFS_PI_F722)
+pi-f722: LDFLAGS+=$(LDFLAGS_F722)
+pi-f722: release_f7
+
+f4m: GitVersion.h
+f4m: CFLAGS+=$(CFLAGS_F4) $(DEFS_F4M)
+f4m: CXXFLAGS+=$(CXXFLAGS_F4) $(DEFS_F4M)
+f4m: LDFLAGS+=$(LDFLAGS_F4)
+f4m: release_f4
+
+f7m: GitVersion.h
+f7m: CFLAGS+=$(CFLAGS_F7) $(DEFS_F7M)
+f7m: CXXFLAGS+=$(CXXFLAGS_F7) $(DEFS_F7M)
+f7m: LDFLAGS+=$(LDFLAGS_F722)
+f7m: release_f7
+
+rpt_hat: GitVersion.h
+rpt_hat: CFLAGS+=$(CFLAGS_F7) $(DEFS_RPT_HAT)
+rpt_hat: CXXFLAGS+=$(CXXFLAGS_F7) $(DEFS_RPT_HAT)
+rpt_hat: LDFLAGS+=$(LDFLAGS_F722)
+rpt_hat: release_f7
+
+rpt_hat_tgo: GitVersion.h
+rpt_hat_tgo: CFLAGS+=$(CFLAGS_F4) $(DEFS_RPT_HAT_TGO)
+rpt_hat_tgo: CXXFLAGS+=$(CXXFLAGS_F4) $(DEFS_RPT_HAT_TGO)
+rpt_hat_tgo: LDFLAGS+=$(LDFLAGS_F4)
+rpt_hat_tgo: release_f4
+
+nucleo: GitVersion.h
+nucleo: CFLAGS+=$(CFLAGS_F4) $(DEFS_NUCLEO)
+nucleo: CXXFLAGS+=$(CXXFLAGS_F4) $(DEFS_NUCLEO)
+nucleo: LDFLAGS+=$(LDFLAGS_F4)
+nucleo: release_f4
+
+dis: GitVersion.h
+dis: CFLAGS+=$(CFLAGS_F4) $(DEFS_DIS)
+dis: CXXFLAGS+=$(CXXFLAGS_F4) $(DEFS_DIS)
+dis: LDFLAGS+=$(LDFLAGS_F4)
+dis: release_f4
+
+f767: GitVersion.h
+f767: CFLAGS+=$(CFLAGS_F7) $(DEFS_NUCLEO_F767)
+f767: CXXFLAGS+=$(CXXFLAGS_F7) $(DEFS_NUCLEO_F767)
+f767: LDFLAGS+=$(LDFLAGS_F767)
+f767: release_f7
+
+dvm: GitVersion.h
+dvm: CFLAGS+=$(CFLAGS_F4) $(DEFS_DVM) -DDRCC_DVM_446
+dvm: CXXFLAGS+=$(CXXFLAGS_F4) $(DEFS_DVM) -DDRCC_DVM_446
+dvm: LDFLAGS+=$(LDFLAGS_F4)
+dvm: release_f4
+
+dvm722: GitVersion.h
+dvm722: CFLAGS+=$(CFLAGS_F7) $(DEFS_DVM722) -DDRCC_DVM_722
+dvm722: CXXFLAGS+=$(CXXFLAGS_F7) $(DEFS_DVM722) -DDRCC_DVM_722
+dvm722: LDFLAGS+=$(LDFLAGS_F722)
+dvm722: release_f7
+
+drcc_nqf: GitVersion.h
+drcc_nqf: CFLAGS+=$(CFLAGS_F4) $(DEFS_DRCC_DVM) -DDRCC_DVM_NQF
+drcc_nqf: CXXFLAGS+=$(CXXFLAGS_F4) $(DEFS_DRCC_DVM) -DDRCC_DVM_NQF
+drcc_nqf: LDFLAGS+=$(LDFLAGS_F4)
+drcc_nqf: release_f4
+
+hhp446: GitVersion.h
+hhp446: CFLAGS+=$(CFLAGS_F4) $(DEFS_DRCC_DVM) -DDRCC_DVM_HHP446
+hhp446: CXXFLAGS+=$(CXXFLAGS_F4) $(DEFS_DRCC_DVM) -DDRCC_DVM_HHP446
+hhp446: LDFLAGS+=$(LDFLAGS_F4)
+hhp446: release_f4
+
+eda405: GitVersion.h
+eda405: CFLAGS+=$(CFLAGS_F4) $(DEFS_EDA_405)
+eda405: CXXFLAGS+=$(CXXFLAGS_F4) $(DEFS_EDA_405)
+eda405: LDFLAGS+=$(LDFLAGS_F4)
+eda405: release_f4
+
+eda446: GitVersion.h
+eda446: CFLAGS+=$(CFLAGS_F4) $(DEFS_EDA_446)
+eda446: CXXFLAGS+=$(CXXFLAGS_F4) $(DEFS_EDA_446)
+eda446: LDFLAGS+=$(LDFLAGS_F4)
+eda446: release_f4
+
+release_f4: $(BINDIR)
+release_f4: $(OBJDIR_F4)
+release_f4: $(BINDIR)/$(BINHEX_F4)
+release_f4: $(BINDIR)/$(BINBIN_F4)
+
+release_f7: $(BINDIR)
+release_f7: $(OBJDIR_F7)
+release_f7: $(BINDIR)/$(BINHEX_F7)
+release_f7: $(BINDIR)/$(BINBIN_F7)
+
+$(BINDIR):
+	$(MDDIRS)
+
+$(OBJDIR_F4):
+	$(MDDIRS)
+
+$(OBJDIR_F7):
+	$(MDDIRS)
+
+$(BINDIR)/$(BINHEX_F4): $(BINDIR)/$(BINELF_F4)
+	$(CP) -O ihex $< $@
+	@echo "Objcopy from ELF to IHEX complete!\n"
+
+$(BINDIR)/$(BINBIN_F4): $(BINDIR)/$(BINELF_F4)
+	$(CP) -O binary $< $@
+	@echo "Objcopy from ELF to BINARY complete!\n"
+
+$(BINDIR)/$(BINELF_F4): $(OBJ_F4)
+	$(CXX) $(OBJ_F4) $(LDFLAGS) -o $@
+	@echo "Linking complete!\n"
+	$(SIZE) $(BINDIR)/$(BINELF_F4)
+
+$(BINDIR)/$(BINHEX_F7): $(BINDIR)/$(BINELF_F7)
+	$(CP) -O ihex $< $@
+	@echo "Objcopy from ELF to IHEX complete!\n"
+
+$(BINDIR)/$(BINBIN_F7): $(BINDIR)/$(BINELF_F7)
+	$(CP) -O binary $< $@
+	@echo "Objcopy from ELF to BINARY complete!\n"
+
+$(BINDIR)/$(BINELF_F7): $(OBJ_F7)
+	$(CXX) $(OBJ_F7) $(LDFLAGS) -o $@
+	@echo "Linking complete!\n"
+	$(SIZE) $(BINDIR)/$(BINELF_F7)
+
+$(OBJDIR_F4)/%.o: $(MMDVM_PATH)/%.cpp
+	$(CXX) $(CXXFLAGS) $< -o $@
+	@echo "Compiled "$<"!\n"
+
+$(OBJDIR_F7)/%.o: $(MMDVM_PATH)/%.cpp
+	$(CXX) $(CXXFLAGS) $< -o $@
+	@echo "Compiled "$<"!\n"
+
+$(OBJDIR_F4)/%.o: $(STD_LIB_F4)/%.c
+	$(CC) $(CFLAGS) $< -o $@
+	@echo "Compiled "$<"!\n"
+
+$(OBJDIR_F7)/%.o: $(STD_LIB_F7)/%.c
+	$(CC) $(CFLAGS) $< -o $@
+	@echo "Compiled "$<"!\n"
+
+$(OBJDIR_F4)/%.o: $(SYS_DIR_F4)/%.c
+	$(CC) $(CFLAGS) $< -o $@
+	@echo "Compiled "$<"!\n"
+
+$(OBJDIR_F4)/%.o: $(STARTUP_DIR_F4)/%.c
+	$(CC) $(CFLAGS) $< -o $@
+	@echo "Compiled "$<"!\n"
+
+$(OBJDIR_F7)/%.o: $(SYS_DIR_F7)/%.c
+	$(CC) $(CFLAGS) $< -o $@
+	@echo "Compiled "$<"!\n"
+
+$(OBJDIR_F7)/%.o: $(STARTUP_DIR_F7)/%.c
+	$(CC) $(CFLAGS) $< -o $@
+	@echo "Compiled "$<"!\n"
+
+clean:
+	$(CLEANCMD)
+
+deploy:
+ifneq ($(wildcard /usr/bin/openocd),)
+	/usr/bin/openocd -f /usr/share/openocd/scripts/interface/stlink-v2-1.cfg -f /usr/share/openocd/scripts/target/stm32f4x.cfg -c "program bin/$(BINELF_F4) verify reset exit"
+endif
+
+ifneq ($(wildcard /usr/local/bin/openocd),)
+	/usr/local/bin/openocd -f /usr/local/share/openocd/scripts/interface/stlink-v2-1.cfg -f /usr/local/share/openocd/scripts/target/stm32f4x.cfg -c "program bin/$(BINELF_F4) verify reset exit"
+endif
+
+ifneq ($(wildcard /opt/openocd/bin/openocd),)
+	/opt/openocd/bin/openocd -f /opt/openocd/share/openocd/scripts/interface/stlink-v2-1.cfg -f /opt/openocd/share/openocd/scripts/target/stm32f4x.cfg -c "program bin/$(BINELF_F4) verify reset exit"
+endif
+
+deploy-f7:
+ifneq ($(wildcard /usr/bin/openocd),)
+	/usr/bin/openocd -f /usr/share/openocd/scripts/interface/stlink-v2-1.cfg -f /usr/share/openocd/scripts/target/stm32f7x.cfg -c "program bin/$(BINELF_F7) verify reset exit"
+endif
+
+ifneq ($(wildcard /usr/local/bin/openocd),)
+	/usr/local/bin/openocd -f /usr/local/share/openocd/scripts/interface/stlink-v2-1.cfg -f /usr/local/share/openocd/scripts/target/stm32f7x.cfg -c "program bin/$(BINELF_F7) verify reset exit"
+endif
+
+ifneq ($(wildcard /opt/openocd/bin/openocd),)
+	/opt/openocd/bin/openocd -f /opt/openocd/share/openocd/scripts/interface/stlink-v2-1.cfg -f /opt/openocd/share/openocd/scripts/target/stm32f7x.cfg -c "program bin/$(BINELF_F7) verify reset exit"
+endif
+
+deploy-pi:
+ifneq ($(wildcard /usr/local/bin/stm32flash),)
+	-/usr/local/bin/stm32flash -i 20,-21,21:-20,21 /dev/ttyAMA0
+	/usr/local/bin/stm32flash -v -w bin/$(BINBIN_F4) -g 0x0 -R /dev/ttyAMA0
+endif
+
+ifneq ($(wildcard /usr/bin/stm32flash),)
+	-/usr/bin/stm32flash -i 20,-21,21:-20,21 /dev/ttyAMA0
+	/usr/bin/stm32flash -v -w bin/$(BINBIN_F4) -g 0x0 -R /dev/ttyAMA0
+endif
+
+deploy-f4m: deploy-pi
+deploy-dvm: deploy-pi
+deploy-eda405: deploy-pi
+deploy-eda446: deploy-pi
+
+deploy-pi-f7:
+ifneq ($(wildcard /usr/local/bin/stm32flash),)
+	-/usr/local/bin/stm32flash -i 20,-21,21:-20,21 /dev/ttyAMA0
+	/usr/local/bin/stm32flash -v -w bin/$(BINBIN_F7) -g 0x0 -R /dev/ttyAMA0
+
+else ifneq ($(wildcard /usr/bin/stm32flash),)
+	-/usr/bin/stm32flash -i 20,-21,21:-20,21 /dev/ttyAMA0
+	/usr/bin/stm32flash -v -w bin/$(BINBIN_F7) -g 0x0 -R /dev/ttyAMA0
+endif
+
+deploy-f7m:   deploy-pi-f7
+deploy-rpt_hat: deploy-pi-f7
+
+# Export the current git version if the index file exists, else 000...
+GitVersion.h:
+ifdef SYSTEMROOT
+	echo #define GITVERSION "0000000" > $@
+else ifdef SystemRoot
+	echo #define GITVERSION "0000000" > $@
+else
+ifneq ("$(wildcard .git/index)","")
+	echo "#define GITVERSION \"$(shell git rev-parse --short HEAD)\"" > $@
+else
+	echo "#define GITVERSION \"0000000\"" > $@
+endif
+endif
+
+flash_f4:
+	@echo "flashing firmware..."
+	st-flash write bin/$(BINBIN_F4) 0x8000000
@@ -175,7 +175,7 @@ void CNXDNTX::writeByte(uint8_t c)

 void CNXDNTX::writeSilence()
 {
-  q15_t inBuffer[4U] = {0x00U, 0x00U, 0x00U, 0x00U};
+  q15_t inBuffer[4U] = {0, 0, 0, 0};
  q15_t intBuffer[NXDN_RADIO_SYMBOL_LENGTH * 4U];
  q15_t outBuffer[NXDN_RADIO_SYMBOL_LENGTH * 4U];

@@ -78,7 +78,7 @@ void CP25TX::process()
      for (uint16_t i = 0U; i < m_txDelay; i++)
        m_poBuffer[m_poLen++] = P25_START_SYNC;
    } else {
-      uint8_t length = 0U;
+      uint8_t length;
      m_buffer.get(length);
      for (uint8_t i = 0U; i < length; i++) {
        uint8_t c = 0U;
@@ -173,7 +173,7 @@ void CP25TX::writeByte(uint8_t c)

 void CP25TX::writeSilence()
 {
-  q15_t inBuffer[4U] = {0x00U, 0x00U, 0x00U, 0x00U};
+  q15_t inBuffer[4U] = {0, 0, 0, 0};
  q15_t intBuffer[P25_RADIO_SYMBOL_LENGTH * 4U];
  q15_t outBuffer[P25_RADIO_SYMBOL_LENGTH * 4U];

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jonathan Naylor	7f339556f4	Add the ST-Micro licences.	2023-10-29 20:32:18 +00:00
Jonathan Naylor	0189520ab2	Add the LL library files and clean up some indentation.	2023-10-28 20:30:36 +01:00
Jonathan Naylor	5d2d37f44b	Remove the submodules.	2023-10-28 16:32:48 +01:00
Jonathan Naylor	5ede02212a	Remove Due, Teensy, and STM32F1xx support.	2023-10-27 16:23:49 +01:00
Jonathan Naylor	85d3086d4c	Restart the RSSI ADC conversion in the STM32 interrupt to match the signal ADC.	2023-10-10 20:06:50 +01:00
Jonathan Naylor	ccf3b7301e	Make the type correct for silence frames.	2023-10-10 20:03:01 +01:00
Jonathan Naylor	6b3a811ae7	Simplify the serial repeater code.	2023-10-05 19:49:17 +01:00
Jonathan Naylor	3e079f58ad	Add RSSI reporting to FM and AX.25	2023-08-02 17:34:52 +01:00
Jonathan Naylor	7ef0d992d9	Improve the status reporting for FM mode.	2023-01-18 14:30:02 +00:00