diff --git a/DMRTX.cpp b/DMRTX.cpp
index f204f51..a396ebb 100644
--- a/DMRTX.cpp
+++ b/DMRTX.cpp
@@ -17,6 +17,8 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#define WANT_DEBUG
+
 #include "Config.h"
 #include "Globals.h"
 #include "DMRSlotType.h"
@@ -27,10 +29,8 @@ static q15_t DMR_C4FSK_FILTER[] = {401, 104, -340, -731, -847, -553, 112, 909, 1
                                    -553, -847, -731, -340, 104, 401, 0};
 const uint16_t DMR_C4FSK_FILTER_LEN = 42U;
 
-q15_t DMR_A[] = { 640,  640,  640,  640,  640};
-q15_t DMR_B[] = { 213,  213,  213,  213,  213};
-q15_t DMR_C[] = {-213, -213, -213, -213, -213};
-q15_t DMR_D[] = {-640, -640, -640, -640, -640};
+const q15_t DMR_LEVEL3 = 640;
+const q15_t DMR_LEVEL1 = 213;
 
 // The PR FILL and Data Sync pattern.
 const uint8_t IDLE_DATA[] =
@@ -54,6 +54,10 @@ const uint8_t BIT_MASK_TABLE[] = {0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02
 
 CDMRTX::CDMRTX() :
 m_fifo(),
+m_levelA(),
+m_levelB(),
+m_levelC(),
+m_levelD(),
 m_modFilter(),
 m_modState(),
 m_state(DMRTXSTATE_IDLE),
@@ -75,6 +79,13 @@ m_count(0U)
 
   ::memcpy(m_newShortLC, EMPTY_SHORT_LC, 12U);
   ::memcpy(m_shortLC,    EMPTY_SHORT_LC, 12U);
+
+  for (uint8_t i = 0U; i < 5U; i++) {
+    m_levelA[i] =  DMR_LEVEL3;
+    m_levelB[i] =  DMR_LEVEL1;
+    m_levelC[i] = -DMR_LEVEL1;
+    m_levelD[i] = -DMR_LEVEL3;
+  }
 }
 
 void CDMRTX::process()
@@ -229,16 +240,16 @@ void CDMRTX::writeByte(uint8_t c, uint8_t control)
   for (uint8_t i = 0U; i < 4U; i++, c <<= 2, p += DMR_RADIO_SYMBOL_LENGTH) {
     switch (c & MASK) {
       case 0xC0U:
-        ::memcpy(p, DMR_A, DMR_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
+        ::memcpy(p, m_levelA, DMR_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
         break;
       case 0x80U:
-        ::memcpy(p, DMR_B, DMR_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
+        ::memcpy(p, m_levelB, DMR_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
         break;
       case 0x00U:
-        ::memcpy(p, DMR_C, DMR_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
+        ::memcpy(p, m_levelC, DMR_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
         break;
       default:
-        ::memcpy(p, DMR_D, DMR_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
+        ::memcpy(p, m_levelD, DMR_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
         break;
     }
   }
@@ -368,3 +379,37 @@ void CDMRTX::setColorCode(uint8_t colorCode)
   slotType.encode(colorCode, DT_IDLE, m_idle);
 }
 
+void CDMRTX::setLevels(int8_t percent1, int8_t percent3)
+{
+  q31_t res1 = DMR_LEVEL1 * 1000;
+  q31_t res3 = DMR_LEVEL3 * 1000;
+
+  if (percent1 > 0) {
+    for (int8_t i = 0; i < percent1; i++)
+      res1 += DMR_LEVEL1;
+  } else if (percent1 < 0) {
+    for (int8_t i = 0; i < -percent1; i++)
+      res1 -= DMR_LEVEL1;
+  }
+
+  if (percent3 > 0) {
+    for (int8_t i = 0; i < percent3; i++)
+      res3 += DMR_LEVEL3;
+  } else if (percent3 < 0) {
+    for (int8_t i = 0; i < -percent3; i++)
+      res3 -= DMR_LEVEL3;
+  }
+
+  q15_t level1 = res1 / 1000;
+  q15_t level3 = res3 / 1000;
+
+  for (uint8_t i = 0U; i < 5U; i++) {
+    m_levelA[i] =  level3;
+    m_levelB[i] =  level1;
+    m_levelC[i] = -level1;
+    m_levelD[i] = -level3;
+  }
+
+  DEBUG3("DMR, Levels 1/3", level1, level3);
+}
+
diff --git a/DMRTX.h b/DMRTX.h
index ea404d0..7cb3c0b 100644
--- a/DMRTX.h
+++ b/DMRTX.h
@@ -53,9 +53,14 @@ public:
   uint16_t getSpace2() const;
 
   void setColorCode(uint8_t colorCode);
+  void setLevels(int8_t level1, int8_t level3);
 
 private:
   CSerialRB            m_fifo[2U];
+  q15_t                m_levelA[5U];
+  q15_t                m_levelB[5U];
+  q15_t                m_levelC[5U];
+  q15_t                m_levelD[5U];
   arm_fir_instance_q15 m_modFilter;
   q15_t                m_modState[70U];    // NoTaps + BlockSize - 1, 42 + 20 - 1 plus some spare
   DMRTXSTATE           m_state;
diff --git a/DStarTX.cpp b/DStarTX.cpp
index a319651..f07ee87 100644
--- a/DStarTX.cpp
+++ b/DStarTX.cpp
@@ -16,6 +16,8 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#define WANT_DEBUG
+
 #include "Config.h"
 #include "Globals.h"
 #include "DStarTX.h"
@@ -30,8 +32,7 @@ const uint8_t FRAME_SYNC[] = {0xEAU, 0xA6U, 0x00U};
 static q15_t DSTAR_GMSK_FILTER[] = {8, 104, 760, 3158, 7421, 9866, 7421, 3158, 760, 104, 8, 0};
 const uint16_t DSTAR_GMSK_FILTER_LEN = 12U;
 
-q15_t DSTAR_1[] = { 800,  800,  800,  800,  800};
-q15_t DSTAR_0[] = {-800, -800, -800, -800, -800};
+const q15_t DSTAR_LEVEL = 800;
 
 const uint8_t BIT_MASK_TABLE[] = {0x80U, 0x40U, 0x20U, 0x10U, 0x08U, 0x04U, 0x02U, 0x01U};
 
@@ -188,6 +189,8 @@ const uint8_t DSTAR_EOT    = 0x02U;
 
 CDStarTX::CDStarTX() :
 m_buffer(),
+m_level0(),
+m_level1(),
 m_modFilter(),
 m_modState(),
 m_poBuffer(),
@@ -201,6 +204,11 @@ m_count(0U)
   m_modFilter.numTaps = DSTAR_GMSK_FILTER_LEN;
   m_modFilter.pState  = m_modState;
   m_modFilter.pCoeffs = DSTAR_GMSK_FILTER;
+
+  for (uint8_t i = 0U; i < 5U; i++) {
+    m_level0[i] = -DSTAR_LEVEL;
+    m_level1[i] =  DSTAR_LEVEL;
+  }
 }
 
 void CDStarTX::process()
@@ -417,9 +425,9 @@ void CDStarTX::writeByte(uint8_t c)
   q15_t* p = inBuffer;
   for (uint8_t i = 0U; i < 8U; i++, p += DSTAR_RADIO_BIT_LENGTH) {
     if ((c & mask) == mask)
-      ::memcpy(p, DSTAR_0, DSTAR_RADIO_BIT_LENGTH * sizeof(q15_t));
+      ::memcpy(p, m_level0, DSTAR_RADIO_BIT_LENGTH * sizeof(q15_t));
     else
-      ::memcpy(p, DSTAR_1, DSTAR_RADIO_BIT_LENGTH * sizeof(q15_t));
+      ::memcpy(p, m_level1, DSTAR_RADIO_BIT_LENGTH * sizeof(q15_t));
 
     mask <<= 1;
   }
@@ -457,3 +465,25 @@ uint16_t CDStarTX::getSpace() const
   return m_buffer.getSpace() / (DSTAR_DATA_LENGTH_BYTES + 1U);
 }
 
+void CDStarTX::setLevels(int8_t percent)
+{
+  q31_t res = DSTAR_LEVEL * 1000;
+
+  if (percent > 0) {
+    for (int8_t i = 0; i < percent; i++)
+      res += DSTAR_LEVEL;
+  } else if (percent < 0) {
+    for (int8_t i = 0; i < -percent; i++)
+      res -= DSTAR_LEVEL;
+  }
+
+  q15_t level = res / 1000;
+
+  for (uint8_t i = 0U; i < 5U; i++) {
+    m_level0[i] = -level;
+    m_level1[i] =  level;
+  }
+
+  DEBUG2("D-Star, Level", level);
+}
+
diff --git a/DStarTX.h b/DStarTX.h
index b2f72ff..c3cb177 100644
--- a/DStarTX.h
+++ b/DStarTX.h
@@ -34,11 +34,14 @@ public:
   void process();
 
   void setTXDelay(uint8_t delay);
+  void setLevels(int8_t level);
 
   uint16_t getSpace() const;
 
 private:
   CSerialRB            m_buffer;
+  q15_t                m_level0[5U];
+  q15_t                m_level1[5U];
   arm_fir_instance_q15 m_modFilter;
   q15_t                m_modState[60U];    // NoTaps + BlockSize - 1, 12 + 40 - 1 plus some spare
   uint8_t              m_poBuffer[400U];
diff --git a/SerialPort.cpp b/SerialPort.cpp
index a29fec2..e688b00 100644
--- a/SerialPort.cpp
+++ b/SerialPort.cpp
@@ -185,7 +185,7 @@ void CSerialPort::getVersion()
 
 uint8_t CSerialPort::setConfig(const uint8_t* data, uint8_t length)
 {
-  if (length < 9U)
+  if (length < 14U)
     return 4U;
 
   bool rxInvert  = (data[0U] & 0x01U) == 0x01U;
@@ -232,6 +232,14 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint8_t length)
     m_sampleInsert = false;
   }
 
+  int8_t dstarLevel = int8_t(data[9U]) - 128;
+
+  int8_t dmrLevel1 = int8_t(data[10U]) - 128;
+  int8_t dmrLevel3 = int8_t(data[11U]) - 128;
+
+  int8_t ysfLevel1 = int8_t(data[12U]) - 128;
+  int8_t ysfLevel3 = int8_t(data[13U]) - 128;
+
   m_modemState  = modemState;
 
   m_dstarEnable = dstarEnable;
@@ -246,6 +254,10 @@ uint8_t CSerialPort::setConfig(const uint8_t* data, uint8_t length)
   dmrRX.setDelay(dmrDelay);
   dmrIdleRX.setColorCode(colorCode);
 
+  dstarTX.setLevels(dstarLevel);
+  dmrTX.setLevels(dmrLevel1, dmrLevel3);
+  ysfTX.setLevels(ysfLevel1, ysfLevel3);
+
   io.setParameters(rxInvert, txInvert, pttInvert, rxLevel, txLevel);
 
   io.start();
diff --git a/YSFTX.cpp b/YSFTX.cpp
index 92984a7..3b37372 100644
--- a/YSFTX.cpp
+++ b/YSFTX.cpp
@@ -16,6 +16,8 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#define WANT_DEBUG
+
 #include "Config.h"
 #include "Globals.h"
 #include "YSFTX.h"
@@ -31,13 +33,15 @@ const uint16_t YSF_C4FSK_FILTER_LEN = 42U;
 const uint8_t YSF_START_SYNC = 0x77U;
 const uint8_t YSF_END_SYNC   = 0xFFU;
 
-q15_t YSF_A[] = { 809,  809,  809,  809,  809};
-q15_t YSF_B[] = { 269,  269,  269,  269,  269};
-q15_t YSF_C[] = {-269, -269, -269, -269, -269};
-q15_t YSF_D[] = {-809, -809, -809, -809, -809};
+const q15_t YSF_LEVEL3 = 809;
+const q15_t YSF_LEVEL1 = 269;
 
 CYSFTX::CYSFTX() :
 m_buffer(1500U),
+m_levelA(),
+m_levelB(),
+m_levelC(),
+m_levelD(),
 m_modFilter(),
 m_modState(),
 m_poBuffer(),
@@ -51,6 +55,13 @@ m_count(0U)
   m_modFilter.numTaps = YSF_C4FSK_FILTER_LEN;
   m_modFilter.pState  = m_modState;
   m_modFilter.pCoeffs = YSF_C4FSK_FILTER;
+
+  for (uint8_t i = 0U; i < 5U; i++) {
+    m_levelA[i] =  YSF_LEVEL3;
+    m_levelB[i] =  YSF_LEVEL1;
+    m_levelC[i] = -YSF_LEVEL1;
+    m_levelD[i] = -YSF_LEVEL3;
+  }
 }
 
 void CYSFTX::process()
@@ -118,16 +129,16 @@ void CYSFTX::writeByte(uint8_t c)
   for (uint8_t i = 0U; i < 4U; i++, c <<= 2, p += YSF_RADIO_SYMBOL_LENGTH) {
     switch (c & MASK) {
       case 0xC0U:
-        ::memcpy(p, YSF_A, YSF_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
+        ::memcpy(p, m_levelA, YSF_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
         break;
       case 0x80U:
-        ::memcpy(p, YSF_B, YSF_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
+        ::memcpy(p, m_levelB, YSF_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
         break;
       case 0x00U:
-        ::memcpy(p, YSF_C, YSF_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
+        ::memcpy(p, m_levelC, YSF_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
         break;
       default:
-        ::memcpy(p, YSF_D, YSF_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
+        ::memcpy(p, m_levelD, YSF_RADIO_SYMBOL_LENGTH * sizeof(q15_t));
         break;
     }
   }
@@ -165,3 +176,37 @@ uint16_t CYSFTX::getSpace() const
   return m_buffer.getSpace() / YSF_FRAME_LENGTH_BYTES;
 }
 
+void CYSFTX::setLevels(int8_t percent1, int8_t percent3)
+{
+  q31_t res1 = YSF_LEVEL1 * 1000;
+  q31_t res3 = YSF_LEVEL3 * 1000;
+
+  if (percent1 > 0) {
+    for (int8_t i = 0; i < percent1; i++)
+      res1 += YSF_LEVEL1;
+  } else if (percent1 < 0) {
+    for (int8_t i = 0; i < -percent1; i++)
+      res1 -= YSF_LEVEL1;
+  }
+
+  if (percent3 > 0) {
+    for (int8_t i = 0; i < percent3; i++)
+      res3 += YSF_LEVEL3;
+  } else if (percent3 < 0) {
+    for (int8_t i = 0; i < -percent3; i++)
+      res3 -= YSF_LEVEL3;
+  }
+
+  q15_t level1 = res1 / 1000;
+  q15_t level3 = res3 / 1000;
+
+  for (uint8_t i = 0U; i < 5U; i++) {
+    m_levelA[i] =  level3;
+    m_levelB[i] =  level1;
+    m_levelC[i] = -level1;
+    m_levelD[i] = -level3;
+  }
+
+  DEBUG3("YSF, Levels 1/3", level1, level3);
+}
+
diff --git a/YSFTX.h b/YSFTX.h
index 9235a9c..9ae8cef 100644
--- a/YSFTX.h
+++ b/YSFTX.h
@@ -32,11 +32,16 @@ public:
   void process();
 
   void setTXDelay(uint8_t delay);
+  void setLevels(int8_t level1, int8_t level3);
 
   uint16_t getSpace() const;
 
 private:
   CSerialRB            m_buffer;
+  q15_t                m_levelA[5U];
+  q15_t                m_levelB[5U];
+  q15_t                m_levelC[5U];
+  q15_t                m_levelD[5U];
   arm_fir_instance_q15 m_modFilter;
   q15_t                m_modState[70U];    // NoTaps + BlockSize - 1, 42 + 20 - 1 plus some spare
   uint8_t              m_poBuffer[720U];