From 825cc683397269375122b15d9cf8a7f73078f58b Mon Sep 17 00:00:00 2001
From: Sjef Verhoeven PE5PVB <pe5pvb@het-bar.net>
Date: Fri, 2 Jun 2023 23:09:17 +0200
Subject: [PATCH] API update, stepsize update and RDS fix

Updated API.
Added stepsize 10MHz (FM) / 1MHz (AM)
Make RDS more sensitive.
---
 TEF6686_ESP32.ino                  | 296 +++++++++++--------
 src/TEF6686.cpp                    | 437 ++++++++++++++++++++---------
 src/TEF6686.h                      | 100 ++++---
 src/Tuner_Api.cpp                  | 106 -------
 src/Tuner_Api.h                    |   7 -
 src/Tuner_Drv_Lithio.cpp           | 210 ++++++++------
 src/Tuner_Drv_Lithio.h             | 142 ++++++----
 src/Tuner_Interface.cpp            | 109 +++----
 src/Tuner_Patch_Lithio_V101_p119.h |   6 +-
 src/Tuner_Patch_Lithio_V102_p224.h |   6 +-
 src/Tuner_Patch_Lithio_V205_p512.h |  26 +-
 11 files changed, 808 insertions(+), 637 deletions(-)
 delete mode 100644 src/Tuner_Api.cpp
 delete mode 100644 src/Tuner_Api.h

diff --git a/TEF6686_ESP32.ino b/TEF6686_ESP32.ino
index 320d716..c0e0da2 100644
--- a/TEF6686_ESP32.ino
+++ b/TEF6686_ESP32.ino
@@ -373,18 +373,10 @@ void setup() {
   btStop();
   Serial.begin(115200);
 
-  if (iMSset == 1 && EQset == 1) {
-    iMSEQ = 2;
-  }
-  if (iMSset == 0 && EQset == 1) {
-    iMSEQ = 3;
-  }
-  if (iMSset == 1 && EQset == 0) {
-    iMSEQ = 4;
-  }
-  if (iMSset == 0 && EQset == 0) {
-    iMSEQ = 1;
-  }
+  if (iMSset == 1 && EQset == 1) iMSEQ = 2;
+  if (iMSset == 0 && EQset == 1) iMSEQ = 3;
+  if (iMSset == 1 && EQset == 0) iMSEQ = 4;
+  if (iMSset == 0 && EQset == 0) iMSEQ = 1;
 
   tft.init();
 
@@ -598,49 +590,32 @@ void loop() {
 
       if (millis() >= lowsignaltimer + 300) {
         lowsignaltimer = millis();
-        if (band == 0) radio.getStatus(SStatus, USN, WAM, OStatus, BW, MStatus); else radio.getStatus_AM(SStatus, USN, WAM, OStatus, BW, MStatus);
+        if (band == 0) radio.getStatus(SStatus, USN, WAM, OStatus, BW, MStatus); else radio.getStatusAM(SStatus, USN, WAM, OStatus, BW, MStatus);
         if (screenmute == true) readRds();
-        if (menu == false) doSquelch();
+        if (menu == false) {
+          doSquelch();
+          GetData();
+        }
       }
 
     } else {
-      if (band == 0) radio.getStatus(SStatus, USN, WAM, OStatus, BW, MStatus); else radio.getStatus_AM(SStatus, USN, WAM, OStatus, BW, MStatus);
+      if (band == 0) radio.getStatus(SStatus, USN, WAM, OStatus, BW, MStatus); else radio.getStatusAM(SStatus, USN, WAM, OStatus, BW, MStatus);
       if (menu == false) {
         doSquelch();
         readRds();
-        if (screenmute == false) {
-          ShowModLevel();
-        }
-      }
-    }
-
-    if (menu == false) {
-      if (screenmute == false) {
-        if (band == 0) {
-          showPI();
-          showPTY();
-          showCT();
-          showPS();
-          showRadioText();
-          showPS();
-          ShowStereoStatus();
-        }
-        ShowOffset();
-        ShowSignalLevel();
-        ShowBW();
+        GetData();
+        if (screenmute == false) ShowModLevel();
       }
     }
 
     XDRGTKRoutine();
 
-    if (menu == true && menuopen == true && menuoption == 110)
-    {
-      if (band == 0) radio.getStatus(SStatus, USN, WAM, OStatus, BW, MStatus); else radio.getStatus_AM(SStatus, USN, WAM, OStatus, BW, MStatus);
+    if (menu == true && menuopen == true && menuoption == 110) {
+      if (band == 0) radio.getStatus(SStatus, USN, WAM, OStatus, BW, MStatus); else radio.getStatusAM(SStatus, USN, WAM, OStatus, BW, MStatus);
       if (millis() >= lowsignaltimer + 500 || change2 == true) {
         lowsignaltimer = millis();
         change2 = false;
-        if (SStatus > SStatusold || SStatus < SStatusold)
-        {
+        if (SStatus > SStatusold || SStatus < SStatusold) {
           String count = String(SStatus / 10, DEC);
           if (screenmute == false) {
             tft.setTextColor(TFT_BLACK);
@@ -656,8 +631,7 @@ void loop() {
             tft.setTextFont(6);
             tft.print(SStatusold / 10);
             tft.print(".");
-            if (SStatusold < 0)
-            {
+            if (SStatusold < 0) {
               String negative = String (SStatusold % 10, DEC);
               if (SStatusold % 10 == 0) tft.print("0");  else tft.print(negative[1]);
             } else {
@@ -677,8 +651,7 @@ void loop() {
             tft.setTextFont(6);
             tft.print(SStatus / 10);
             tft.print(".");
-            if (SStatus < 0)
-            {
+            if (SStatus < 0) {
               String negative = String (SStatus % 10, DEC);
               if (SStatus % 10 == 0) tft.print("0"); else tft.print(negative[1]);
             } else {
@@ -703,8 +676,8 @@ void loop() {
     if (change > 200 && store == true) {
       detachInterrupt(digitalPinToInterrupt(ROTARY_PIN_A));
       detachInterrupt(digitalPinToInterrupt(ROTARY_PIN_B));
-      EEPROM.writeUInt(0, radio.getFrequency());
-      EEPROM.writeUInt(47, radio.getFrequency_AM());
+      EEPROM.writeUInt(0, frequency);
+      EEPROM.writeUInt(47, frequency_AM);
       EEPROM.writeByte(46, band);
       EEPROM.commit();
       store = false;
@@ -714,6 +687,23 @@ void loop() {
   }
 }
 
+void GetData() {
+  if (screenmute == false) {
+    if (band == 0) {
+      showPI();
+      showPTY();
+      showCT();
+      showPS();
+      showRadioText();
+      showPS();
+      ShowStereoStatus();
+    }
+    ShowOffset();
+    ShowSignalLevel();
+    ShowBW();
+  }
+
+}
 void PWRButtonPress() {
   if (menu == false) {
     unsigned long counterold = millis();
@@ -747,8 +737,8 @@ void PWRButtonPress() {
 }
 
 void StoreFrequency() {
-  EEPROM.writeUInt(0, radio.getFrequency());
-  EEPROM.writeUInt(47, radio.getFrequency_AM());
+  EEPROM.writeUInt(0, frequency);
+  EEPROM.writeUInt(47, frequency_AM);
   EEPROM.writeByte(46, band);
   EEPROM.commit();
 }
@@ -759,11 +749,10 @@ void SelectBand() {
     tunemode = false;
     BWreset = true;
     BWset = 2;
-    if (radio.getFrequency_AM() > 0) frequency_AM = radio.getFrequency_AM();
-    radio.setFrequency_AM(frequency_AM);
+    radio.SetFreqAM(frequency_AM);
     freqold = frequency_AM;
     doBW;
-    radio.getStatus_AM(SStatus, USN, WAM, OStatus, BW, MStatus);
+    radio.getStatusAM(SStatus, USN, WAM, OStatus, BW, MStatus);
     if (screenmute == false) BuildDisplay();
     tft.drawString("PI:", 216, 195, 2);
     tft.drawString("PS:", 6, 195, 2);
@@ -781,7 +770,7 @@ void SelectBand() {
     BWset = 0;
     radio.power(0);
     delay(50);
-    radio.setFrequency(frequency, LowEdgeSet, HighEdgeSet, fullsearchrds);
+    radio.SetFreq(frequency);
     freqold = frequency_AM;
     doBW;
     radio.getStatus(SStatus, USN, WAM, OStatus, BW, MStatus);
@@ -803,6 +792,7 @@ void BWButtonPress() {
       doStereoToggle();
     }
   }
+
   while (digitalRead(BWBUTTON) == LOW) delay(50);
   delay(100);
 }
@@ -892,32 +882,39 @@ void ShowStepSize() {
   tft.fillRect(224, 38, 15, 4, TFT_GREYOUT);
   tft.fillRect(193, 38, 15, 4, TFT_GREYOUT);
   if (band == 0) tft.fillRect(148, 38, 15, 4, TFT_GREYOUT); else tft.fillRect(162, 38, 15, 4, TFT_GREYOUT);
+  if (band == 0) tft.fillRect(116, 38, 15, 4, TFT_GREYOUT); else tft.fillRect(128, 38, 15, 4, TFT_GREYOUT);
   if (stepsize == 1) tft.fillRect(224, 38, 15, 4, TFT_GREEN);
   if (stepsize == 2) tft.fillRect(193, 38, 15, 4, TFT_GREEN);
   if (stepsize == 3) {
     if (band == 0) tft.fillRect(148, 38, 15, 4, TFT_GREEN); else tft.fillRect(162, 38, 15, 4, TFT_GREEN);
   }
+  if (stepsize == 4) {
+    if (band == 0) tft.fillRect(116, 38, 15, 4, TFT_GREEN); else tft.fillRect(128, 38, 15, 4, TFT_GREEN);
+  }
 }
 
 void RoundStep() {
   if (band == 0) {
-    int freq = radio.getFrequency();
+    unsigned int freq = frequency;
     if (freq % 10 < 3) {
-      radio.setFrequency(freq - (freq % 10 - 5) - 5, LowEdgeSet, HighEdgeSet, fullsearchrds);
+      frequency = (freq - freq % 10);
     }
     else if (freq % 10 > 2 && freq % 10 < 8) {
-      radio.setFrequency(freq - (freq % 10 - 5) , LowEdgeSet, HighEdgeSet, fullsearchrds);
+      frequency = (freq - (freq % 10 - 5));
     }
     else if (freq % 10 > 7) {
-      radio.setFrequency(freq - (freq % 10 - 5) + 5, LowEdgeSet, HighEdgeSet, fullsearchrds);
+      frequency = (freq - (freq % 10) + 10);
     }
-  } else {
-    int freq = radio.getFrequency_AM();
-    if (freq < 2000) radio.setFrequency_AM((freq / 9) * 9); else radio.setFrequency_AM((freq / 5) * 5);
+    radio.SetFreq(frequency);
+  }
+  if (band == 1) {
+    unsigned int freq = frequency_AM / 9;
+    frequency_AM = freq * 9;
+    radio.SetFreqAM(frequency_AM);
   }
   while (digitalRead(ROTARY_BUTTON) == LOW) delay(50);
 
-  if (band == 0) EEPROM.writeUInt(0, radio.getFrequency()); else EEPROM.writeUInt(47, radio.getFrequency_AM());
+  if (band == 0) EEPROM.writeUInt(0, frequency); else EEPROM.writeUInt(47, frequency_AM);
   EEPROM.commit();
 }
 
@@ -931,7 +928,7 @@ void ButtonPress() {
     if (counter - counterold < 1000) {
       if (tunemode == false) {
         stepsize++;
-        if (stepsize > 3) stepsize = 0;
+        if (stepsize > 4) stepsize = 0;
 
         if (screenmute == false) ShowStepSize();
 
@@ -1084,7 +1081,7 @@ void KeyUp() {
       seek = true;
       Seek(direction);
     } else {
-      if (band == 0) frequency = radio.tuneUp(stepsize, LowEdgeSet, HighEdgeSet, fullsearchrds); else frequency_AM = radio.tuneUp_AM(stepsize);
+      TuneUp();
     }
       if (USBstatus == true) if (band == 0) Serial.println("T" + String(frequency * 10)); else Serial.println("T" + String(frequency_AM));
     radio.clearRDS(fullsearchrds);
@@ -1223,7 +1220,7 @@ void KeyDown() {
       seek = true;
       Seek(direction);
     } else {
-      if (band == 0) frequency = radio.tuneDown(stepsize, LowEdgeSet, HighEdgeSet, fullsearchrds); else frequency_AM = radio.tuneDown_AM(stepsize);
+      TuneDown();
     }
       if (USBstatus == true) if (band == 0) Serial.println("T" + String(frequency * 10)); else Serial.println("T" + String(frequency_AM));
     radio.clearRDS(fullsearchrds);
@@ -1358,8 +1355,6 @@ void KeyDown() {
   }
 }
 
-
-
 void readRds() {
   if (band == 0) {
     RDSstatus = radio.readRDS();
@@ -1387,6 +1382,7 @@ void readRds() {
       Serial.print ("P");
       Serial.print (String(((radio.rds.rdsA >> 8) >> 4) & 0xF, HEX) + String((radio.rds.rdsA >> 8) & 0xF, HEX));
       Serial.print (String(((radio.rds.rdsA) >> 4) & 0xF, HEX) + String((radio.rds.rdsA) & 0xF, HEX));
+      if (radio.rds.correct == false) Serial.print("?");
       Serial.print ("\n");
 
       XDRGTKRDS = "R";
@@ -1632,8 +1628,8 @@ void BuildDisplay() {
 void ShowFreq(int mode) {
   if (setupmode == false) {
     if (band == 1) {
-      if (freqold < 2000 && radio.getFrequency_AM() >= 2000 && stepsize == 0) if (radio.getFrequency_AM() != 27000 && freqold != 144) radio.setFrequency_AM(2000);
-      if (freqold >= 2000 && radio.getFrequency_AM() < 2000 && stepsize == 0) if (radio.getFrequency_AM() != 144 && freqold != 27000) radio.setFrequency_AM(1998);
+      if (freqold < 2000 && frequency_AM >= 2000 && stepsize == 0) if (frequency_AM != 27000 && freqold != 144) radio.SetFreqAM(2000);
+      if (freqold >= 2000 && frequency_AM < 2000 && stepsize == 0) if (frequency_AM != 144 && freqold != 27000) radio.SetFreqAM(1998);
     }
   }
 
@@ -1641,7 +1637,7 @@ void ShowFreq(int mode) {
     detachInterrupt(digitalPinToInterrupt(ROTARY_PIN_A));
     detachInterrupt(digitalPinToInterrupt(ROTARY_PIN_B));
     if (band == 1) {
-      unsigned int freq = radio.getFrequency_AM();
+      unsigned int freq = frequency_AM;
       String count = String(freq, DEC);
       if (count.length() != freqoldcount || mode != 0) {
         tft.setTextColor(TFT_BLACK);
@@ -1652,7 +1648,7 @@ void ShowFreq(int mode) {
       freqold = freq;
       freqoldcount = count.length();
     } else {
-      unsigned int freq = radio.getFrequency() + ConverterSet * 100;
+      unsigned int freq = frequency + ConverterSet * 100;
       String count = String(freq / 100, DEC);
       if (count.length() != freqoldcount || mode != 0) {
         tft.setTextColor(TFT_BLACK);
@@ -1661,9 +1657,11 @@ void ShowFreq(int mode) {
         if (freqoldcount >= 4) tft.setCursor (44, 45);
         tft.setTextFont(7);
         tft.print(freqold / 100);
-        tft.print(".");
-        if (freqold % 100 < 10) tft.print("0");
-        tft.print(freqold % 100);
+        if (band == 0) {
+          tft.print(".");
+          if (freqold % 100 < 10) tft.print("0");
+          tft.print(freqold % 100);
+        }
       }
 
       tft.setTextColor(TFT_YELLOW, TFT_BLACK);
@@ -1721,10 +1719,8 @@ void ShowSignalLevel() {
   int16_t smeter = 0;
   int16_t segments;
 
-  if (SStatus > 0)
-  {
-    if (SStatus < 1000)
-    {
+  if (SStatus > 0) {
+    if (SStatus < 1000) {
       sval = 51 * ((pow(10, (((float)SStatus) / 1000))) - 1);
       smeter = int16_t(sval);
     } else {
@@ -1738,8 +1734,7 @@ void ShowSignalLevel() {
 
   if (menu == false) analogWrite(SMETERPIN, smeter);
 
-  if (SStatus > (SStatusold + 3) || SStatus < (SStatusold - 3))
-  {
+  if (SStatus > (SStatusold + 3) || SStatus < (SStatusold - 3)) {
     if (SStatus > 1200) SStatus = 1200;
     if (SStatus < -400) SStatus = -400;
     String count = String(abs(SStatus / 10), DEC);
@@ -1759,8 +1754,7 @@ void ShowSignalLevel() {
     tft.setCursor (294, 110);
     tft.setTextFont(4);
     tft.print(".");
-    if (SStatus < 0)
-    {
+    if (SStatus < 0) {
       String negative = String (SStatus % 10, DEC);
       if (SStatus % 10 == 0) tft.print("0"); else tft.print(negative[1]);
     } else {
@@ -1780,8 +1774,7 @@ void ShowSignalLevel() {
 
 void ShowRDSLogo(bool RDSstatus) {
   if (screenmute == false) {
-    if (RDSstatus != RDSstatusold)
-    {
+    if (RDSstatus != RDSstatusold) {
       if (RDSstatus == true) tft.drawBitmap(110, 5, RDSLogo, 67, 22, TFT_SKYBLUE); else tft.drawBitmap(110, 5, RDSLogo, 67, 22, TFT_GREYOUT);
       RDSstatusold = RDSstatus;
     }
@@ -1789,13 +1782,10 @@ void ShowRDSLogo(bool RDSstatus) {
 }
 
 void ShowStereoStatus() {
-  if (StereoToggle == true)
-  {
+  if (StereoToggle == true) {
     if (band == 0) Stereostatus = radio.getStereoStatus(); else Stereostatus = 0;
-    if (Stereostatus != Stereostatusold)
-    {
-      if (Stereostatus == true && screenmute == false)
-      {
+    if (Stereostatus != Stereostatusold) {
+      if (Stereostatus == true && screenmute == false) {
         tft.drawCircle(81, 15, 10, TFT_RED);
         tft.drawCircle(81, 15, 9, TFT_RED);
         tft.drawCircle(91, 15, 10, TFT_RED);
@@ -1934,8 +1924,7 @@ void ShowModLevel() {
       color = TFT_GREEN;
       if (segments > 8) color = TFT_ORANGE;
       if (segments > 9) color = TFT_RED;
-      if (MStatus > (segments + 1) * 10)
-      {
+      if (MStatus > (segments + 1) * 10) {
         hold = segments;
         tft.fillRect(20 + segments * 14, 139, 12, 8, color);
       } else {
@@ -2239,8 +2228,7 @@ void ShowUSBstatus() {
 }
 
 void XDRGTKRoutine() {
-  if (Serial.available() > 0)
-  {
+  if (Serial.available()) {
     buff[buff_pos] = Serial.read();
     if (buff[buff_pos] != '\n' && buff_pos != 16 - 1) {
       buff_pos++;
@@ -2248,8 +2236,7 @@ void XDRGTKRoutine() {
       buff[buff_pos] = 0;
       buff_pos = 0;
 
-      switch (buff[0])
-      {
+      switch (buff[0]) {
         case 'x':
           Serial.println("OK");
           if (band != 0) {
@@ -2370,7 +2357,7 @@ void XDRGTKRoutine() {
               band = 1;
               SelectBand();
             } else {
-              radio.setFrequency_AM(frequency_AM);
+              radio.SetFreqAM(frequency_AM);
             }
             Serial.print("M1\n");
           } else if (freqtemp > 64999 && freqtemp < 108001) {
@@ -2380,7 +2367,7 @@ void XDRGTKRoutine() {
               SelectBand();
               Serial.print("M0\n");
             } else {
-              radio.setFrequency(frequency, 65, 108, fullsearchrds);
+              radio.SetFreq(frequency);
             }
           }
           if (band == 0) Serial.print("T" + String(frequency * 10) + "\n"); else Serial.print("T" + String(frequency_AM) + "\n");
@@ -2390,22 +2377,17 @@ void XDRGTKRoutine() {
           break;
 
         case 'S':
-          if (buff[1] == 'a')
-          {
+          if (buff[1] == 'a') {
             scanner_start = (atol(buff + 2) + 5) / 10;
-          } else if (buff[1] == 'b')
-          {
+          } else if (buff[1] == 'b') {
             scanner_end = (atol(buff + 2) + 5) / 10;
-          } else if (buff[1] == 'c')
-          {
+          } else if (buff[1] == 'c') {
             scanner_step = (atol(buff + 2) + 5) / 10;
-          } else if (buff[1] == 'f')
-          {
+          } else if (buff[1] == 'f') {
             scanner_filter = atol(buff + 2);
-          } else if (scanner_start > 0 && scanner_end > 0 && scanner_step > 0 && scanner_filter >= 0)
-          {
-            frequencyold = radio.getFrequency();
-            radio.setFrequency(scanner_start, 65, 108, fullsearchrds);
+          } else if (scanner_start > 0 && scanner_end > 0 && scanner_step > 0 && scanner_filter >= 0) {
+            frequencyold = frequency;
+            radio.SetFreq(scanner_start);
             Serial.print('U');
             if (scanner_filter < 0) {
               BWset = 0;
@@ -2451,17 +2433,12 @@ void XDRGTKRoutine() {
               tft.print("SCANNING...");
             }
             frequencyold = frequency / 10;
-            for (freq_scan = scanner_start; freq_scan <= scanner_end; freq_scan += scanner_step)
-            {
-              radio.setFrequency(freq_scan, 65, 108, fullsearchrds);
+            for (freq_scan = scanner_start; freq_scan <= scanner_end; freq_scan += scanner_step) {
+              radio.SetFreq(freq_scan);
               Serial.print(freq_scan * 10, DEC);
               Serial.print('=');
               delay(10);
-              if (band == 0) {
-                radio.getStatus(SStatus, USN, WAM, OStatus, BW, MStatus);
-              } else {
-                radio.getStatus_AM(SStatus, USN, WAM, OStatus, BW, MStatus);
-              }
+              if (band == 0) radio.getStatus(SStatus, USN, WAM, OStatus, BW, MStatus); else  radio.getStatusAM(SStatus, USN, WAM, OStatus, BW, MStatus);
               Serial.print((SStatus / 10) + 10, DEC);
               Serial.print(',');
             }
@@ -2472,7 +2449,7 @@ void XDRGTKRoutine() {
               tft.setCursor (90, 60);
               tft.print("SCANNING...");
             }
-            radio.setFrequency(frequencyold, 65, 108, fullsearchrds);
+            radio.SetFreq(frequencyold);
             if (screenmute == false) ShowFreq(0);
             radio.setFMABandw();
           }
@@ -2545,10 +2522,93 @@ void XDRGTKRoutine() {
   }
 }
 
+void TuneUp() {
+  unsigned int temp;
+  if (stepsize == 0) {
+    if (band == 1) {
+      if (frequency_AM < 1998) {
+        temp = 9;
+        frequency_AM = (frequency_AM / 9) * 9;
+      } else {
+        temp = 5;
+        frequency_AM = (frequency_AM / 5) * 5;
+      }
+    } else {
+      temp = 5;
+    }
+  }
+  if (stepsize == 1) temp = 1;
+  if (stepsize == 2) temp = 10;
+  if (stepsize == 3) temp = 100;
+  if (stepsize == 4) temp = 1000;
+
+  if (band == 0) {
+    frequency += temp;
+    if (frequency >= (HighEdgeSet * 100) + 1) {
+      frequency = LowEdgeSet * 100;
+    }
+    radio.SetFreq(frequency);
+  }
+
+  if (band == 1) {
+    frequency_AM += temp;
+    if (frequency_AM > 27000) {
+      frequency_AM = 144;
+    }
+    radio.SetFreqAM(frequency_AM);
+  }
+  radio.clearRDS(fullsearchrds);
+}
+
+void TuneDown() {
+  unsigned int temp;
+  if (stepsize == 0) {
+    if (band == 1) {
+      if (frequency_AM <= 2000) {
+        if (frequency_AM == 2000) {
+          frequency_AM = 1998;
+          temp = 0;
+        } else {
+          temp = 9;
+          frequency_AM = (frequency_AM / 9) * 9;
+        }
+      } else {
+        temp = 5;
+        frequency_AM = (frequency_AM / 5) * 5;
+      }
+    } else {
+      temp = 5;
+    }
+  }
+  if (stepsize == 1) temp = 1;
+  if (stepsize == 2) temp = 10;
+  if (stepsize == 3) temp = 100;
+  if (stepsize == 4) temp = 1000;
+
+  if (band == 0) {
+    frequency -= temp;
+    if (frequency < LowEdgeSet * 100) frequency = HighEdgeSet * 100;
+    radio.SetFreq(frequency);
+  }
+
+  if (band == 1) {
+    if (temp == 1000 && frequency_AM <= 1440)
+    {
+      frequency_AM = 27000;
+    } else {
+      frequency_AM -= temp;
+      if (frequency_AM < 144) frequency_AM = 27000;
+    }
+    radio.SetFreqAM(frequency_AM);
+  }
+  radio.clearRDS(fullsearchrds);
+}
+
+
 void Seek(bool mode) {
   if (band == 0) {
     radio.setMute();
-    if (mode == false) frequency = radio.tuneDown(stepsize, LowEdgeSet, HighEdgeSet, fullsearchrds); else frequency = radio.tuneUp(stepsize, LowEdgeSet, HighEdgeSet, fullsearchrds);
+    if (mode == false) TuneDown(); else TuneUp();
     delay(50);
     ShowFreq(0);
       if (USBstatus == true) if (band == 0) Serial.print("T" + String(frequency * 10) + "\n"); else Serial.print("T" + String(frequency_AM) + "\n");
diff --git a/src/TEF6686.cpp b/src/TEF6686.cpp
index a386817..106e3bd 100644
--- a/src/TEF6686.cpp
+++ b/src/TEF6686.cpp
@@ -40,27 +40,16 @@ const char* const PTY[]
 void TEF6686::init(byte TEF) {
   uint8_t bootstatus;
   Tuner_I2C_Init();
-  getBootStatus(bootstatus);
+  devTEF_APPL_Get_Operation_Status(&bootstatus);
   if (bootstatus == 0) {
     Tuner_Patch(TEF);
     delay(50);
-    if (digitalRead(15) == LOW) {
-      Tuner_Init9216();
-    } else {
-      Tuner_Init4000();
-    }
+    if (digitalRead(15) == LOW) Tuner_Init9216(); else Tuner_Init4000();
     power(1);
     Tuner_Init();
   }
 }
 
-void TEF6686::power(uint8_t mode) {
-  devTEF_APPL_Set_OperationMode(mode);
-  if (mode == 0) {
-    devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 7, 1, 10000);
-  }
-}
-
 bool TEF6686::getIdentification(uint16_t &device, uint16_t &hw_version, uint16_t &sw_version) {
   bool result = devTEF_Radio_Get_Identification(&device, &hw_version, &sw_version);
   return device;
@@ -68,70 +57,75 @@ bool TEF6686::getIdentification(uint16_t &device, uint16_t &hw_version, uint16_t
   return sw_version;
 }
 
-void TEF6686::setFrequency(uint16_t frequency, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds) {
-  Radio_SetFreq(frequency, LowEdge, HighEdge, fullsearchrds);
+void TEF6686::power(bool mode) {
+  devTEF_APPL_Set_OperationMode(mode);
+  if (mode == 0) devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 7, 1, 10000);
 }
 
-void TEF6686::setFrequency_AM(uint16_t frequency) {
-  Radio_SetFreq_AM(frequency);
+void TEF6686::SetFreq(uint16_t frequency) {
+  devTEF_Radio_Tune_To(frequency);
 }
 
-uint16_t TEF6686::getFrequency() {
-  return Radio_GetCurrentFreq();
+void TEF6686::SetFreqAM(uint16_t frequency) {
+  devTEF_Radio_Tune_AM (frequency);
 }
 
-uint16_t TEF6686::getFrequency_AM() {
-  return Radio_GetCurrentFreq_AM();
-}
-
-void TEF6686::setOffset(int16_t offset) {
+void TEF6686::setOffset(int8_t offset) {
   devTEF_Radio_Set_LevelOffset(offset * 10);
 }
 
 void TEF6686::setFMBandw(uint16_t bandwidth) {
   devTEF_Radio_Set_Bandwidth(0, bandwidth * 10, 1000, 1000);
 }
+
+void TEF6686::setAMBandw(uint16_t bandwidth) {
+  devTEF_Radio_Set_BandwidthAM(0, bandwidth * 10, 1000, 1000);
+}
+
+void TEF6686::setAMCoChannel(uint16_t start) {
+  devTEF_Radio_Set_CoChannel_AM(start * 10);
+}
+
+void TEF6686::setSoftmuteAM(uint8_t mode) {
+  devTEF_Radio_Set_Softmute_Max_AM(mode);
+}
+
+void TEF6686::setSoftmuteFM(uint8_t mode) {
+  devTEF_Radio_Set_Softmute_Max_FM(mode);
+}
+
+void TEF6686::setAMNoiseBlanker(uint16_t start) {
+  if (start == 0) devTEF_Radio_Set_Noiseblanker_AM(0, 1000); else devTEF_Radio_Set_Noiseblanker_AM(1, (start * 10) + 500);
+}
+
+void TEF6686::setAMAttenuation(uint16_t start) {
+  devTEF_Radio_Set_Attenuator_AM(start * 10);
+}
+
 void TEF6686::setFMABandw() {
   devTEF_Radio_Set_Bandwidth(1, 3110, 1000, 1000);
 }
 
-void TEF6686::setAMBandw(uint16_t bandwidth) {
-  devTEF_Radio_Set_Bandwidth_AM(0, bandwidth * 10, 1000, 1000);
-}
-
-void TEF6686::setiMS(uint16_t mph) {
+void TEF6686::setiMS(bool mph) {
   devTEF_Radio_Set_MphSuppression(mph);
 }
 
-void TEF6686::setEQ(uint16_t eq) {
+void TEF6686::setEQ(bool eq) {
   devTEF_Radio_Set_ChannelEqualizer(eq);
 }
 
 bool TEF6686::getStereoStatus() {
-  return Radio_CheckStereo();
+  uint16_t status;
+  bool stereo = 0;
+  if (1 == devTEF_Radio_Get_Stereo_Status(&status)) stereo = ((status >> 15) & 1) ? 1 : 0;
+  return stereo;
 }
 
-void TEF6686::setMono(uint8_t mono) {
+void TEF6686::setMono(bool mono) {
   devTEF_Radio_Set_Stereo_Min(mono);
 }
 
-uint16_t TEF6686::tuneUp(uint8_t stepsize, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds) {
-  return tune(1, stepsize, LowEdge, HighEdge, fullsearchrds);
-}
-
-uint16_t TEF6686::tuneDown(uint8_t stepsize, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds) {
-  return tune(0, stepsize, LowEdge, HighEdge, fullsearchrds);
-}
-
-uint16_t TEF6686::tuneUp_AM(uint8_t stepsize) {
-  return tune_AM(1, stepsize);
-}
-
-uint16_t TEF6686::tuneDown_AM(uint8_t stepsize) {
-  return tune_AM(0, stepsize);
-}
-
-void TEF6686::setVolume(int16_t volume) {
+void TEF6686::setVolume(int8_t volume) {
   devTEF_Audio_Set_Volume(volume);
 }
 
@@ -143,34 +137,47 @@ void TEF6686::setUnMute() {
   devTEF_Audio_Set_Mute(0);
 }
 
-void TEF6686::setAGC(uint8_t start) {
-  if (start == 0) {
-    devTEF_Radio_Set_RFAGC(920);
-  }
-  if (start == 1) {
-    devTEF_Radio_Set_RFAGC(900);
-  }
-  if (start == 2) {
-    devTEF_Radio_Set_RFAGC(870);
-  }
-  if (start == 3) {
-    devTEF_Radio_Set_RFAGC(840);
-  }
+void TEF6686::setAGC(uint8_t agc) {
+  if (agc == 0) devTEF_Radio_Set_RFAGC(920);
+  if (agc == 1) devTEF_Radio_Set_RFAGC(900);
+  if (agc == 2) devTEF_Radio_Set_RFAGC(870);
+  if (agc == 3) devTEF_Radio_Set_RFAGC(840);
 }
 
 void TEF6686::setDeemphasis(uint8_t timeconstant) {
-  if (timeconstant == 0) {
-    devTEF_Radio_Set_Deemphasis(500);
-  }
-  if (timeconstant == 1) {
-    devTEF_Radio_Set_Deemphasis(750);
-  }
-  if (timeconstant == 2) {
-    devTEF_Radio_Set_Deemphasis(0);
-  }
+  if (timeconstant == 1) devTEF_Radio_Set_Deemphasis(500);
+  if (timeconstant == 2) devTEF_Radio_Set_Deemphasis(750);
+  if (timeconstant == 3) devTEF_Radio_Set_Deemphasis(0);
 }
 
-void TEF6686::setStereoLevel(uint16_t start) {
+void TEF6686::setAudio(uint8_t audio) {
+  if (audio == 1) devTEF_Radio_Specials(0);
+  if (audio == 2) devTEF_Radio_Specials(1);
+}
+
+void TEF6686::setFMSI(uint8_t mode) {
+  if (mode == 1) devTEF_APPL_Set_StereoImprovement(0);
+  if (mode == 2) devTEF_APPL_Set_StereoImprovement(1);
+}
+
+void TEF6686::setFMSI_Time(uint16_t attack, uint16_t decay) {
+  devTEF_APPL_Set_StereoBandBlend_Time(attack, decay);
+}
+
+void TEF6686::setFMSI_Gain(uint16_t band1, uint16_t band2, uint16_t band3, uint16_t band4) {
+  devTEF_APPL_Set_StereoBandBlend_Gain(band1 * 10, band2 * 10, band3 * 10, band4 * 10);
+}
+
+void TEF6686::setFMSI_Bias(int16_t band1, int16_t band2, int16_t band3, int16_t band4) {
+  devTEF_APPL_Set_StereoBandBlend_Bias(band1 - 250, band2 - 250, band3 - 250, band4 - 250);
+}
+
+
+void TEF6686::setNoiseBlanker(uint16_t start) {
+  if (start == 0) devTEF_Radio_Set_NoisBlanker(0, 1000); else devTEF_Radio_Set_NoisBlanker(1, (start * 10) + 500);
+}
+
+void TEF6686::setStereoLevel(uint8_t start) {
   if (start == 0) {
     devTEF_Radio_Set_Stereo_Level(0, start * 10, 60);
     devTEF_Radio_Set_Stereo_Noise(0, 240, 200);
@@ -182,7 +189,7 @@ void TEF6686::setStereoLevel(uint16_t start) {
   }
 }
 
-void TEF6686::setHighCutOffset(uint16_t start) {
+void TEF6686::setHighCutOffset(uint8_t start) {
   if (start == 0) {
     devTEF_Radio_Set_Highcut_Level(0, start * 10, 300);
     devTEF_Radio_Set_Highcut_Noise(0, 360, 300);
@@ -198,13 +205,35 @@ void TEF6686::setHighCutLevel(uint16_t limit) {
   devTEF_Radio_Set_Highcut_Max(1, limit * 100);
 }
 
-bool TEF6686::getBootStatus(uint8_t &bootstatus) {
-  uint8_t result = devTEF_APPL_Get_Operation_Status(&bootstatus);
-  return bootstatus;
+void TEF6686::setStHiBlendLevel(uint16_t limit) {
+  devTEF_Radio_Set_StHiBlend_Max(1, limit * 100);
+}
+
+void TEF6686::setStHiBlendOffset(uint8_t start) {
+  if (start == 0) {
+    devTEF_Radio_Set_StHiBlend_Level(0, start * 10, 300);
+    devTEF_Radio_Set_StHiBlend_Noise(0, 360, 300);
+    devTEF_Radio_Set_StHiBlend_Mph(0, 360, 300);
+  } else {
+    devTEF_Radio_Set_StHiBlend_Level(3, start * 10, 300);
+    devTEF_Radio_Set_StHiBlend_Noise(3, 360, 300);
+    devTEF_Radio_Set_StHiBlend_Mph(3, 360, 300);
+  }
+}
+
+bool TEF6686::getProcessing(uint16_t &highcut, uint16_t &stereo, uint16_t &sthiblend, uint8_t &stband_1, uint8_t &stband_2, uint8_t &stband_3, uint8_t &stband_4) {
+  bool result = devTEF_Radio_Get_Processing_Status(&highcut, &stereo, &sthiblend, &stband_1, &stband_2, &stband_3, &stband_4);
+  return highcut;
+  return stereo;
+  return sthiblend;
+  return stband_1;
+  return stband_2;
+  return stband_3;
+  return stband_4;
 }
 
 bool TEF6686::getStatus(int16_t &level, uint16_t &USN, uint16_t &WAM, int16_t &offset, uint16_t &bandwidth, uint16_t &modulation) {
-  uint8_t result = devTEF_Radio_Get_Quality_Status(&level, &USN, &WAM, &offset, &bandwidth, &modulation);
+  bool result = devTEF_Radio_Get_Quality_Status(&level, &USN, &WAM, &offset, &bandwidth, &modulation);
   return level;
   return USN;
   return WAM;
@@ -212,35 +241,38 @@ bool TEF6686::getStatus(int16_t &level, uint16_t &USN, uint16_t &WAM, int16_t &o
   return modulation;
 }
 
-bool TEF6686::getStatus_AM(int16_t &level, uint16_t &USN, uint16_t &WAM, int16_t &offset, uint16_t &bandwidth, uint16_t &modulation) {
-  uint8_t result = devTEF_Radio_Get_Quality_Status_AM(&level, &USN, &WAM, &offset, &bandwidth, &modulation);
+bool TEF6686::getStatusAM(int16_t &level, uint16_t &noise, uint16_t &cochannel, int16_t &offset, uint16_t &bandwidth, uint16_t &modulation) {
+  bool result = devTEF_Radio_Get_Quality_Status_AM(&level, &noise, &cochannel, &offset, &bandwidth, &modulation);
   return level;
-  return USN;
-  return WAM;
+  return noise;
+  return cochannel;
   return bandwidth;
   return modulation;
 }
 
 bool TEF6686::readRDS()
 {
-  char     status;
-  uint16_t rdsStat  = 0, rdsErr = 65535, rdsErrA = 65535, rdsErrB = 65535, rdsErrC = 65535, rdsErrD = 65535;
-  uint16_t result   = devTEF_Radio_Get_RDS_Data(&rdsStat, &rds.rdsA, &rds.rdsB, &rds.rdsC, &rds.rdsD, &rdsErr);
-  uint8_t  rds_group;
-  uint8_t  offset;
-  bool     rdsErrCheck = false, rdsDataReady = false;
+  char  status;
+  uint16_t rdsStat = 0, rdsErr = 65535, rdsErrA = 65535, rdsErrB = 65535, rdsErrC = 65535, rdsErrD = 65535;
+  uint16_t result = devTEF_Radio_Get_RDS_Data(&rdsStat, &rds.rdsA, &rds.rdsB, &rds.rdsC, &rds.rdsD, &rdsErr);
+  uint8_t rds_group;
+  uint8_t offset;
+  bool rdsErrCheck = false, rdsDataReady = false;
 
   rdsErrA = ((rdsErr >> 14) & 0x02);
   rdsErrB = ((rdsErr >> 12) & 0x02);
   rdsErrC = ((rdsErr >> 10) & 0x02);
   rdsErrD = ((rdsErr >>  8) & 0x02);
 
+  rdsTimeOut += rdsErr == 0 && rds.rdsA != 0 ? -rdsTimeOut : rdsTimeOut < 32768  ? 1 : 0;
+  rds.hasRDS  = rdsTimeOut < 32768 ? true : false;
+
   rdsErrCheck = rdsErr == 0;
-  rdsDataReady = ((rdsStat & (1 << 15))  && (rdsStat & (1 << 9)));
+  rdsDataReady = ((rdsStat & (1 << 15)) && (rdsStat & (1 << 9)));
   rds.errors = rdsErr;
-  if (rdsDataReady && rdsErrCheck)
+  if (rdsDataReady)
   {
-    //RDS PI
+    //PI
     if (rds.stationID == 0) rds.stationID = rds.rdsA;
     char Hex[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
     rds.picode[0] = Hex[(rds.rdsA & 0xF000U) >> 12];
@@ -249,42 +281,79 @@ bool TEF6686::readRDS()
     rds.picode[3] = Hex[(rds.rdsA & 0x000FU)];
     rds.picode[4] = '\0';
     rds_group  = (rds.rdsB >> 11);
+
+    if (rdsErrCheck) rds.correct = true; else rds.correct = false;
+
     switch (rds_group)
     {
       case RDS_GROUP_0A:
       case RDS_GROUP_0B:
         {
-          //RDS PS
+          //RDS Programm-Service
           offset = rds.rdsB & 0x03;
+          if ((offset == 0) && (ps_process == 0)) ps_process = 1;
 
-          if ((offset == 0) && (ps_process == 0))ps_process = 1;
-
-          if (ps_process == 1)
-          {
+          if (ps_process == 1) {
             ps_buffer[(offset * 2)  + 0] = ascii_converter(rds.rdsD >> 8);
             ps_buffer[(offset * 2)  + 1] = ascii_converter(rds.rdsD & 0xFF);
             ps_buffer[(offset * 2)  + 2] = 0;
             ps_process = strlen(ps_buffer) == 8 ? 2 : 1;
           }
 
-          if (ps_process == 2)
-          {
+          if (ps_process == 2) {
             strcpy(rds.stationName, ps_buffer);
-            for (int i = 0; i < 9; i++)
-              ps_buffer[i]  = '\0';
+            for (int i = 0; i < 9; i++) ps_buffer[i]  = '\0';
             ps_process = 0;
+            rds.hasPS = true;
           }
 
-          //RDS PTY Code
+          //PTY
           rds.stationTypeCode = (rds.rdsB >> 5) & 0x1F;
+          rds.hasPTY = true;
           strcpy(rds.stationType, PTY[rds.stationTypeCode]);
+
+          //TP-TA-EON-MS
+          if ((bitRead(rds.rdsB, 4)) == 1 && ((bitRead(rds.rdsB, 10)) == 0)) rds.hasEON = true; else rds.hasEON = false;
+          if ((bitRead(rds.rdsB, 4)) == 0 && ((bitRead(rds.rdsB, 10)) == 1)) rds.hasTP = true; else rds.hasTP = false;
+          rds.hasTA = (bitRead(rds.rdsB, 4)) && (bitRead(rds.rdsB, 10)) & 0x1F;
+          rds.MS = (bitRead(rds.rdsB, 3)) & 0x1F;
+
+          //AF
+          uint8_t  af_controlCode = rds.rdsC >> 8;
+          if ((af_controlCode < 224) && (af_counter < 50))
+          {
+            uint16_t buffer0 = (rds.rdsC >> 8);
+            uint16_t buffer1 = (rds.rdsC & 0xFF);
+            rds.hasAF = true;
+            if (buffer0 != 0 && buffer1 != 0)
+            {
+              buffer0 = buffer0 * 10 + 8750;
+              buffer1 = buffer1 * 10 + 8750;
+              bool isDouble = false;
+              isDouble = checkDouble(buffer0);
+              if (!isDouble && buffer0 != 0) {
+                af[af_counter].frequency = buffer0;
+                af_counter++;
+              }
+
+              isDouble = checkDouble(buffer1);
+              if (!isDouble && buffer1 != 0) {
+                af[af_counter].frequency = buffer1;
+                af_counter++;
+              }
+            }
+          }
         } break;
 
+      case RDS_GROUP_1A:
+        if (rds.rdsC < 255) rds.ECC = rds.rdsC;
+        break;
+
       case RDS_GROUP_2A:
       case RDS_GROUP_2B:
         {
-          //RDS RT Code
           boolean limit_reached = false;
+          rds.hasRT = true;
           offset = (rds.rdsB & 0xf) * 4;
           rds.rtAB = (bitRead(rds.rdsB, 4));
           limit_reached = (offset == 60 || (rds.rdsC >> 8) == '\r' || (rds.rdsC & 0xFF) == '\r' || (rds.rdsD >> 8) == '\r' || (rds.rdsD & 0xFF) == '\r')  ? true : false;
@@ -292,17 +361,14 @@ bool TEF6686::readRDS()
 
           if (rds.rtAB != ABold) {
             offsetold = 0;
-            for (int i = 0; i < 65; i++) {
-              rds.stationText[i] = 0;
-            }
-            if (rt_timer == 64) {
-              strcpy(rds.stationText, stationTextBuffer);
-            }
+            for (int i = 0; i < 65; i++) rds.stationText[i] = 0;
+            if (rt_timer == 64) strcpy(rds.stationText, stationTextBuffer);
+
             for (int i = 0; i < 65; i++) {
               rt_buffer[i]  = 0;
               stationTextBuffer[i] = 0;
             }
-            rt_process = 0;
+            if (rds.hasRDSplus == false) rt_process = 0;
           }
           ABold = rds.rtAB;
 
@@ -320,9 +386,8 @@ bool TEF6686::readRDS()
             rt_buffer[offset + 2] = ascii_converter(rds.rdsD >> 8);
             rt_buffer[offset + 3] = ascii_converter(rds.rdsD & 0xff);
 
-            if (offset > offsetold) {
-              offsetold = offset;
-            }
+            if (offset > offsetold) offsetold = offset;
+
             if (offset == offsetold) {
               strcpy(stationTextBuffer, rt_buffer);
               if (rt_timer < 64) {
@@ -339,6 +404,7 @@ bool TEF6686::readRDS()
           {
             for (int i = 0; i < 64; i++)
             {
+              rt_buffer2[i]   = rt_buffer[i];
               rt_buffer[i]  = 0;
             }
           }
@@ -347,7 +413,26 @@ bool TEF6686::readRDS()
       case RDS_GROUP_4A:
       case RDS_GROUP_4B:
         {
-          //RDS CT
+          uint32_t mjd;
+          rds.hasCT = true;
+          mjd = (rds.rdsB & 0x03);
+          mjd <<= 15;
+          mjd += ((rds.rdsC >> 1) & 0x7FFF);
+
+          long J, C, Y, M;
+          uint8_t LocalOffset;
+          J = mjd + 2400001 +  68569;
+          C = 4 * J / 146097;
+          J = J - (146097 * C + 3) / 4;
+          Y = 4000 * (J + 1) / 1461001;
+          J = J - 1461 * Y / 4 + 31;
+          M = 80 * (J + 0) / 2447;
+
+          rds.days = J - 2447 * M / 80;
+          J = M / 11;
+
+          rds.months = M +  2 - (12 * J);
+          rds.years = 100 * (C - 49) + Y + J;
           rds.hours = ((rds.rdsD >> 12) & 0x0f);
           rds.hours += ((rds.rdsC <<  4) & 0x0010);
           rds.minutes = ((rds.rdsD >>  6) & 0x3f);
@@ -355,6 +440,77 @@ bool TEF6686::readRDS()
           rds.offset = (rds.rdsD & 0x3f);
           rds.hasCT = true;
         } break;
+
+      case RDS_GROUP_10A:
+      case RDS_GROUP_10B:
+      case RDS_GROUP_11A:
+      case RDS_GROUP_11B:
+      case RDS_GROUP_12A:
+      case RDS_GROUP_12B:
+        {
+          if (useRTPlus)
+          {
+            uint16_t  content_byte_1 = (rds.rdsB & 0x07);
+            content_byte_1 = (content_byte_1  << 0x03);
+            content_byte_1 += (rds.rdsC >> 0x0D);
+            uint16_t  content_byte_2 = (rds.rdsC & 0x01);
+            content_byte_2 = (content_byte_2 << 0x05);
+            content_byte_2 += (rds.rdsD >> 0x0B);
+            uint16_t  start_marker_1 = (rds.rdsC >> 0x07);
+            start_marker_1 = (start_marker_1 & 0x3F);
+            uint16_t length_marker_1 = (rds.rdsC >> 0x01);
+            length_marker_1 = (length_marker_1  & 0x3F);
+            uint16_t start_marker_2 = (rds.rdsD >> 0x05);
+            start_marker_2 = (start_marker_2 & 0x3F);
+            uint16_t length_marker_2 = (rds.rdsD & 0x1F);
+            rds.hasRDSplus   = true;
+
+            if (rt_process == 2)
+            {
+              if (content_byte_1 == 0x04) { //ArtistID
+                rds.hasMusicArtist = true;
+                for (int i = 0; i <= length_marker_1; i++)rds.musicArtist[i] = rt_buffer2[i + start_marker_1];
+                rds.musicArtist[length_marker_1 + 1] = 0;
+              }
+              else if (content_byte_1 == 0x01) {//TitleID
+                rds.hasMusicTitle = true;
+                for (int i = 0; i <= length_marker_1; i++)rds.musicTitle[i] = rt_buffer2[i + start_marker_1];
+                rds.musicTitle[length_marker_1 + 1] = 0;
+              }
+              if (content_byte_2 == 0x04) {//ArtistID
+                rds.hasMusicArtist = true;
+                for (int i = 0; i <= length_marker_2; i++)rds.musicArtist[i] = rt_buffer2[i + start_marker_2];
+                rds.musicArtist[length_marker_2 + 1] = 0;
+              }
+              else if (content_byte_2 == 0x01) {//TitleID
+                rds.hasMusicTitle = true;
+                for (int i = 0; i <= length_marker_2; i++)rds.musicTitle[i] = rt_buffer2[i + start_marker_2];
+                rds.musicTitle[length_marker_2 + 1] = 0;
+              }
+              if (content_byte_1 == 0x24) {//HostID
+                rds.hasStationHost = true;
+                for (int i = 0; i <= length_marker_1; i++)rds.stationHost[i] = rt_buffer2[i + start_marker_1];
+                rds.stationHost[length_marker_1 + 1] = 0;
+              }
+              else if (content_byte_2 == 0x24) {
+                rds.hasStationHost = true;
+                for (int i = 0; i <= length_marker_2; i++)rds.stationHost[i] = rt_buffer2[i + start_marker_2];
+                rds.stationHost[length_marker_2 + 1] = 0;
+              }
+              if (content_byte_1 == 0x21) {//EventID
+                rds.hasStationEvent = true;
+                for (int i = 0; i <= length_marker_1; i++)rds.stationEvent[i] = rt_buffer2[i + start_marker_1];
+                rds.stationEvent[length_marker_1 + 1] = 0;
+              }
+              else if (content_byte_2 == 0x21) {
+                rds.hasStationEvent = true;
+                for (int i = 0; i <= length_marker_2; i++)rds.stationEvent[i] = rt_buffer2[i + start_marker_2];
+                rds.stationEvent[length_marker_2 + 1] = 0;
+              }
+              rt_process = 0;
+            }
+          }
+        } break;
     }
   }
   return rdsDataReady;
@@ -377,6 +533,12 @@ uint8_t TEF6686::ascii_converter (uint8_t src)
   return (dest);
 }
 
+bool TEF6686::checkDouble (uint16_t value)
+{
+  for (int i = 0; i < 50; i++) if (af[i].frequency == value)return (true);
+  return (false);
+}
+
 void TEF6686::clearRDS (bool fullsearchrds)
 {
   devTEF_Radio_Set_RDS(fullsearchrds);
@@ -389,44 +551,55 @@ void TEF6686::clearRDS (bool fullsearchrds)
     rds.stationText[i] = 0;
     stationTextBuffer[i] = 0;
     rt_buffer[i] = 0;
+    rt_buffer2[i] = 0;
   }
   for (i = 0; i < 17; i++) {
     rds.stationType[i] = 0;
   }
 
-  for (i = 0; i < 5; i++) {
-    rds.picode[i] = 0;
+  for (i = 0; i < 32; i++) {
+    rds.musicArtist[i] = 0;
+    rds.musicTitle[i] = 0;
+    rds.stationEvent[i] = 0;
+    rds.stationHost[i] = 0;
   }
+  for (i = 0; i < 5; i++) rds.picode[i] = 0;
+
+  for (i = 0; i < 50; i++) af[i].frequency = 0;
 
   rds.stationType[i] = '\0';
   rds.stationID = 0;
+  rds.ECC = 0;
   offsetold = 0;
   rds.stationTypeCode = 32;
+  rdsTimeOut = 32768;
+  rds.hasRDSplus = false;
+  rds.afclear = false;
+  rds.hasRT = false;
+  rds.hasRDS = false;
+  rds.hasPS = false;
+  rds.hasTP = false;
+  rds.hasTA = false;
+  rds.hasEON = false;
+  rds.MS = false;
+  rds.hasPTY = false;
   rds.hasCT = false;
+  rds.hasMusicTitle = false;
+  rds.hasMusicArtist = false;
+  rds.hasStationEvent = false;
+  rds.hasStationHost = false;
   rds.stationTextOffset  = 0;
+  rds.errors = 0;
+  rds.correct = 0;
   rt_process = 0;
   ps_process = 1;
   af_counter = 0;
   rt_timer = 0;
-  rds.errors = 0;
-}
-
-uint16_t TEF6686::tune(uint8_t up, uint8_t stepsize, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds) {
-  Radio_ChangeFreqOneStep(up, stepsize, LowEdge, HighEdge, fullsearchrds);
-  Radio_SetFreq(Radio_GetCurrentFreq(), LowEdge, HighEdge, fullsearchrds);
-
-  return Radio_GetCurrentFreq();
-}
-
-uint16_t TEF6686::tune_AM(uint8_t up, uint8_t stepsize) {
-  Radio_ChangeFreqOneStep_AM(up, stepsize);
-  Radio_SetFreq_AM(Radio_GetCurrentFreq_AM());
-  return Radio_GetCurrentFreq_AM();
 }
 
 void TEF6686::tone(uint16_t time, int16_t amplitude, uint16_t frequency) {
-	devTEF_Audio_Set_Mute(0);
-	devTEF_Radio_Set_Wavegen(1, amplitude, frequency);
-	delay (time);
-	devTEF_Radio_Set_Wavegen(0, 0, 0);
+  devTEF_Audio_Set_Mute(0);
+  devTEF_Radio_Set_Wavegen(1, amplitude, frequency);
+  delay (time);
+  devTEF_Radio_Set_Wavegen(0, 0, 0);
 }
diff --git a/src/TEF6686.h b/src/TEF6686.h
index 30feb6a..b1d4245 100644
--- a/src/TEF6686.h
+++ b/src/TEF6686.h
@@ -1,79 +1,111 @@
 #define TEF6686_h
 
 #include "Arduino.h"
-#include "Tuner_Api.h"
 #include "Tuner_Drv_Lithio.h"
 #include "Tuner_Interface.h"
 
-
-enum RDS_GROUPS
-{
+enum RDS_GROUPS {
   RDS_GROUP_0A,  RDS_GROUP_0B,  RDS_GROUP_1A,  RDS_GROUP_1B,  RDS_GROUP_2A,  RDS_GROUP_2B,  RDS_GROUP_3A,  RDS_GROUP_3B,
   RDS_GROUP_4A,  RDS_GROUP_4B,  RDS_GROUP_5A,  RDS_GROUP_5B,  RDS_GROUP_6A,  RDS_GROUP_6B,  RDS_GROUP_7A,  RDS_GROUP_7B,
   RDS_GROUP_8A,  RDS_GROUP_8B,  RDS_GROUP_9A,  RDS_GROUP_9B,  RDS_GROUP_10A, RDS_GROUP_10B, RDS_GROUP_11A, RDS_GROUP_11B,
   RDS_GROUP_12A, RDS_GROUP_12B, RDS_GROUP_13A, RDS_GROUP_13B, RDS_GROUP_14A, RDS_GROUP_14B, RDS_GROUP_15A, RDS_GROUP_15B
 };
 
-typedef struct _rds_
-{
-  char picode[5];
+typedef struct _rds_ {
+  byte stationTypeCode;
   char stationName[9];
   char stationText[65];
-  byte stationTypeCode;
   char stationType[17];
-  uint16_t hours, minutes, days, offsetplusmin, stationID = 0, rdsA, rdsB, rdsC, rdsD, rdsError, errors = 0;
+  char musicTitle[48];
+  char musicArtist[48];
+  char stationHost[48];
+  char stationEvent[48];
+  char picode[5];
+  uint16_t hours, minutes, days, months, years, offsetplusmin, stationID = 0, rdsA, rdsB, rdsC, rdsD, rdsError, errors = 0;
   int8_t offset;
   uint8_t stationTextOffset = 0;
-  bool hasCT = false;
-  bool rtAB = false;
+  int ECC;
+  bool hasMusicTitle;
+  bool hasMusicArtist;
+  bool hasStationHost;
+  bool hasStationEvent;
+  bool hasRDSplus;
+  bool hasRDS;
+  bool hasPS;
+  bool hasRT;
+  bool hasTP;
+  bool hasTA;
+  bool hasEON;
+  bool hasAF;
+  bool MS;
+  bool hasPTY;
+  bool hasCT;
+  bool afclear;
+  bool rtAB;
+  bool correct;
 } rds_;
 
+typedef struct _af_ {
+  uint16_t  frequency;
+} af_;
+
+
 class TEF6686 {
   public:
+    af_  af[50];
     rds_ rds;
     bool readRDS(void);
-    uint16_t getFrequency();
-    uint16_t getFrequency_AM();
-    uint16_t tuneDown(uint8_t stepsize, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds);
-    uint16_t tuneUp(uint8_t stepsize, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds);
-    uint16_t tuneDown_AM(uint8_t stepsize);
-    uint16_t tuneUp_AM(uint8_t stepsize);
+    void SetFreq(uint16_t frequency);
+    void SetFreqAM(uint16_t frequency);
+    bool getProcessing(uint16_t &highcut, uint16_t &stereo, uint16_t &sthiblend, uint8_t &stband_1, uint8_t &stband_2, uint8_t &stband_3, uint8_t &stband_4);
     bool getStatus(int16_t &level, uint16_t &USN, uint16_t &WAM, int16_t &offset, uint16_t &bandwidth, uint16_t &modulation);
-    bool getStatus_AM(int16_t &level, uint16_t &USN, uint16_t &WAM, int16_t &offset, uint16_t &bandwidth, uint16_t &modulation);
+    bool getStatusAM(int16_t &level, uint16_t &noise, uint16_t &cochannel, int16_t &offset, uint16_t &bandwidth, uint16_t &modulation);
     bool getIdentification(uint16_t &device, uint16_t &hw_version, uint16_t &sw_version);
-    bool getBootStatus(uint8_t &bootstatus);
-    void setMono(uint8_t mono);
+    void setSoftmuteFM(uint8_t mode);
+    void setSoftmuteAM(uint8_t mode);
+    void setMono(bool mono);
     bool getStereoStatus();
     void init(byte TEF);
     void clearRDS(bool fullsearchrds);
-    void power(uint8_t mode);
-    void setAGC(uint8_t start);
-    void setiMS(uint16_t mph);
-    void setEQ(uint16_t eq);
+    void power(bool mode);
+    void setAGC(uint8_t agc);
+    void setiMS(bool mph);
+    void setEQ(bool eq);
     void setDeemphasis(uint8_t timeconstant);
+    void setAudio(uint8_t audio);
     void setFMABandw();
     void setFMBandw(uint16_t bandwidth);
     void setAMBandw(uint16_t bandwidth);
-    void setFrequency(uint16_t frequency, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds);
-    void setFrequency_AM(uint16_t frequency);
     void setHighCutLevel(uint16_t limit);
-    void setHighCutOffset(uint16_t start);
+    void setHighCutOffset(uint8_t start);
+    void setStHiBlendLevel(uint16_t limit);
+    void setStHiBlendOffset(uint8_t start);
+    void setNoiseBlanker(uint16_t start);
+    void setAMCoChannel(uint16_t start);
+    void setAMNoiseBlanker(uint16_t start);
+    void setAMAttenuation(uint16_t start);
     void setMute();
-    void setOffset(int16_t offset);
-    void setStereoLevel(uint16_t start);
+    void setOffset(int8_t offset);
+    void setFMSI(uint8_t mode);
+    void setFMSI_Time(uint16_t attack, uint16_t decay);
+    void setFMSI_Gain(uint16_t band1, uint16_t band2, uint16_t band3, uint16_t band4);
+    void setFMSI_Bias(int16_t band1, int16_t band2, int16_t band3, int16_t band4);
+    void setStereoLevel(uint8_t start);
     void setUnMute();
-    void setVolume(int16_t volume);
-	void tone(uint16_t time, int16_t amplitude, uint16_t frequency);
+    void setVolume(int8_t volume);
     uint8_t af_counter;
+    void tone(uint16_t time, int16_t amplitude, uint16_t frequency);
 
   private:
-    uint16_t tune(uint8_t up, uint8_t stepsize, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds);
-    uint16_t tune_AM(uint8_t up, uint8_t stepsize);
-    uint8_t ascii_converter (uint8_t src);
+    uint8_t ascii_converter   (uint8_t src);
+    uint16_t rdsTimeOut  = 32768;
     uint8_t ps_process;
     uint8_t rt_process;
     char ps_buffer[9];
     char rt_buffer[65];
+    char rt_buffer2[65];
+    bool useRTPlus = true;
+    bool checkDouble (uint16_t value);
     bool ABold;
     byte rt_timer;
     byte offsetold;
diff --git a/src/Tuner_Api.cpp b/src/Tuner_Api.cpp
deleted file mode 100644
index 760e5b8..0000000
--- a/src/Tuner_Api.cpp
+++ /dev/null
@@ -1,106 +0,0 @@
-#include "TEF6686.h"
-
-uint16_t Radio_CurrentFreq;
-uint16_t Radio_CurrentFreq_AM;
-
-void Radio_SetFreq(uint16_t Freq, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds)
-{
-  if ((Freq > HighEdge * 100) || (Freq < LowEdge * 100)) {
-    Freq = LowEdge * 100;
-  }
-  Radio_CurrentFreq = Freq;
-  devTEF_Radio_Tune_To(Freq);
-  devTEF_Radio_Set_RDS(fullsearchrds);
-}
-
-void Radio_SetFreq_AM(uint16_t Freq)
-{
-  if (Freq > 27000) {
-    Freq = 144;
-  }
-  if (Freq < 144) {
-    Freq = 27000;
-  }
-  Radio_CurrentFreq_AM = Freq;
-  devTEF_Radio_Tune_To_AM(Freq);
-}
-
-void Radio_ChangeFreqOneStep(uint8_t UpDown, uint8_t stepsize, uint16_t LowEdge, uint16_t HighEdge, bool fullseachrds)
-{
-  byte temp;
-  if (stepsize == 0) {
-    temp = 5;
-  }
-  if (stepsize == 1) {
-    temp = 1;
-  }
-  if (stepsize == 2) {
-    temp = 10;
-  }
-  if (stepsize == 3) {
-    temp = 100;
-  }
-  if (UpDown == 1) {
-    Radio_CurrentFreq += temp;
-    if (Radio_CurrentFreq > HighEdge * 100) {
-      Radio_CurrentFreq = LowEdge * 100;
-    }
-  } else {
-    Radio_CurrentFreq -= temp;
-    if (Radio_CurrentFreq < LowEdge * 100) {
-      Radio_CurrentFreq = HighEdge * 100;
-    }
-  }
-}
-
-void Radio_ChangeFreqOneStep_AM(uint8_t UpDown, uint8_t stepsize)
-{
-  byte temp;
-  if (stepsize == 0) {
-    if (Radio_CurrentFreq_AM < 2000) {
-      temp = 9;
-    } else {
-      temp = 5;
-    }
-  }
-  if (stepsize == 1) {
-    temp = 1;
-  }
-  if (stepsize == 2) {
-    temp = 10;
-  }
-  if (stepsize == 3) {
-    temp = 100;
-  }
-  if (UpDown == 1) {
-    Radio_CurrentFreq_AM += temp;
-    if (Radio_CurrentFreq_AM > 27000) {
-      Radio_CurrentFreq_AM = 144;
-    }
-  } else {
-    Radio_CurrentFreq_AM -= temp;
-    if (Radio_CurrentFreq_AM < 144) {
-      Radio_CurrentFreq_AM = 27000;
-    }
-  }
-}
-
-uint16_t Radio_GetCurrentFreq(void)
-{
-  return Radio_CurrentFreq;
-}
-
-uint16_t Radio_GetCurrentFreq_AM(void)
-{
-  return Radio_CurrentFreq_AM;
-}
-
-bool Radio_CheckStereo(void)
-{
-  uint16_t status;
-  uint8_t stereo = 0;
-  if (1 == devTEF_Radio_Get_Stereo_Status(&status)) {
-    stereo = ((status >> 15) & 1) ? 1 : 0;
-  }
-  return stereo;
-}
diff --git a/src/Tuner_Api.h b/src/Tuner_Api.h
deleted file mode 100644
index 31046d7..0000000
--- a/src/Tuner_Api.h
+++ /dev/null
@@ -1,7 +0,0 @@
-extern uint16_t Radio_GetCurrentFreq(void);
-extern uint16_t Radio_GetCurrentFreq_AM(void);
-extern void Radio_ChangeFreqOneStep(uint8_t UpDown, uint8_t stepsize, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds);
-extern void Radio_ChangeFreqOneStep_AM(uint8_t UpDown, uint8_t stepsize);
-extern void Radio_SetFreq(uint16_t Freq, uint16_t LowEdge, uint16_t HighEdge, bool fullsearchrds);
-extern void Radio_SetFreq_AM(uint16_t Freq);
-bool Radio_CheckStereo(void);
diff --git a/src/Tuner_Drv_Lithio.cpp b/src/Tuner_Drv_Lithio.cpp
index 6f5e8e4..1e4adfc 100644
--- a/src/Tuner_Drv_Lithio.cpp
+++ b/src/Tuner_Drv_Lithio.cpp
@@ -1,40 +1,32 @@
 #include "TEF6686.h"
 #include <stdarg.h>
 
-#define High_16bto8b(a)  ((uint8_t)((a) >> 8))
-#define Low_16bto8b(a)  ((uint8_t)(a ))
+#define High_16bto8b(a) ((uint8_t)((a) >> 8))
+#define Low_16bto8b(a) ((uint8_t)(a ))
 #define Convert8bto16b(a) ((uint16_t)(((uint16_t)(*(a))) << 8 |((uint16_t)(*(a+1)))))
 
-bool devTEF_Set_Cmd(TEF_MODULE module, uint8_t cmd, uint16_t len, ...)
-{
+bool devTEF_Set_Cmd(TEF_MODULE module, uint8_t cmd, uint16_t len, ...) {
   uint16_t i;
   uint8_t buf[20];
   uint16_t temp;
   va_list vArgs;
-
   va_start(vArgs, len);
-
   buf[0] = module;
   buf[1] = cmd;
   buf[2] = 1;
 
-  for (i = 3; i < len; i++)
-  {
+  for (i = 3; i < len; i++) {
     temp = va_arg(vArgs, int);
     buf[i++] = High_16bto8b(temp);
     buf[i] = Low_16bto8b(temp);
   }
 
   va_end(vArgs);
-
   return Tuner_WriteBuffer(buf, len);
 }
 
-
-bool devTEF_Get_Cmd(TEF_MODULE module, uint8_t cmd, uint8_t *receive, uint16_t len)
-{
+bool devTEF_Get_Cmd(TEF_MODULE module, uint8_t cmd, uint8_t *receive, uint16_t len) {
   uint8_t buf[3];
-
   buf[0] = module;
   buf[1] = cmd;
   buf[2] = 1;
@@ -43,118 +35,176 @@ bool devTEF_Get_Cmd(TEF_MODULE module, uint8_t cmd, uint8_t *receive, uint16_t l
   return Tuner_ReadBuffer(receive, len);
 }
 
-bool devTEF_Radio_Tune_To (uint16_t frequency)
-{
+bool devTEF_Radio_Tune_To (uint16_t frequency) {
   return devTEF_Set_Cmd(TEF_FM, Cmd_Tune_To, 7, 4, frequency);
 }
 
-bool devTEF_Radio_Tune_To_AM (uint16_t frequency)
-{
+bool devTEF_Radio_Tune_AM (uint16_t frequency) {
   return devTEF_Set_Cmd(TEF_AM, Cmd_Tune_To, 7, 1, frequency);
 }
 
-bool devTEF_Radio_Set_Bandwidth(uint16_t mode, uint16_t bandwidth, uint16_t control_sensitivity, uint16_t low_level_sensitivity)
-{
+bool devTEF_Radio_Set_Bandwidth(uint8_t mode, uint16_t bandwidth, uint16_t control_sensitivity, uint16_t low_level_sensitivity) {
   return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Bandwidth, 11, mode, bandwidth, control_sensitivity, low_level_sensitivity);
 }
 
-bool devTEF_Radio_Set_Bandwidth_AM(uint16_t mode, uint16_t bandwidth, uint16_t control_sensitivity, uint16_t low_level_sensitivity)
-{
+bool devTEF_Radio_Set_BandwidthAM(uint8_t mode, uint16_t bandwidth, uint16_t control_sensitivity, uint16_t low_level_sensitivity) {
   return devTEF_Set_Cmd(TEF_AM, Cmd_Set_Bandwidth, 7, mode, bandwidth, control_sensitivity, low_level_sensitivity);
 }
 
-bool devTEF_Radio_Set_LevelOffset(int16_t offset)
-{
+bool devTEF_Radio_Set_Noiseblanker_AM(uint8_t mode, uint16_t start) {
+  return devTEF_Set_Cmd(TEF_AM, Cmd_Set_NoiseBlanker, 7, mode, start);
+  return devTEF_Set_Cmd(TEF_AM, Cmd_Set_NoiseBlanker_Audio, 7, mode, 1000);
+}
+
+bool devTEF_Radio_Set_Attenuator_AM(uint16_t start) {
+  return devTEF_Set_Cmd(TEF_AM, Cmd_Set_Antenna, 5, start);
+}
+
+bool devTEF_Radio_Set_CoChannel_AM(uint16_t start) {
+  return devTEF_Set_Cmd(TEF_AM, Cmd_Set_CoChannelDet, 11, 1, 2, start, 1000, 3);
+}
+
+bool devTEF_Radio_Set_LevelOffset(int16_t offset) {
   return devTEF_Set_Cmd(TEF_FM, Cmd_Set_LevelOffset, 5, offset - 70);
 }
 
-bool devTEF_Radio_Set_Highcut_Level(uint16_t mode, uint16_t start, uint16_t slope)
-{
+bool devTEF_Radio_Set_RDS(bool fullsearchrds) {
+  if (fullsearchrds == true) return devTEF_Set_Cmd(TEF_FM, Cmd_Set_RDS, 9, 3, 1, 0); else return devTEF_Set_Cmd(TEF_FM, Cmd_Set_RDS, 9, 1, 1, 0);
+}
+
+bool devTEF_Radio_Set_Highcut_Level(uint8_t mode, uint16_t start, uint16_t slope) {
   return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Level, 9, mode, start, slope);
 }
 
-bool devTEF_Radio_Set_Highcut_Noise(uint16_t mode, uint16_t start, uint16_t slope)
-{
+bool devTEF_Radio_Set_Highcut_Noise(uint8_t mode, uint16_t start, uint16_t slope) {
   return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Noise, 9, mode, start, slope);
 }
 
-bool devTEF_Radio_Set_Highcut_Mph(uint16_t mode, uint16_t start, uint16_t slope)
-{
+bool devTEF_Radio_Set_Highcut_Mph(uint8_t mode, uint16_t start, uint16_t slope) {
   return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Mph, 9, mode, start, slope);
 }
 
-bool devTEF_Radio_Set_Highcut_Max(uint16_t mode, uint16_t limit)
-{
+bool devTEF_Radio_Set_Highcut_Max(uint8_t mode, uint16_t limit) {
   return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Highcut_Max, 7, mode, limit);
 }
 
-bool devTEF_Radio_Set_Stereo_Level(uint16_t mode, uint16_t start, uint16_t slope)
-{
+bool devTEF_Radio_Set_StHiBlend_Level(uint8_t mode, uint16_t start, uint16_t slope) {
+  return devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Level, 9, mode, start, slope);
+}
+
+bool devTEF_Radio_Set_StHiBlend_Noise(uint8_t mode, uint16_t start, uint16_t slope) {
+  return devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Noise, 9, mode, start, slope);
+}
+
+bool devTEF_Radio_Set_StHiBlend_Mph(uint8_t mode, uint16_t start, uint16_t slope) {
+  return devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Mph, 9, mode, start, slope);
+}
+
+bool devTEF_Radio_Set_StHiBlend_Max(uint8_t mode, uint16_t limit) {
+  return devTEF_Set_Cmd(TEF_FM, Cmd_Set_StHiBlend_Max, 7, mode, limit);
+}
+
+bool devTEF_Radio_Set_Stereo_Level(uint8_t mode, uint16_t start, uint16_t slope) {
   return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Level, 9, mode, start, slope);
 }
 
-bool devTEF_Radio_Set_Stereo_Noise(uint16_t mode, uint16_t start, uint16_t slope)
-{
+bool devTEF_Radio_Set_NoisBlanker(uint8_t mode, uint16_t start) {
+  return devTEF_Set_Cmd(TEF_FM, Cmd_Set_NoiseBlanker, 7, mode, start);
+}
+
+bool devTEF_Radio_Set_Stereo_Noise(uint8_t mode, uint16_t start, uint16_t slope) {
   return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Noise, 9, mode, start, slope);
 }
 
-bool devTEF_Radio_Set_Stereo_Mph(uint16_t mode, uint16_t start, uint16_t slope)
-{
+bool devTEF_Radio_Set_Stereo_Mph(uint8_t mode, uint16_t start, uint16_t slope) {
   return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Mph, 9, mode, start, slope);
 }
 
-bool devTEF_Radio_Set_MphSuppression(uint16_t mph)
-{
+bool devTEF_Radio_Set_MphSuppression(bool mph) {
   return devTEF_Set_Cmd(TEF_FM, Cmd_Set_MphSuppression, 5, mph, 0);
 }
 
-bool devTEF_Radio_Set_ChannelEqualizer(uint16_t eq)
-{
+bool devTEF_Radio_Set_ChannelEqualizer(bool eq) {
   return devTEF_Set_Cmd(TEF_FM, Cmd_Set_ChannelEqualizer, 5, eq, 0);
 }
 
-bool devTEF_Radio_Set_Stereo_Min(uint16_t mode)
-{
+bool devTEF_Radio_Set_Stereo_Min(bool mode) {
   return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Stereo_Min, 7, mode);
 }
 
-bool devTEF_Radio_Set_RFAGC(uint16_t start)
-{
-  return devTEF_Set_Cmd(TEF_FM, Cmd_Set_RFAGC, 7, start, 0, 0);
+bool devTEF_Radio_Set_RFAGC(uint16_t agc) {
+  return devTEF_Set_Cmd(TEF_FM, Cmd_Set_RFAGC, 7, agc, 0, 0);
 }
 
-bool devTEF_Radio_Set_Deemphasis(uint16_t timeconstant)
-{
+bool devTEF_Radio_Set_Deemphasis(uint16_t timeconstant) {
   return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Deemphasis, 5, timeconstant, 0);
 }
 
-bool devTEF_Audio_Set_Volume(int16_t volume)
-{
+bool devTEF_Radio_Specials(uint16_t audio) {
+  return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Specials, 5, audio, 0);
+}
+
+bool devTEF_Audio_Set_Volume(int16_t volume) {
   return devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Volume, 5, volume * 10);
 }
 
-bool devTEF_Audio_Set_Mute(uint16_t mode)
-{
+bool devTEF_Audio_Set_Mute(uint8_t mode) {
   return devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Mute, 5, mode);
 }
 
-bool devTEF_APPL_Set_OperationMode(uint16_t mode)
-{
+bool devTEF_APPL_Set_OperationMode(bool mode) {
   return devTEF_Set_Cmd(TEF_APPL, Cmd_Set_OperationMode, 5, mode);
 }
 
-bool devTEF_APPL_Get_Operation_Status (uint8_t *bootstatus)
-{
+bool devTEF_APPL_Set_StereoImprovement(bool mode) {
+  return devTEF_Set_Cmd(TEF_FM, Cmd_Set_StereoImprovement, 5, mode);
+}
+
+bool devTEF_APPL_Set_StereoBandBlend_Time(uint16_t attack, uint16_t decay) {
+  return devTEF_Set_Cmd(TEF_FM, Cmd_Set_StBandBlend_Time, 7, attack, decay);
+}
+
+bool devTEF_APPL_Set_StereoBandBlend_Gain(uint16_t band1, uint16_t band2, uint16_t band3, uint16_t band4) {
+  return devTEF_Set_Cmd(TEF_FM, Cmd_Set_StBandBlend_Gain, 11, band1, band2, band3, band4);
+}
+
+bool devTEF_APPL_Set_StereoBandBlend_Bias(int16_t band1, int16_t band2, int16_t band3, int16_t band4) {
+  return devTEF_Set_Cmd(TEF_FM, Cmd_Set_StBandBlend_Bias, 11, band1, band2, band3, band4);
+}
+
+bool devTEF_Radio_Set_Softmute_Max_FM(uint8_t mode) {
+  return devTEF_Set_Cmd(TEF_FM, Cmd_Set_Softmute_Max, 7, uint16_t(mode), uint16_t(200));
+}
+
+bool devTEF_Radio_Set_Softmute_Max_AM(uint8_t mode) {
+  return devTEF_Set_Cmd(TEF_AM, Cmd_Set_Softmute_Max, 7, uint16_t(mode), uint16_t(300));
+}
+
+bool devTEF_APPL_Get_Operation_Status (uint8_t *bootstatus) {
   uint8_t buf[2];
   uint16_t r = devTEF_Get_Cmd(TEF_APPL, Cmd_Get_Operation_Status, buf, sizeof(buf));
   *bootstatus = Convert8bto16b(buf);
   return r;
 }
 
-bool devTEF_Radio_Get_Quality_Status (int16_t *level, uint16_t *usn, uint16_t *wam, int16_t *offset, uint16_t *bandwidth, uint16_t *mod)
-{
+bool devTEF_Radio_Get_Processing_Status (uint16_t *highcut, uint16_t *stereo, uint16_t *sthiblend, uint8_t *stband_1, uint8_t *stband_2, uint8_t *stband_3, uint8_t *stband_4) {
+  uint8_t buf[12];
+  uint16_t r = devTEF_Get_Cmd(TEF_FM, Cmd_Get_Processing_Status, buf, sizeof(buf));
+  *highcut = Convert8bto16b(buf + 2) / 10;
+  *stereo = Convert8bto16b(buf + 4) / 10;
+  *sthiblend = Convert8bto16b(buf + 6) / 10;
+  uint16_t stband_1_2 = Convert8bto16b(buf + 8);
+  uint16_t stband_3_4 = Convert8bto16b(buf + 10);
+  *stband_1 = High_16bto8b(stband_1_2);
+  *stband_2 = Low_16bto8b(stband_1_2);
+  *stband_3 = High_16bto8b(stband_3_4);
+  *stband_4 = Low_16bto8b(stband_3_4);
+  return r;
+}
+
+bool devTEF_Radio_Get_Quality_Status (int16_t *level, uint16_t *usn, uint16_t *wam, int16_t *offset, uint16_t *bandwidth, uint16_t *mod) {
   uint8_t buf[14];
-  uint16_t r = devTEF_Get_Cmd(TEF_FM, Cmd_Get_Quality_Status, buf, sizeof(buf));
+  uint16_t r = devTEF_Get_Cmd(TEF_FM, Cmd_Get_Quality_Data, buf, sizeof(buf));
 
   *level = Convert8bto16b(buf + 2);
   *usn = Convert8bto16b(buf + 4);
@@ -165,25 +215,23 @@ bool devTEF_Radio_Get_Quality_Status (int16_t *level, uint16_t *usn, uint16_t *w
   return r;
 }
 
-bool devTEF_Radio_Get_Quality_Status_AM (int16_t *level, uint16_t *usn, uint16_t *wam, int16_t *offset, uint16_t *bandwidth, uint16_t *mod)
-{
+bool devTEF_Radio_Get_Quality_Status_AM (int16_t *level, uint16_t *noise, uint16_t *cochannel, int16_t *offset, uint16_t *bandwidth, uint16_t *mod) {
   uint8_t buf[14];
-  uint16_t r = devTEF_Get_Cmd(TEF_AM, Cmd_Get_Quality_Status, buf, sizeof(buf));
+  uint16_t r = devTEF_Get_Cmd(TEF_AM, Cmd_Get_Quality_Data, buf, sizeof(buf));
 
   *level = Convert8bto16b(buf + 2);
-  *usn = Convert8bto16b(buf + 4);
-  *wam = Convert8bto16b(buf + 6);
+  *noise = Convert8bto16b(buf + 4);
+  *cochannel = Convert8bto16b(buf + 6);
   *offset = Convert8bto16b(buf + 8);
   *bandwidth = Convert8bto16b(buf + 10) / 10;
   *mod = Convert8bto16b(buf + 12) / 10;
   return r;
 }
 
-bool devTEF_Radio_Get_RDS_Data (uint16_t *status, uint16_t *A_block, uint16_t *B_block, uint16_t *C_block, uint16_t *D_block, uint16_t *dec_error)
-{
+
+bool devTEF_Radio_Get_RDS_Data (uint16_t *status, uint16_t *A_block, uint16_t *B_block, uint16_t *C_block, uint16_t *D_block, uint16_t *dec_error) {
   uint8_t buf[12];
   uint8_t r = devTEF_Get_Cmd(TEF_FM, Cmd_Get_RDS_Status, buf, sizeof(buf));
-
   *status = Convert8bto16b(buf);
   *A_block = Convert8bto16b(buf + 2);
   *B_block = Convert8bto16b(buf + 4);
@@ -193,8 +241,7 @@ bool devTEF_Radio_Get_RDS_Data (uint16_t *status, uint16_t *A_block, uint16_t *B
   return r;
 }
 
-bool devTEF_Radio_Get_Stereo_Status(uint16_t *status)
-{
+bool devTEF_Radio_Get_Stereo_Status(uint16_t *status) {
   uint8_t buf[2];
   uint16_t r = devTEF_Get_Cmd(TEF_FM, Cmd_Get_Signal_Status, buf, sizeof(buf));
 
@@ -202,17 +249,7 @@ bool devTEF_Radio_Get_Stereo_Status(uint16_t *status)
   return r;
 }
 
-bool devTEF_Radio_Set_RDS(bool fullsearchrds)
-{
-  if (fullsearchrds == true) {
-    return devTEF_Set_Cmd(TEF_FM, Cmd_Set_RDS, 9, 3, 1, 0);
-  } else {
-    return devTEF_Set_Cmd(TEF_FM, Cmd_Set_RDS, 9, 1, 1, 0);
-  }
-}
-
-bool devTEF_Radio_Get_Identification (uint16_t *device, uint16_t *hw_version, uint16_t *sw_version)
-{
+bool devTEF_Radio_Get_Identification (uint16_t *device, uint16_t *hw_version, uint16_t *sw_version) {
   uint8_t buf[6];
   uint16_t r = devTEF_Get_Cmd(TEF_APPL, Cmd_Get_Identification, buf, sizeof(buf));
 
@@ -222,13 +259,12 @@ bool devTEF_Radio_Get_Identification (uint16_t *device, uint16_t *hw_version, ui
   return r;
 }
 
-bool devTEF_Radio_Set_Wavegen(bool mode, int16_t amplitude, uint16_t freq)
-{
+bool devTEF_Radio_Set_Wavegen(bool mode, int16_t amplitude, uint16_t freq) {
   if (mode == true) {
-	devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Input, 5, 240);
-	return devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_WaveGen, 15, 5, 0, amplitude*10, freq, amplitude*10 , freq);
+    devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Input, 5, 240);
+    return devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_WaveGen, 15, 5, 0, amplitude * 10, freq, amplitude * 10 , freq);
   } else {
-	devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Input, 5, 0);
-	return devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_WaveGen, 15, 0);
+    devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_Input, 5, 0);
+    return devTEF_Set_Cmd(TEF_AUDIO, Cmd_Set_WaveGen, 15, 0);
   }
-}  
\ No newline at end of file
+}
diff --git a/src/Tuner_Drv_Lithio.h b/src/Tuner_Drv_Lithio.h
index 563ec47..44ff29f 100644
--- a/src/Tuner_Drv_Lithio.h
+++ b/src/Tuner_Drv_Lithio.h
@@ -1,73 +1,103 @@
-typedef enum
-{ TEF_FM    = 32,
-  TEF_AM    = 33,
-  TEF_AUDIO = 48,
-  TEF_APPL  = 64
+typedef enum {
+  TEF_FM                      = 32,
+  TEF_AM                      = 33,
+  TEF_AUDIO                   = 48,
+  TEF_APPL                    = 64
 } TEF_MODULE;
 
-typedef enum
-{ Cmd_Tune_To             =  1,
-  Cmd_Set_Bandwidth       = 10,
-  Cmd_Set_RFAGC           = 11,
-  Cmd_Set_MphSuppression  = 20,
-  Cmd_Set_ChannelEqualizer= 22,
-  Cmd_Set_Deemphasis      = 31,
-  Cmd_Set_LevelOffset     = 39,
-  Cmd_Set_Softmute_Max    = 45,
-  Cmd_Set_Highcut_Level   = 52,
-  Cmd_Set_Highcut_Noise   = 53,
-  Cmd_Set_Highcut_Mph     = 54,
-  Cmd_Set_Highcut_Max     = 55,
-  Cmd_Set_Stereo_Level    = 62,
-  Cmd_Set_Stereo_Noise    = 63,
-  Cmd_Set_Stereo_Mph      = 64,
-  Cmd_Set_Stereo_Min      = 66,
-  Cmd_Set_RDS             = 81,
-  Cmd_Get_Quality_Status  = 128,
-  Cmd_Get_RDS_Status      = 130,
-  Cmd_Get_Signal_Status   = 133
+typedef enum {
+  Cmd_Tune_To                 =  1,
+  Cmd_Set_Bandwidth           = 10,
+  Cmd_Set_RFAGC               = 11,
+  Cmd_Set_Antenna             = 12,
+  Cmd_Set_CoChannelDet        = 14,
+  Cmd_Set_MphSuppression      = 20,
+  Cmd_Set_ChannelEqualizer    = 22,
+  Cmd_Set_NoiseBlanker        = 23,
+  Cmd_Set_NoiseBlanker_Audio  = 24,
+  Cmd_Set_Deemphasis          = 31,
+  Cmd_Set_StereoImprovement   = 32,
+  Cmd_Set_LevelOffset         = 39,
+  Cmd_Set_Softmute_Max        = 45,
+  Cmd_Set_Highcut_Level       = 52,
+  Cmd_Set_Highcut_Noise       = 53,
+  Cmd_Set_Highcut_Mph         = 54,
+  Cmd_Set_Highcut_Max         = 55,
+  Cmd_Set_Stereo_Level        = 62,
+  Cmd_Set_Stereo_Noise        = 63,
+  Cmd_Set_Stereo_Mph          = 64,
+  Cmd_Set_Stereo_Min          = 66,
+  Cmd_Set_StHiBlend_Level     = 72,
+  Cmd_Set_StHiBlend_Noise     = 73,
+  Cmd_Set_StHiBlend_Mph       = 74,
+  Cmd_Set_StHiBlend_Max       = 75,
+  Cmd_Set_RDS                 = 81,
+  Cmd_Set_Specials            = 85,
+  Cmd_Set_StBandBlend_Time    = 90,
+  Cmd_Set_StBandBlend_Gain    = 91,
+  Cmd_Set_StBandBlend_Bias    = 92,
+  Cmd_Get_Quality_Status      = 128,
+  Cmd_Get_Quality_Data        = 129,
+  Cmd_Get_RDS_Status          = 130,
+  Cmd_Get_Signal_Status       = 133,
+  Cmd_Get_Processing_Status   = 134
 } TEF_RADIO_COMMAND;
 
-typedef enum
-{ Cmd_Set_Volume = 10,
-  Cmd_Set_Mute = 11,
-  Cmd_Set_Input = 12,
-  Cmd_Set_WaveGen = 24
+typedef enum {
+  Cmd_Set_Volume              = 10,
+  Cmd_Set_Mute                = 11,
+  Cmd_Set_Input               = 12,
+  Cmd_Set_WaveGen             = 24
 } TEF_AUDIO_COMMAND;
 
-typedef enum
-{
-  Cmd_Set_OperationMode = 1,
-  Cmd_Get_Operation_Status = 128,
-  Cmd_Get_Identification = 130
+typedef enum {
+  Cmd_Set_OperationMode       =   1,
+  Cmd_Get_Operation_Status    = 128,
+  Cmd_Get_Identification      = 130
 } TEF_APPL_COMMAND;
 
+bool devTEF_Radio_Set_RDS(bool fullsearchrds);
+bool devTEF_Radio_Set_Softmute_Max_FM(uint8_t mode);
+bool devTEF_Radio_Set_Softmute_Max_AM(uint8_t mode);
 bool devTEF_Set_Cmd(TEF_MODULE module, uint8_t cmd, uint16_t len, ...);
-bool devTEF_Radio_Tune_To (uint16_t frequency);
-bool devTEF_Radio_Tune_To_AM (uint16_t frequency);
 bool devTEF_Radio_Get_Identification (uint16_t *device, uint16_t *hw_version, uint16_t *sw_version);
+bool devTEF_Radio_Tune_To (uint16_t frequency );
+bool devTEF_Radio_Tune_AM (uint16_t frequency );
 bool devTEF_Radio_Get_Quality_Status (int16_t *level, uint16_t *usn, uint16_t *wam, int16_t *offset, uint16_t *bandwidth, uint16_t *mod);
-bool devTEF_Radio_Get_Quality_Status_AM (int16_t *level, uint16_t *usn, uint16_t *wam, int16_t *offset, uint16_t *bandwidth, uint16_t *mod);
+bool devTEF_Radio_Get_Processing_Status (uint16_t *highcut, uint16_t *stereo, uint16_t *sthiblend, uint8_t *stband_1, uint8_t *stband_2, uint8_t *stband_3, uint8_t *stband_4);
+bool devTEF_Radio_Get_Quality_Status_AM (int16_t *level, uint16_t *noise, uint16_t *cochannel, int16_t *offset, uint16_t *bandwidth, uint16_t *mod);
 bool devTEF_APPL_Get_Operation_Status(uint8_t *bootstatus);
-bool devTEF_Audio_Set_Mute(uint16_t mode);
+bool devTEF_Audio_Set_Mute(uint8_t mode);
 bool devTEF_Audio_Set_Volume(int16_t volume);
 bool devTEF_Radio_Get_Stereo_Status(uint16_t *status);
-bool devTEF_APPL_Set_OperationMode(uint16_t mode);
+bool devTEF_APPL_Set_OperationMode(bool mode);
 bool devTEF_Radio_Get_RDS_Data(uint16_t *status, uint16_t *A_block, uint16_t *B_block, uint16_t *C_block, uint16_t *D_block, uint16_t *dec_error);
-bool devTEF_Radio_Set_Bandwidth(uint16_t mode, uint16_t bandwidth, uint16_t control_sensitivity, uint16_t low_level_sensitivity);
-bool devTEF_Radio_Set_Bandwidth_AM(uint16_t mode, uint16_t bandwidth, uint16_t control_sensitivity, uint16_t low_level_sensitivity);
+bool devTEF_Radio_Set_Bandwidth(uint8_t mode, uint16_t bandwidth, uint16_t control_sensitivity, uint16_t low_level_sensitivity);
+bool devTEF_Radio_Set_BandwidthAM(uint8_t mode, uint16_t bandwidth, uint16_t control_sensitivity, uint16_t low_level_sensitivity);
+bool devTEF_Radio_Set_Noiseblanker_AM(uint8_t mode, uint16_t start);
+bool devTEF_Radio_Set_Attenuator_AM(uint16_t start);
+bool devTEF_Radio_Set_CoChannel_AM(uint16_t start);
 bool devTEF_Radio_Set_LevelOffset(int16_t offset);
-bool devTEF_Radio_Set_Stereo_Level(uint16_t mode, uint16_t start, uint16_t slope);
-bool devTEF_Radio_Set_Stereo_Noise(uint16_t mode, uint16_t start, uint16_t slope);
-bool devTEF_Radio_Set_Stereo_Mph(uint16_t mode, uint16_t start, uint16_t slope);
-bool devTEF_Radio_Set_Stereo_Min(uint16_t mode);
-bool devTEF_Radio_Set_MphSuppression(uint16_t mph);
-bool devTEF_Radio_Set_ChannelEqualizer(uint16_t eq);
-bool devTEF_Radio_Set_RFAGC(uint16_t start);
+bool devTEF_Radio_Set_Stereo_Level(uint8_t mode, uint16_t start, uint16_t slope);
+bool devTEF_Radio_Set_Stereo_Noise(uint8_t mode, uint16_t start, uint16_t slope);
+bool devTEF_Radio_Set_Stereo_Mph(uint8_t mode, uint16_t start, uint16_t slope);
+bool devTEF_Radio_Set_Stereo_Min(bool mode);
+bool devTEF_Radio_Set_MphSuppression(bool mph);
+bool devTEF_Radio_Set_ChannelEqualizer(bool eq);
+bool devTEF_Radio_Set_RFAGC(uint16_t agc);
 bool devTEF_Radio_Set_Deemphasis(uint16_t timeconstant);
-bool devTEF_Radio_Set_Highcut_Max(uint16_t mode, uint16_t limit);
-bool devTEF_Radio_Set_Highcut_Level(uint16_t mode, uint16_t start, uint16_t slope);
-bool devTEF_Radio_Set_Highcut_Noise(uint16_t mode, uint16_t start, uint16_t slope);
-bool devTEF_Radio_Set_Highcut_Mph(uint16_t mode, uint16_t start, uint16_t slope);
-bool devTEF_Radio_Set_RDS(bool fullsearchrds);
-bool devTEF_Radio_Set_Wavegen(bool mode, int16_t amplitude, uint16_t freq);
\ No newline at end of file
+bool devTEF_Radio_Specials(uint16_t audio);
+bool devTEF_APPL_Set_StereoImprovement(bool mode);
+bool devTEF_APPL_Set_StereoBandBlend_Time(uint16_t attack, uint16_t decay);
+bool devTEF_APPL_Set_StereoBandBlend_Gain(uint16_t band1, uint16_t band2, uint16_t band3, uint16_t band4);
+bool devTEF_APPL_Set_StereoBandBlend_Bias(int16_t band1, int16_t band2, int16_t band3, int16_t band4);
+bool devTEF_Radio_Set_Highcut_Max(uint8_t mode, uint16_t limit);
+bool devTEF_Radio_Set_Highcut_Level(uint8_t mode, uint16_t start, uint16_t slope);
+bool devTEF_Radio_Set_Highcut_Noise(uint8_t mode, uint16_t start, uint16_t slope);
+bool devTEF_Radio_Set_Highcut_Mph(uint8_t mode, uint16_t start, uint16_t slope);
+bool devTEF_Radio_Set_StHiBlend_Max(uint8_t mode, uint16_t limit);
+bool devTEF_Radio_Set_StHiBlend_Level(uint8_t mode, uint16_t start, uint16_t slope);
+bool devTEF_Radio_Set_StHiBlend_Noise(uint8_t mode, uint16_t start, uint16_t slope);
+bool devTEF_Radio_Set_StHiBlend_Mph(uint8_t mode, uint16_t start, uint16_t slope);
+bool devTEF_Radio_Set_NoisBlanker(uint8_t mode, uint16_t start);
+bool devTEF_Radio_Set_Wavegen(bool mode, int16_t amplitude, uint16_t freq);
diff --git a/src/Tuner_Interface.cpp b/src/Tuner_Interface.cpp
index 9716888..008d691 100644
--- a/src/Tuner_Interface.cpp
+++ b/src/Tuner_Interface.cpp
@@ -4,9 +4,6 @@
 #include "Tuner_Patch_Lithio_V205_p512.h"
 #include <Wire.h>
 
-bool debug_tx = false;
-bool debug_rx = false;
-
 static const unsigned char tuner_init_tab[] = {
   7, 0x20, 0x0B, 0x01, 0x03, 0x98, 0x00, 0x00,
   5, 0x20, 0x14, 0x01, 0x00, 0x00,
@@ -52,51 +49,24 @@ static const unsigned char tuner_init_tab9216[] = {
   2, 0xff, 100,
 };
 
-bool Tuner_WriteBuffer(unsigned char *buf, uint16_t len)
-{
+bool Tuner_WriteBuffer(unsigned char *buf, uint16_t len) {
   Wire.beginTransmission(0x64);
-  if (debug_tx == true) {
-    Serial.println();
-  }
-  for (uint16_t i = 0; i < len; i++) {
-    if (debug_tx == true) {
-      if (buf[i] < 0x10) {
-        Serial.print("0");
-      }
-      Serial.print(buf[i], HEX);
-      Serial.print(" ");
-    }
-    Wire.write(buf[i]);
-  }
+  for (uint16_t i = 0; i < len; i++) Wire.write(buf[i]);
   uint8_t r = Wire.endTransmission();
   delay(2);
   return (r == 0) ? 1 : 0;
 }
 
-bool Tuner_ReadBuffer(unsigned char *buf, uint16_t len)
-{
+bool Tuner_ReadBuffer(unsigned char *buf, uint16_t len) {
   Wire.requestFrom(0x64, len);
-  if (debug_rx == true) {
-    Serial.println();
-  }
   if (Wire.available() == len) {
-    for (uint16_t i = 0; i < len; i++) {
-      if (debug_rx == true) {
-        if (buf[i] < 0x10) {
-          Serial.print("0");
-        }
-        Serial.print(buf[i], HEX);
-        Serial.print(" ");
-      }
-      buf[i] = Wire.read();
-    }
+    for (uint16_t i = 0; i < len; i++) buf[i] = Wire.read();
     return 1;
   }
   return 0;
 }
 
-bool Tuner_Patch_Load(const unsigned char *pLutBytes, uint16_t size)
-{
+bool Tuner_Patch_Load(const unsigned char *pLutBytes, uint16_t size) {
   unsigned char buf[24 + 1];
   uint16_t i, len;
   uint16_t r;
@@ -107,24 +77,17 @@ bool Tuner_Patch_Load(const unsigned char *pLutBytes, uint16_t size)
     len = (size > 24) ? 24 : size;
     size -= len;
 
-    for (i = 0; i < len; i++)
-      buf[1 + i] = pLutBytes[i];
-
+    for (i = 0; i < len; i++) buf[1 + i] = pLutBytes[i];
     pLutBytes += len;
 
-    if (1 != (r = Tuner_WriteBuffer(buf, len + 1)))
-    {
-      break;
-    }
+    if (1 != (r = Tuner_WriteBuffer(buf, len + 1))) break;
   }
   return r;
 }
 
 
-bool Tuner_Table_Write(const unsigned char *tab)
-{
-  if (tab[1] == 0xff)
-  {
+bool Tuner_Table_Write(const unsigned char *tab) {
+  if (tab[1] == 0xff) {
     delay(tab[2]);
     return 1;
   } else {
@@ -152,12 +115,18 @@ void Tuner_Patch(byte TEF) {
   Wire.write(0x00);
   Wire.write(0x74);
   Wire.endTransmission();
-  if (TEF == 101) {
-    Tuner_Patch_Load(pPatchBytes101, PatchSize101);
-  } else if (TEF == 102) {
-    Tuner_Patch_Load(pPatchBytes102, PatchSize102);
-  } else if (TEF == 205) {
-    Tuner_Patch_Load(pPatchBytes205, PatchSize205);
+  switch (TEF) {
+    case 101:
+      Tuner_Patch_Load(pPatchBytes101, PatchSize101);
+      break;
+
+    case 102:
+      Tuner_Patch_Load(pPatchBytes102, PatchSize102);
+      break;
+
+    case 205:
+      Tuner_Patch_Load(pPatchBytes205, PatchSize205);
+      break;
   }
   Wire.beginTransmission(0x64);
   Wire.write(0x1c);
@@ -170,12 +139,18 @@ void Tuner_Patch(byte TEF) {
   Wire.write(0x00);
   Wire.write(0x75);
   Wire.endTransmission();
-  if (TEF == 101) {
-    Tuner_Patch_Load(pLutBytes101, LutSize101);
-  } else if (TEF == 102) {
-    Tuner_Patch_Load(pLutBytes102, LutSize102);
-  } else if (TEF == 205) {
-    Tuner_Patch_Load(pLutBytes205, LutSize205);
+  switch (TEF) {
+    case 101:
+      Tuner_Patch_Load(pLutBytes101, LutSize101);
+      break;
+
+    case 102:
+      Tuner_Patch_Load(pLutBytes102, LutSize102);
+      break;
+
+    case 205:
+      Tuner_Patch_Load(pLutBytes205, LutSize205);
+      break;
   }
   Wire.beginTransmission(0x64);
   Wire.write(0x1c);
@@ -193,10 +168,8 @@ bool Tuner_Init(void) {
   uint16_t r;
   const unsigned char *p = tuner_init_tab;
 
-  for (uint16_t i = 0; i < sizeof(tuner_init_tab); i += (p[i] + 1))
-  {
-    if (1 != (r = Tuner_Table_Write(p + i)))
-      break;
+  for (uint16_t i = 0; i < sizeof(tuner_init_tab); i += (p[i] + 1)) {
+    if (1 != (r = Tuner_Table_Write(p + i))) break;
   }
   return r;
 }
@@ -205,10 +178,8 @@ bool Tuner_Init4000(void) {
   uint16_t r;
   const unsigned char *p = tuner_init_tab4000;
 
-  for (uint16_t i = 0; i < sizeof(tuner_init_tab4000); i += (p[i] + 1))
-  {
-    if (1 != (r = Tuner_Table_Write(p + i)))
-      break;
+  for (uint16_t i = 0; i < sizeof(tuner_init_tab4000); i += (p[i] + 1)) {
+    if (1 != (r = Tuner_Table_Write(p + i))) break;
   }
   return r;
 }
@@ -217,10 +188,8 @@ bool Tuner_Init9216(void) {
   uint16_t r;
   const unsigned char *p = tuner_init_tab9216;
 
-  for (uint16_t i = 0; i < sizeof(tuner_init_tab9216); i += (p[i] + 1))
-  {
-    if (1 != (r = Tuner_Table_Write(p + i)))
-      break;
+  for (uint16_t i = 0; i < sizeof(tuner_init_tab9216); i += (p[i] + 1)) {
+    if (1 != (r = Tuner_Table_Write(p + i))) break;
   }
   return r;
 }
diff --git a/src/Tuner_Patch_Lithio_V101_p119.h b/src/Tuner_Patch_Lithio_V101_p119.h
index 57744ca..e2ac08a 100644
--- a/src/Tuner_Patch_Lithio_V101_p119.h
+++ b/src/Tuner_Patch_Lithio_V101_p119.h
@@ -1,7 +1,6 @@
 extern const size_t PatchSize101;
 extern const unsigned char *pPatchBytes101;
-static const unsigned char PatchByteValues101[] =
-{
+static const unsigned char PatchByteValues101[] = {
   0xF0, 0x00, 0x38, 0x40, 0xD0, 0x80, 0x32, 0x81, 0x38, 0x58, 0xD0, 0x80, 0xF0, 0x00, 0x38, 0x52, 0xD0, 0x80, 0xF0, 0x00, 0x38, 0x64, 0xD0, 0x80,
   0xC4, 0xCB, 0x38, 0x68, 0xD0, 0x80, 0x80, 0x20, 0x38, 0xA9, 0xD0, 0x80, 0x90, 0x41, 0x38, 0xAE, 0xD0, 0x80, 0xF0, 0x00, 0x38, 0xB7, 0xD0, 0x80,
   0x80, 0x08, 0x38, 0xD8, 0xD0, 0x80, 0xF0, 0x00, 0x39, 0x2D, 0xD0, 0x80, 0xF0, 0x00, 0x3B, 0x55, 0xD0, 0x80, 0xF0, 0x00, 0x3B, 0x57, 0xD0, 0x80,
@@ -252,8 +251,7 @@ const unsigned char * pPatchBytes101 = &PatchByteValues101[0];
 
 extern const size_t LutSize101;
 extern const unsigned char * pLutBytes101;
-static unsigned char LutByteValues101[] =
-{
+static unsigned char LutByteValues101[] = {
   0x40, 0x13, 0x46, 0xEA, 0x47, 0x07, 0x48, 0x2E,
   0x48, 0x4D, 0x4C, 0x45, 0x4D, 0x20, 0x4F, 0x78,
   0x50, 0x33, 0x53, 0xC7, 0x54, 0x0F, 0x54, 0x10,
diff --git a/src/Tuner_Patch_Lithio_V102_p224.h b/src/Tuner_Patch_Lithio_V102_p224.h
index 139a1d7..03dbea7 100644
--- a/src/Tuner_Patch_Lithio_V102_p224.h
+++ b/src/Tuner_Patch_Lithio_V102_p224.h
@@ -1,7 +1,6 @@
 extern const size_t PatchSize102;
 extern const unsigned char *pPatchBytes102;
-static const unsigned char PatchByteValues102[] =
-{
+static const unsigned char PatchByteValues102[] = {
   0xF0, 0x00, 0x38, 0x3B, 0xD0, 0x80, 0xF0, 0x00, 0x38, 0x43, 0xD0, 0x80, 0x43, 0xB2, 0x38, 0x46, 0xD0, 0x80, 0xF0, 0x00, 0x70, 0x00, 0xC2, 0xF7,
   0xF0, 0x00, 0x38, 0x77, 0xD0, 0x80, 0xF0, 0x00, 0x38, 0x7B, 0xDF, 0x80, 0x80, 0xFC, 0x39, 0x0E, 0xD0, 0x80, 0xC2, 0x38, 0x20, 0x11, 0x40, 0xB7,
   0x9F, 0xA7, 0x39, 0x13, 0xD2, 0x80, 0x9F, 0xA7, 0x39, 0x1D, 0xD2, 0x80, 0xF0, 0x00, 0x39, 0x24, 0xD0, 0x80, 0xF0, 0x00, 0x39, 0x27, 0xD0, 0x80,
@@ -264,8 +263,7 @@ const unsigned char * pPatchBytes102 = &PatchByteValues102[0];
 
 extern const size_t LutSize102;
 extern const unsigned char * pLutBytes102;
-static unsigned char LutByteValues102[] =
-{
+static unsigned char LutByteValues102[] = {
   0x40, 0x13, 0x40, 0x2F, 0x41, 0x68, 0x41, 0xC1,
   0x42, 0x14, 0x42, 0xA6, 0x44, 0xDE, 0x44, 0xE9,
   0x45, 0xFB, 0x46, 0x11, 0x47, 0xC5, 0x47, 0xFC,
diff --git a/src/Tuner_Patch_Lithio_V205_p512.h b/src/Tuner_Patch_Lithio_V205_p512.h
index 09547f3..13df9a2 100644
--- a/src/Tuner_Patch_Lithio_V205_p512.h
+++ b/src/Tuner_Patch_Lithio_V205_p512.h
@@ -1,7 +1,6 @@
 extern const size_t PatchSize205;
 extern const unsigned char *pPatchBytes205;
-static const unsigned char PatchByteValues205[] =
-{
+static const unsigned char PatchByteValues205[] = {
   0xF0, 0x00, 0x60, 0x40, 0xD0, 0x80, 0x20, 0x87, 0x60, 0x4C, 0xD0, 0x80, 0x90, 0x00, 0x60, 0x4E, 0xD0, 0x80, 0x22, 0x02, 0x00, 0x55, 0x60, 0x04,
   0xF0, 0x00, 0x60, 0x65, 0xDF, 0x80, 0xF0, 0x00, 0x05, 0xBA, 0x60, 0x0E, 0x20, 0x90, 0x60, 0x9B, 0xD0, 0x80, 0x31, 0x40, 0x60, 0x9F, 0xD0, 0x80,
   0x9E, 0xB9, 0x60, 0xAD, 0xD0, 0x80, 0xF0, 0x00, 0x60, 0xAF, 0xD0, 0x80, 0x20, 0x15, 0x60, 0xB3, 0xD2, 0x80, 0xF0, 0x00, 0x60, 0xCE, 0xD0, 0x80,
@@ -249,23 +248,12 @@ const unsigned char * pPatchBytes205 = &PatchByteValues205[0];
 
 extern const size_t LutSize205;
 extern const unsigned char * pLutBytes205;
-static unsigned char LutByteValues205[] =
-{
-  0x80, 0x17, 0x80, 0x45, 0x80, 0x96, 0x81, 0x5B,
-  0x82, 0xD6, 0x83, 0x76, 0x88, 0x0B, 0x88, 0x10,
-  0x88, 0xDB, 0x89, 0x48, 0x89, 0xE9, 0x8B, 0x0A,
-  0x8B, 0x12, 0x8B, 0x13, 0x8B, 0x21, 0x8B, 0x26,
-  0x8C, 0x6F, 0x8F, 0x91, 0x8F, 0xF6, 0x94, 0xD0,
-  0x95, 0x20, 0x95, 0x33, 0x95, 0x6F, 0x95, 0xA8,
-  0x95, 0xAC, 0x95, 0xC3, 0x95, 0xE1, 0x97, 0xC9,
-  0x97, 0xF6, 0x98, 0x8D, 0x99, 0x00, 0x9A, 0x00,
-  0x9E, 0x73, 0xA0, 0x12, 0xA1, 0x03, 0xA1, 0x68,
-  0xA2, 0xF0, 0xA3, 0x0D, 0xA3, 0x4C, 0xA3, 0x52,
-  0xA3, 0xED, 0xA5, 0x20, 0xA5, 0x25, 0xA6, 0x0F,
-  0xA6, 0x1D, 0xA8, 0x31, 0xAB, 0x01, 0xAB, 0x1F,
-  0xAB, 0x4C, 0xAC, 0x76, 0xAC, 0x88, 0xAC, 0x97,
-  0xAD, 0xB0, 0xAD, 0xB7, 0xAD, 0xB8, 0xB0, 0x55,
-  0xB0, 0xC6, 0xB0, 0xE2, 0xB1, 0x01, 0xB1, 0x0B,
+static unsigned char LutByteValues205[] = {
+  0x80, 0x17, 0x80, 0x45, 0x80, 0x96, 0x81, 0x5B, 0x82, 0xD6, 0x83, 0x76, 0x88, 0x0B, 0x88, 0x10, 0x88, 0xDB, 0x89, 0x48, 0x89, 0xE9, 0x8B, 0x0A,
+  0x8B, 0x12, 0x8B, 0x13, 0x8B, 0x21, 0x8B, 0x26, 0x8C, 0x6F, 0x8F, 0x91, 0x8F, 0xF6, 0x94, 0xD0, 0x95, 0x20, 0x95, 0x33, 0x95, 0x6F, 0x95, 0xA8,
+  0x95, 0xAC, 0x95, 0xC3, 0x95, 0xE1, 0x97, 0xC9, 0x97, 0xF6, 0x98, 0x8D, 0x99, 0x00, 0x9A, 0x00, 0x9E, 0x73, 0xA0, 0x12, 0xA1, 0x03, 0xA1, 0x68,
+  0xA2, 0xF0, 0xA3, 0x0D, 0xA3, 0x4C, 0xA3, 0x52, 0xA3, 0xED, 0xA5, 0x20, 0xA5, 0x25, 0xA6, 0x0F, 0xA6, 0x1D, 0xA8, 0x31, 0xAB, 0x01, 0xAB, 0x1F,
+  0xAB, 0x4C, 0xAC, 0x76, 0xAC, 0x88, 0xAC, 0x97, 0xAD, 0xB0, 0xAD, 0xB7, 0xAD, 0xB8, 0xB0, 0x55, 0xB0, 0xC6, 0xB0, 0xE2, 0xB1, 0x01, 0xB1, 0x0B,
   0xB1, 0x35, 0xB1, 0x3B, 0xB1, 0x97, 0xB3, 0x03
 };