diff --git a/README.md b/README.md
index 8309ca7..eb0ee67 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,21 @@
 # ESP32Radio-V2
-New version of the well known ESP32 Radio.  Now optional I2S output!
+New version of the well known ESP32 Radio.  Now optional I2S output and SP/DIF output!
 - Compile time configuration in config.h.
 - Do not forget to upload the data directory to the ESP32.
 - SD cards supported, but still experimental.
 
+![SAM_2922](https://github.com/Edzelf/ESP32Radio-V2/assets/18257026/a58f7b7e-cdd4-4d7f-96b8-62fa487de906)
+
 Updates:
+- 17-oct-2024: Experimental support for ESP32-S3. SP/DIF tested.
+- 05-jul-2024: Correction SPDIF output.
+- 12-mar-2024: Add document with building instructions.  New PCB available! See [here at PCBWay](https://www.pcbway.com/project/shareproject/W652317AS2P1_Gerber_ESP32_Radio_PCB_ESP32_Radio_fab8a6d9.html).
+- 19-feb-2024: SP/DIF (Toslink) output, fixed mono bug.
+- 26-dec-2023: Correct crash with VS1053 and empty preferences.
+- 14-dec-2023: Add "mqttrefresh" command to refresh all mqtt items.
+- 09-oct-2023: Reduced error messages caused by uninitialized GPIO numbers.
+- 16-may-2023: Added sleep command.
+- 05-may-2023: SD card file stored on SD card, mute/unmute, better mutex.
 - 24-mar-2023: Code clean-up
 - 03-nov-2022: Added AI Thinker Audio kit V2.1 suport.
 - 05-oct-2021: Fixed internal DAC output, fixed OTA upload.
diff --git a/archive/ESP32Radio.zip b/archive/ESP32Radio.zip
new file mode 100644
index 0000000..4b5af64
Binary files /dev/null and b/archive/ESP32Radio.zip differ
diff --git a/archive/readme.md b/archive/readme.md
new file mode 100644
index 0000000..ae73b8c
--- /dev/null
+++ b/archive/readme.md
@@ -0,0 +1,7 @@
+ESP32Radio.zip Contains the project as an Arduino sketch.
+Edit config.h for your configuration....
+Enable core debug level "Info" in the tools menu.
+
+There is no simple way to upload the SPIFFS files in version 2 of the Arduino IDE, so use version 1.
+
+
diff --git a/data/about.html b/data/about.html
index de2d240..4a05580 100644
--- a/data/about.html
+++ b/data/about.html
@@ -16,14 +16,13 @@
   </ul>
   <br><br><br>
   <center>
-   <h1>** ESP32 Radio **</h1>
+   <h1>** ESP32 Radio V2 **</h1>
   </center>
 	<p>ESP32 Radio V2 -- Web radio receiver for ESP32, Color display and VS1053 MP3 module.<br>
-  I2S output instead of VS1053 is also supported.<br>
+  I2S and SPDIF output instead of VS1053 is also supported.<br>
 	This project is documented at <a target="blank" href="https://github.com/Edzelf/ESP32Radio-V2">Github</a>.</p>
 	<p>Author: Ed Smallenburg (ed@smallenburg.nl)<br>
-	Webinterface design: <a target="blank" href="http://www.sanderjochems.nl/">Sander Jochems</a><br>
 	App (Android): <a target="blank" href="https://play.google.com/store/apps/details?id=com.thunkable.android.sander542jochems.ESP_Radio">Sander Jochems</a><br>
-	Date: January 2022</p>
+	Date: January 2022 - May 2023</p>
  </body>
 </html>
diff --git a/data/config.html b/data/config.html
index 8f52cdb..46ed51b 100644
--- a/data/config.html
+++ b/data/config.html
@@ -19,9 +19,6 @@
    <h1>** ESP32 Radio **</h1>
    <p>You can edit the configuration here. <i>Note that this will be effective on the next restart of the radio.</i>
    </p>
-   <h3>Available WiFi networks
-   <select class="select" onChange="handletone(this)" id="ssid"></select>
-   </h3>
    <textarea rows="20" cols="100" id="prefs">Loading preferences</textarea> 
    <br>
    <button class="button" onclick="fsav()">Save</button>
@@ -31,11 +28,11 @@ <h3>Available WiFi networks
    <button class="button" onclick="ldef('getdefs')">Default</button>
     <br><input type="text" size="80" id="resultstr" placeholder="Waiting for input....">
     <br>
-
+  </center>
     <script>
       function httpGet ( theReq )
       {
-        var theUrl = "/?" + theReq + "&version=" + Math.random() ;
+        var theUrl = "/" + theReq + "?version=" + Math.random() ;
         var xhr = new XMLHttpRequest() ;
         xhr.onreadystatechange = function() {
           if ( xhr.readyState == XMLHttpRequest.DONE )
@@ -100,30 +97,8 @@ <h3>Available WiFi networks
         xhr.setRequestHeader ( "Content-type", "application/x-www-form-urlencoded" ) ;
         xhr.send() ;
       }
-
       // Fill configuration initially
-      // First the available WiFi networks
-      var i, select, opt, networks, params ;
-
-      select = document.getElementById("selnet") ;
-      var theUrl = "/?getnetworks" + "&version=" + Math.random() ;
-      var xhr = new XMLHttpRequest() ;
-      xhr.onreadystatechange = function() {
-        if ( xhr.readyState == XMLHttpRequest.DONE )
-        {
-          networks = xhr.responseText.split ( "|" ) ;
-          for ( i = 0 ; i < ( networks.length - 1 ) ; i++ )
-          {
-            opt = document.createElement( "OPTION" ) ;
-            opt.value = i ;
-            opt.text = networks[i] ;
-            ssid.add( opt ) ;
-          }
-        }
-      }
-      xhr.open ( "GET", theUrl, false ) ;
-      xhr.send() ;
-      // Now get the configuration parameters from preferences
+      // Get the configuration parameters from preferences
       ldef ( "getprefs" ) ;
     </script>
   </body>
diff --git a/data/defaultprefs.txt b/data/defaultprefs.txt
index 934ed5a..078a863 100644
--- a/data/defaultprefs.txt
+++ b/data/defaultprefs.txt
@@ -1,12 +1,15 @@
 # Example configuration
 # Programmable input pins:
 gpio_00 = uppreset = 1
-gpio_12 = upvolume = 2
-gpio_13 = downvolume = 2
-gpio_14 = stop
+gpio_25 = upvolume = 2
+gpio_33 = downvolume = 2
+gpio_16 = stop
 gpio_17 = resume
-gpio_34 = station = icecast.omroep.nl:80/radio1-bb-mp3
+gpio_21 = station = icecast.omroep.nl:80/radio1-bb-mp3
 #
+# Battery monitor
+batt100 = 2950
+batt0 = 2600 
 # MQTT settings
 mqttbroker = none
 mqttport = 1883
@@ -27,37 +30,38 @@ preset = 6
 # Some preset examples
 preset_00 = 109.206.96.34:8100                       #  0 - NAXI LOVE RADIO, Belgrade, Serbia
 preset_01 = airspectrum.cdnstream1.com:8114/1648_128 #  1 - Easy Hits Florida 128k
-preset_02 = us2.internet-radio.com:8050              #  2 - CLASSIC ROCK MIAMI 256k
+preset_02 = stream.hitfm.de:9050/live                #  2 - 89 HIT FM - Munichs Power Station, 128k
 preset_03 = airspectrum.cdnstream1.com:8000/1261_192 #  3 - Magic Oldies Florida
 preset_04 = airspectrum.cdnstream1.com:8008/1604_128 #  4 - Magic 60s Florida 60s Classic Rock
 preset_05 = us1.internet-radio.com:8105              #  5 - Classic Rock Florida - SHE Radio
-preset_06 = icecast.omroep.nl:80/radio1-bb-mp3       #  6 - Radio 1, NL
+preset_06 = icecast.omroep.nl:80/radio1-bb-mp3       #  6 - Radio 1, NL, 192k
 preset_07 = 205.164.62.15:10032                      #  7 - 1.FM - GAIA, 64k
-preset_08 = skonto.ls.lv:8002/mp3                    #  8 - Skonto 128k
-preset_09 = 94.23.66.155:8106                        #  9 - *ILR CHILL and GROOVE
-preset_10 = ihr/IHR_IEDM                             # 10 - iHeartRadio IHR_IEDM
-preset_11 = ihr/IHR_TRAN                             # 11 - iHeartRadio IHR_TRAN
+preset_08 = www.doowopradio.com:8000                 #  8 - Doo-Wop Radio, 96k
+preset_09 = server-27.stream-server.nl:8192/stream   #  9 - 192 Radio Nederland, 320k
 #
 # Clock offset and daylight saving time
 clk_server = pool.ntp.org                            # Time server to be used
 clk_offset = 1                                       # Offset with respect to UTC in hours
 clk_dst = 1                                          # Offset during daylight saving time (hours)
-# Some IR codes
+# Some example IR codes
 ir_40BF = upvolume = 2
 ir_C03F = downvolume = 2
 # GPIO pinnings
 pin_ir = 35                                          # GPIO Pin number for IR receiver VS1838B
-pin_enc_clk = 25                                     # GPIO Pin number for rotary encoder "CLK"
-pin_enc_dt = 26                                      # GPIO Pin number for rotary encoder "DT"
-pin_enc_sw = 27                                      # GPIO Pin number for rotary encoder "SW"
+pin_enc_clk = 12                                     # GPIO Pin number for rotary encoder "CLK"
+pin_enc_dt = 14                                      # GPIO Pin number for rotary encoder "DT"
+pin_enc_sw = 13                                      # GPIO Pin number for rotary encoder "SW"
 #
-pin_tft_cs = 15                                      # GPIO Pin number for TFT "CS"
-pin_tft_dc = 2                                       # GPIO Pin number for TFT "DC"
+pin_tft_cs = 2                                       # GPIO Pin number for TFT "CS"
+pin_tft_dc = 4                                       # GPIO Pin number for TFT "DC"
 #
+# define pins for decoder.  Examples for VS1053, I2S and Toslink
 pin_vs_cs = 5                                        # GPIO Pin number for VS1053 "CS"
 pin_vs_dcs = 32                                      # GPIO Pin number for VS1053 "DCS"
-pin_vs_dreq = 4                                      # GPIO Pin number for VS1053 "DREQ"
+pin_vs_dreq = 15                                     # GPIO Pin number for VS1053 "DREQ"
 #
-pin_i2s_bck = 5                                      # GPIO Pin number for I2S "BCK"
-pin_i2s_lck = 32                                     # GPIO Pin number for I2S "L(R)CK"
-pin_i2s_din = 4                                      # GPIO Pin number for I2S "DIN"
+#pin_i2s_bck = 15                                    # GPIO Pin number for I2S "BCK"
+#pin_i2s_lck = 27                                    # GPIO Pin number for I2S "L(R)CK"
+#pin_i2s_din = 26                                    # GPIO Pin number for I2S "DIN"
+#
+#pin_i2s_spdif = 15                                  # GPIO Pin number for I2S/SPDIF (Toslink)
diff --git a/data/index.html b/data/index.html
index def2728..b31e13f 100644
--- a/data/index.html
+++ b/data/index.html
@@ -21,9 +21,12 @@ <h1>** ESP32 Radio **</h1>
    <button class="button" onclick="httpGet('uppreset=1')">NEXT</button>
    <button class="button" id="volmin" onclick="httpGet('downvolume=2')">VOL-</button>
    <button class="button" id="volplus" onclick="httpGet('upvolume=2')">VOL+</button>
-   <button class="button" onclick="httpGet('mute')">(un)MUTE</button>
    <button class="button" onclick="httpGet('status')">STATUS</button>
    <button class="button" onclick="httpGet('test')">TEST</button>
+   <br>
+   <button class="button" onclick="httpGet('mute')">MUTE</button>
+   <button class="button" onclick="httpGet('unmute')">UNMUTE</button>
+   <button class="button" onclick="httpGet('sleep')">SLEEP</button>
    <table id="t1" style="width:500px">
     <tr>
      <td colspan="2"><center>
@@ -63,21 +66,21 @@ <h1>** ESP32 Radio **</h1>
       <label for="HF"><big>Treble Freq:</big></label>
       <br>
       <select class="select" onChange="handletone(this)" id="tonehf">
-        <option value="1">1 kHz</option>
-        <option value="2">2 kHz</option>
-        <option value="3">3 kHz</option>
-        <option value="4">4 kHz</option>
-        <option value="5">5 kHz</option>
-        <option value="6">6 kHz</option>
-        <option value="7">7 kHz</option>
-        <option value="8">8 kHz</option>
-        <option value="9">9 kHz</option>
-        <option value="10">10 kHz</option>
-        <option value="11">11 kHz</option>
-        <option value="12">12 kHz</option>
-        <option value="13">13 kHz</option>
-        <option value="14">14 kHz</option>
-        <option value="15">15 kHz</option>
+       <option value="1">1 kHz</option>
+       <option value="2">2 kHz</option>
+       <option value="3">3 kHz</option>
+       <option value="4">4 kHz</option>
+       <option value="5">5 kHz</option>
+       <option value="6">6 kHz</option>
+       <option value="7">7 kHz</option>
+       <option value="8">8 kHz</option>
+       <option value="9">9 kHz</option>
+       <option value="10">10 kHz</option>
+       <option value="11">11 kHz</option>
+       <option value="12">12 kHz</option>
+       <option value="13">13 kHz</option>
+       <option value="14">14 kHz</option>
+       <option value="15">15 kHz</option>
       </select>
       <br><br> 
      </center></td>
@@ -139,10 +142,10 @@ <h1>** ESP32 Radio **</h1>
    <br><br>
    <p>Find new radio stations at <a target="blank" href="http://www.internet-radio.com">http://www.internet-radio.com</a><br>
       or use the Search function from the menu.</p>
-   <p>Examples: us5.internet-radio.com:8121, 1a-60er.radionetz.de/1a-60er.mp3, 85.17.121.103:8800</p><br>
+   <br><br>
   </center>
   <script>
-   function httpGet ( theReq )
+    function httpGet ( theReq )
    {
     var theUrl = "/?" + theReq + "&version=" + Math.random() ;
     var xhr = new XMLHttpRequest() ;
@@ -212,7 +215,6 @@ <h1>** ESP32 Radio **</h1>
    }
 
    // Fill preset list initially
-   //
    function onloadfunc()
    {
      var i, sel, opt, lines, parts ;
@@ -224,30 +226,30 @@ <h1>** ESP32 Radio **</h1>
          lines = xhr.responseText.split ( "\n" ) ;
          for ( i = 0 ; i < ( lines.length-1 ) ; i++ )
          {
-           sel = document.getElementById ( "preset" ) ;
-           parts = lines[i].split ( "=" ) ;
-           if ( parts[0].indexOf ( "preset_" ) == 0 )
-           {
-             opt = document.createElement ( "OPTION" ) ;
-             opt.value = parts[0].substring ( 7 ) ;
-             opt.text = parts[1] ;
-             sel.add( opt ) ;
-           }
-           if ( ( parts[0].indexOf ( "tone" ) == 0 ) ||
-                ( parts[0] == "preset" ) )
-           {
-             selectItemByValue ( parts[0], parts[1] ) ;
-           }
-           // No tone settings if no VS1053 decoder 
-           if ( parts[0].indexOf ( "decoder" ) == 0 )
+          sel = document.getElementById ( "preset" ) ;
+          parts = lines[i].split ( "=" ) ;
+          if ( parts[0].indexOf ( "preset_" ) == 0 )
+          {
+           opt = document.createElement ( "OPTION" ) ;
+           opt.value = parts[0].substring ( 7 ) ;
+           opt.text = parts[1] ;
+           sel.add( opt ) ;
+          }
+          if ( ( parts[0].indexOf ( "tone" ) == 0 ) ||
+               ( parts[0] == "preset" ) )
+          {
+           selectItemByValue ( parts[0], parts[1] ) ;
+          }
+          // No tone settings if no VS1053 decoder 
+          if ( parts[0].indexOf ( "decoder" ) == 0 )
+          {
+           if ( parts[1].indexOf ( "helix" ) == 0 )
            {
-             if ( parts[1].indexOf ( "helix" ) == 0 )
-             {
-              var toneobj = document.getElementById("t1") ;
-              toneobj.deleteRow(2);
-              toneobj.deleteRow(1);
-             }
+           var toneobj = document.getElementById("t1") ;
+            toneobj.deleteRow(2);
+            toneobj.deleteRow(1);
            }
+          }
          }
          setTimeout(myRefresh,5000) ;
        }
diff --git a/data/search.html b/data/search.html
index 60a1958..995978f 100644
--- a/data/search.html
+++ b/data/search.html
@@ -33,7 +33,8 @@ <h1>** ESP32 Radio search stations **</h1>
    <td><button class="button" onclick="listStats('reggae')">Reggae</button></td>
    <td><button class="button" onclick="listStats('funk')">Funk</button></td>
    <td><button class="button" onclick="listStats('top')">Top</button></td>
-   <td><button class="button" onclick="listStats('synth')">Synth</button></td><tr>
+   <td><button class="button" onclick="listStats('synth')">Synth</button></td>
+   <td><button class="button" onclick="listStats('country')">Country</button></td><tr>
    <td><button class="button" onclick="listStats('fantasy')">Fantasy</button></td>
    <td><button class="button" onclick="listStats('rain')">Rain</button></td>
    <td><button class="button" onclick="listStats('ambient')">Ambient</button></td>
diff --git a/doc/ESP32-Radio.dip b/doc/ESP32-Radio.dip
deleted file mode 100644
index 026d4b1..0000000
Binary files a/doc/ESP32-Radio.dip and /dev/null differ
diff --git a/doc/ESP32-radio buiding instructions.odt b/doc/ESP32-radio buiding instructions.odt
new file mode 100644
index 0000000..cbde1c4
Binary files /dev/null and b/doc/ESP32-radio buiding instructions.odt differ
diff --git a/doc/ESP32-radio buiding instructions.pdf b/doc/ESP32-radio buiding instructions.pdf
new file mode 100644
index 0000000..bd554a0
Binary files /dev/null and b/doc/ESP32-radio buiding instructions.pdf differ
diff --git a/doc/ESP32-radio.odt b/doc/ESP32-radio.odt
index 60d9dad..6576042 100644
Binary files a/doc/ESP32-radio.odt and b/doc/ESP32-radio.odt differ
diff --git a/doc/ESP32-radio.pdf b/doc/ESP32-radio.pdf
index 857286c..3331059 100644
Binary files a/doc/ESP32-radio.pdf and b/doc/ESP32-radio.pdf differ
diff --git a/doc/Gerber_ESP32-Radio_PCB_ESP32-Radio.zip b/doc/Gerber_ESP32-Radio_PCB_ESP32-Radio.zip
new file mode 100644
index 0000000..8fe699d
Binary files /dev/null and b/doc/Gerber_ESP32-Radio_PCB_ESP32-Radio.zip differ
diff --git a/doc/Schematic_ESP32-Radio_2024-12-17.png b/doc/Schematic_ESP32-Radio_2024-12-17.png
new file mode 100644
index 0000000..3a8e165
Binary files /dev/null and b/doc/Schematic_ESP32-Radio_2024-12-17.png differ
diff --git a/doc/example config.ed.txt b/doc/example config.ed.txt
index 60a40e8..2b46877 100644
--- a/doc/example config.ed.txt	
+++ b/doc/example config.ed.txt	
@@ -15,10 +15,8 @@ mqttpasswd = none
 mqttport = 1883
 mqttuser = carol
 #
-ota = 1
-#
 pin_enc_clk = 12     # GPIO rotary encoder CLK
-pin_enc_dt = 27      # GPIO rotary encoder DT
+pin_enc_dt = 14      # GPIO rotary encoder DT
 pin_enc_sw = 13      # GPIO rotary encoder SW
 pin_ir = 35          # GPIO IR receiver VS1838B
 pin_sd_cs = 14       # SD card select
diff --git a/include/SDcard.h b/include/SDcard.h
index b020df7..472f62f 100644
--- a/include/SDcard.h
+++ b/include/SDcard.h
@@ -1,41 +1,106 @@
 // SDcard.h
-// Includes for SD card interface
+// Includes for SD card interface.
+// The tracklist will be written to a file on the SD card itself.
 //
-#if ESP_ARDUINO_VERSION_MAJOR < 2                         // File function "path()" not available in older versions
-  #define path() name()                                   // Use "name()" instead
+#if ESP_ARDUINO_VERSION_MAJOR < 2                     // File function "path()" not available in older versions
+  #define path() name()                               // Use "name()" instead
 #endif
-#define MAXFNLEN        256                               // Max length of a full filespec
-#define RINGBUFFERSPACE 2560
-#define SD_MAXDEPTH     4                                 // Maximum depths.  Note: see mp3play_html.
+#define MAXFNLEN    255                               // Max length of a full filespec
+#define SD_MAXDEPTH 4                                 // Maximum depths.  Note: see mp3play_html.
+
+struct mp3spec_t                                      // For List of mp3 file on SD card
+{
+  uint8_t entrylen ;                                  // Total length of this entry
+  uint8_t prevlen ;                                   // Number of chars that are equal to previous
+  char    filespec[MAXFNLEN] ;                        // Full file spec, the divergent end part
+} ;
+
 
 #ifndef SDCARD
-  #define mount_SDCARD()         false                    // Dummy mount
-  //#define check_SDCARD()                                // Dummy check
-  #define close_SDCARD()                                  // Dummy close
-  #define read_SDCARD(a,b)       0                        // Dummy read file buffer
+  #define mount_SDCARD()         false                   // Dummy mount
+  #define scan_SDCARD()                                  // Dummy scan files
+  //#define check_SDCARD()                               // Dummy check
+  #define close_SDCARD()                                 // Dummy close
+  #define read_SDCARD(a,b)       0                       // Dummy read file buffer
+  #define selectnextSDnode(b)    String("")
   #define getSDfilename(a)       String("")
-  #define connecttofile_SD()      false                   // Dummy connect to file
-  #define initSDTask()                                    // Dummy start of task
+  #define listsdtracks(a,b,c)    0
+  #define connecttofile_SD()      false                  // Dummy connect to file
+  #define initSDTask()                                   // Dummy start of task
+
 #else
   #include <SPI.h>
   #include <SD.h>
   #include <FS.h>
-  #include <freertos/ringbuf.h>
-  #define SDSPEED 8000000                               // SPI speed of SD card
-
-  RingbufHandle_t fnbuf ;                               // Ringbuffer to store filenames
-  bool            SD_okay = false ;                     // SD is mounted
-  char            SD_lastmp3spec[MAXFNLEN] ;            // Previous full file spec
-  int             SD_filecount = 0 ;                    // Number of files on SD
-  int             tracknum = 0 ;                        // Current track number
+  #define SDSPEED   2000000                             // SPI speed of SD card
+  #define TRACKLIST "/tracklist.dat"                    // File with tracklist on SD card
+
+  bool            SD_okay = false ;                     // SD is okay
+  bool            SD_mounted = false ;                  // SD is mounted
+  int             SD_filecount = 0 ;                    // Number of filenames in SD_nodelist
+  int             SD_curindex ;                         // Current index in mp3names
+  RTC_NOINIT_ATTR mp3spec_t   mp3entry ;                // Entry with track spec
+  RTC_NOINIT_ATTR char        SD_lastmp3spec[512] ;     // Previous full file spec
   File            mp3file ;                             // File containing mp3 on SD card
-  int             mp3filelength ;                       // Length of file
+  int             mp3filelength = 0 ;                   // Length of file
   bool            randomplay = false ;                  // Switch for random play
-
+  File            trackfile ;                           // File for tracknames
+  bool            trackfile_isopen = false ;            // True if trackfile is open for read
+  
   // Forward declaration
-  void SDtask ( void * parameter ) ;
   void setdatamode ( datamode_t newmode ) ;
-  bool mount_SDCARD ( int8_t csPin ) ;
+  void SDtask      ( void * parameter ) ;
+
+  const char*      STAG = "SDcard" ;
+
+
+  //**************************************************************************************************
+  //                               C L O S E T R A C K F I L E                                       *
+  //**************************************************************************************************
+  void closeTrackfile()
+  {
+    if ( trackfile_isopen )                             // Trackfile still open?
+    {
+      trackfile.close() ;
+    }
+    trackfile_isopen = false ;                          // Reset open status
+  }
+
+
+  //**************************************************************************************************
+  //                                  O P E N T R A C K F I L E                                       *
+  //**************************************************************************************************
+  bool openTrackfile ( const char* mode = FILE_READ )
+  {
+    closeTrackfile() ;                                  // Close if already open
+    trackfile = SD.open ( TRACKLIST, mode ) ;           // Open the tracklist file on SD card
+    ESP_LOGI ( STAG, "OpenTrackfile(%s) result is %d",
+               mode, (int)trackfile ) ;
+    trackfile_isopen = ( trackfile != 0 ) ;             // Check result
+    return trackfile_isopen ;                           // Return open status
+  }
+
+
+  //**************************************************************************************************
+  //                               G E T F I R S T S D F I L E N A M E                               *
+  //**************************************************************************************************
+  // Get the first filespec from track file on SD card.                                              *
+  //**************************************************************************************************
+  const char* getFirstSDFileName()
+  {
+    if ( ! openTrackfile() )                            // Try to open track file
+    {
+      return NULL ;                                     // File not available
+    }
+    uint8_t* p = (uint8_t*)&mp3entry ;                  // Point to entrylength of mp3entry
+    trackfile.read ( p, sizeof(mp3entry.entrylen) ) ;   // Get total size of entry
+    p += sizeof(mp3entry.entrylen) ;                    // Bump pointer
+    trackfile.read ( p, mp3entry.entrylen -             // Read rest of entry
+                        sizeof(mp3entry.entrylen) ) ;
+    strcpy ( SD_lastmp3spec, mp3entry.filespec ) ;      // Copy filename into SD_last
+    SD_curindex = 0 ;                                   // Set current index to 0
+    return SD_lastmp3spec ;                             // Return pointer to filename
+  }
 
 
   //**************************************************************************************************
@@ -47,7 +112,7 @@
   {
     if ( strlen ( fnam ) < MAXFNLEN )                   // Guard against long filenames
     {
-      strcpy ( SD_lastmp3spec,  fnam ) ;                // Copy filename intp SD_last
+      strcpy ( SD_lastmp3spec,  fnam ) ;                // Copy filename into SD_last
     }
   }
 
@@ -55,14 +120,15 @@
   //**************************************************************************************************
   //                                   G E T S D F I L E N A M E                                     *
   //**************************************************************************************************
-  // Get a filespec from mp3names at index.                                                          *
+  // Get a filespec from tracklist file at index.                                                    *
   // If index is negative, a random track is selected.                                               *
   //**************************************************************************************************
-  const char* getSDFileName ( int inx )
+  char* getSDFileName ( int inx )
   {
-    size_t      fnlen ;                                   // Length of filename
-    void*       fnam = NULL ;                             // Filename from ringbuffer
-
+    if ( ! trackfile_isopen )                             // Track file available?
+    {
+      return NULL ;                                       // No, return empty name
+    }
     if ( inx < 0 )                                        // Negative track number?
     {
       inx = (int) random ( SD_filecount ) ;               // Yes, pick random track
@@ -72,26 +138,24 @@
     {
       randomplay = false ;                                // Not random, reset flag
     }
-    while ( inx-- )                                       // Move forward until at required position
+    if ( inx >= SD_filecount )                            // Protect against going beyond last track
     {
-      fnam = xRingbufferReceive ( fnbuf, &fnlen, 500 ) ;  // Read next filename
-      if ( fnam == nullptr )                              // Result?
-      {
-        break ;                                           // No, stop reading
-      }
+      inx = 0 ;                                           // Beyond last track: rewind to begin
     }
-    if ( fnam )                                           // Final result?
+    if ( inx < SD_curindex )                              // Going backwards?
     {
-      SD_filecount-- ;                                    // Yes, keep filecount up to date
-      strcpy ( SD_lastmp3spec, (const char*)fnam ) ;      // Yes, copy filename into SD_last
-      vRingbufferReturnItem ( fnbuf, fnam ) ;             // Return space to the buffer
-      dbgprint ( "Filename from ringbuffer is %s",
-                 SD_lastmp3spec ) ;
+      getFirstSDFileName() ;                              // Yes, start all over
     }
-    else
+    while ( SD_curindex < inx )                           // Move forward until at required position
     {
-      dbgprint ( "End of ringbuffer list" ) ;
-      *SD_lastmp3spec = '\0' ;                            // Bad result is also end of list
+      uint8_t* pm = (uint8_t*)&mp3entry ;                 // Point to entrylen of mp3entry
+      trackfile.read ( pm, sizeof(mp3entry.entrylen) ) ;  // Get total size of entry
+      pm += sizeof(mp3entry.entrylen) ;                   // Bump pointer
+      trackfile.read ( pm, mp3entry.entrylen -            // Read rest of entry
+                         sizeof ( mp3entry.entrylen ) ) ;
+      strcpy ( SD_lastmp3spec + mp3entry.prevlen,         // Copy filename into SD_last
+               mp3entry.filespec ) ;
+      SD_curindex++ ;                                     // Set current index
     }
     return SD_lastmp3spec ;                               // Return pointer to filename
   }
@@ -102,9 +166,9 @@
   //**************************************************************************************************
   // Get next filespec from mp3names.                                                                *
   //**************************************************************************************************
-  const char* getNextSDFileName()
+  char* getNextSDFileName()
   {
-    int inx =  1 ;                                       // By default next track
+    int inx = SD_curindex + 1 ;                          // By default next track
 
     if ( randomplay )                                    // Playing random tracks?
     {
@@ -119,7 +183,7 @@
   //**************************************************************************************************
   // Get current filespec from mp3names.                                                             *
   //**************************************************************************************************
-  const char* getCurrentSDFileName()
+  char* getCurrentSDFileName()
   {
     return SD_lastmp3spec ;                             // Return pointer to filename
   }
@@ -130,42 +194,77 @@
   //**************************************************************************************************
   // Get last part of current filespec from mp3names.                                                *
   //**************************************************************************************************
-  const char* getCurrentShortSDFileName()
+  char* getCurrentShortSDFileName()
   {
     return strrchr ( SD_lastmp3spec, '/' ) + 1 ;        // Last part of filespec
   }
 
 
   //**************************************************************************************************
-  //                                  A D D T O R I N G B U F                                        *
+  //                                  A D D T O F I L E L I S T                                      *
   //**************************************************************************************************
-  // Add a filename to the ring buffer.                                                              *
-  // If an error occurs, the filename is lost.                                                       *
+  // Add a filename to the trackfile on SD card.                                                     *
+  // Example:                                                                                        *
+  // Entry entry prev   filespec                             Interpreted result                      *
+  //  num   len   len                   
+  // ----- ----- ----   --------------------------------     ------------------------------------    *
+  // [0]      32    0   /Fleetwood Mac/Albatross.mp3         /Fleetwood Mac/Albatross.mp3            *
+  // [1]      15   15   Hold Me.mp3                          /Fleetwood Mac/Hold Me.mp3              *
   //**************************************************************************************************
-  void addToRingbuf ( const char* newfnam )
+  bool addToFileList ( const char* newfnam )
   {
-    size_t  fnlen = strlen ( newfnam ) + 1 ;                  // Length of filename plus delimeter
-  
-    if ( fnlen >= MAXFNLEN )                                  // Do not store very long filenames
+    char*             lnam = SD_lastmp3spec ;           // Set pointer to compare
+    uint8_t           n = 0 ;                           // Counter for number of equal characters
+    uint16_t          l = strlen ( newfnam ) ;          // Length of new file name
+    uint8_t           entrylen ;                        // Length of entry
+    bool              res = false ;                     // Function result
+
+    //ESP_LOGI ( STAG, "Full filename is %s", newfnam ) ;
+    if ( l >= ( sizeof ( SD_lastmp3spec ) - 1 ) )       // Block very long filenames
     {
-      dbgprint ( "Long filename ignored!" ) ;                 // Show error
-      return ;
+      ESP_LOGE ( STAG, "SD filename too long (%d)!", l ) ;
+      return false ;                                    // Filename too long: skip
     }
-    while ( xRingbufferSend ( fnbuf, newfnam, fnlen, 100 ) == pdFALSE )
+    while ( *lnam == *newfnam )                         // Compare next character of filename
     {
-      if ( ! SD_okay )                                        // Stop on SD error
+      if ( *lnam == '\0' )                              // End of name?
       {
-        return ;
+        break ;                                         // Yes, stop
       }
+      n++ ;                                             // Equal: count
+      lnam++ ;                                          // Update pointers
+      newfnam++ ;
+    }
+    mp3entry.prevlen = n ;                              // This part is equal to previous name
+    l -= n ;                                            // Length of rest of filename
+    if ( l >= ( sizeof ( mp3spec_t ) - 5 ) )            // Block very long filenames
+    {
+      ESP_LOGE ( STAG, "SD filename too long (%d)!", l ) ;
+      return false ;                                    // Filename too long: skip
     }
-    SD_filecount++ ;                                          // Count number of files
+    strcpy ( mp3entry.filespec, newfnam ) ;             // This is last part of new filename
+    entrylen = sizeof(mp3entry.entrylen) +              // Size of entry including string delimeter
+               sizeof(mp3entry.prevlen) +
+               strlen (newfnam) + 1 ;
+    mp3entry.entrylen = entrylen ;
+    strcpy ( lnam, newfnam ) ;                          // Set a new lastmp3spec
+    ESP_LOGI ( STAG, "Added %3u : %s", n,               // Show last part of filename
+               getCurrentShortSDFileName() ) ;
+    if ( trackfile )                                    // Outputfile open?
+    {
+      res = true ;                                      // Yes, positive result
+      trackfile.write ( (uint8_t*)&mp3entry,            // Yes, add to list
+                         entrylen ) ; 
+      SD_filecount++ ;                                  // Count number of files in list
+    }
+    return res ;                                        // Return result of adding name
   }
 
 
   //**************************************************************************************************
   //                                      G E T S D T R A C K S                                      *
   //**************************************************************************************************
-  // Search all MP3 files on directory of SD card.  Store them in ringbuffer.                        *
+  // Search all MP3 files on directory of SD card.                                                   *
   // Will be called recursively.                                                                     *
   //**************************************************************************************************
   bool getsdtracks ( const char * dirname, uint8_t levels )
@@ -173,28 +272,25 @@
     File       root ;                                     // Work directory
     File       file ;                                     // File in work directory
 
-    //dbgprint ( "getsdt dir is %s", dirname ) ;
-    claimSPI ( "sdopen1" ) ;                              // Claim SPI bus
+    //ESP_LOGI ( STAG, "getsdt dir is %s", dirname ) ;
     root = SD.open ( dirname ) ;                          // Open directory
-    releaseSPI() ;                                        // Release SPI bus
     if ( !root )                                          // Check on open
     {
-      dbgprint ( "Failed to open directory" ) ;
+      ESP_LOGI ( STAG, "Failed to open directory" ) ;
       return false ;
     }
     if ( !root.isDirectory() )                            // Really a directory?
     {
-      dbgprint ( "Not a directory" ) ;
+      ESP_LOGI ( STAG, "Not a directory" ) ;
       return false ;
     }
-    claimSPI ( "sdopen2" ) ;                              // Claim SPI bus
     file = root.openNextFile() ;
-    releaseSPI() ;                                        // Release SPI bus
     while ( file )
     {
+      vTaskDelay ( 50 / portTICK_PERIOD_MS ) ;            // Allow others
       if ( file.isDirectory() )                           // Is it a directory?
       {
-        dbgprint ( "  DIR : %s", file.path() ) ;
+        //ESP_LOGI ( STAG, "  DIR : %s", file.path() ) ;
         if ( levels )                                     // Dig in subdirectory?
         {
           if ( strrchr ( file.path(), '/' )[1] != '.' )   // Skip hidden directories
@@ -209,118 +305,20 @@
       }
       else                                                // It is a file
       {
-        vTaskDelay ( 50 / portTICK_PERIOD_MS ) ;          // Allow others
         const char* ext = file.name() ;                   // Point to begin of name
         ext = ext + strlen ( ext ) - 4 ;                  // Point to extension
         if ( ( strcmp ( ext, ".MP3" ) == 0 ) ||           // It is a file, but is it an MP3?
             ( strcmp ( ext, ".mp3" ) == 0 ) )
         {
-          addToRingbuf ( file.path() ) ;                  // Add file to the list
-        }
-      }
-      claimSPI ( "sdopen3" ) ;                            // Claim SPI bus
-      file = root.openNextFile() ;
-      releaseSPI() ;                                      // Release SPI bus
-    }
-    return true ;
-  }
-
-
-  //**************************************************************************************************
-  //                                   S D I N S E R T C H E C K                                     *
-  //**************************************************************************************************
-  // Check if new SD card is inserted and can be read.                                               *
-  //**************************************************************************************************
-  bool SDInsertCheck()
-  {
-    static uint32_t nextCheckTime = 0 ;                     // To prevent checking too often
-    uint32_t        newmillis = millis() ;                  // Current timestamp
-    bool            sdinsNew ;                              // Result of insert check
-    void*           p ;                                     // Pointer to item from ringbuffer
-    size_t          f0 ;                                    // Length of item from ringbuffer
-    static bool     sdInserted = false ;                    // Yes, flag for inserted SD
-    int8_t          dpin = ini_block.sd_detect_pin ;        // SD inserted detect pin
-
-    if ( newmillis < nextCheckTime )                        // Time to check?
-    {
-      return false ;                                        // No, return "no new insert"
-    }
-    nextCheckTime = newmillis + 5000 ;                      // Yes, set new check time
-    if ( dpin >= 0 )                                        // Hardware detection possible?
-    {
-      sdinsNew = ( digitalRead ( dpin ) == LOW ) ;          // Yes, see if card inserted
-      if ( sdinsNew == sdInserted )                         // Situation changed?
-      {
-        return false ;                                      // No, return "no new insert"
-      }
-      else
-      {
-        sdInserted = sdinsNew ;                             // Remember status
-        if ( ! sdInserted )                                 // Card out?
-        {
-          dbgprint ( "SD card removed" ) ;
-          while ( ( p = xRingbufferReceive ( fnbuf,         // Flush filename list
-                                             &f0, 0 ) ) )
+          if ( ! addToFileList ( file.path() ) )          // Add file to the list
           {
-            vRingbufferReturnItem ( fnbuf, p ) ;            // Return space to the buffer
+            break ;                                       // No need to continue
           }
-          claimSPI ( "SDend" ) ;                            // Claim SPI bus
-          SD.end() ;                                        // Unmount SD card
-          releaseSPI() ;                                    // Release SPI bus
-          SD_okay = false ;                                 // Not okay anymore
-        }
-        else
-        {
-          dbgprint ( "SD card inserted" ) ;
-          SD_okay = mount_SDCARD ( ini_block.sd_cs_pin ) ;  // Try to mount
         }
-        return SD_okay ;                                    // Return result
       }
+      file = root.openNextFile() ;
     }
-    else
-    {
-      if ( SD_okay )                                        // Card already mounted?
-      {
-        return false ;                                      // Yes, no change
-      }
-      while ( ( p = xRingbufferReceive ( fnbuf,             // Flush filename list
-                                         &f0, 0 ) ) )
-      {
-        vRingbufferReturnItem ( fnbuf, p ) ;                // Return space to the buffer
-      }
-      claimSPI ( "SDend2" ) ;                               // Claim SPI bus
-      SD.end() ;                                            // Unmount SD card if needed
-      releaseSPI() ;                                        // Release SPI bus
-      SD_okay = mount_SDCARD ( ini_block.sd_cs_pin ) ;      // Try to mount
-      return SD_okay ;                                      // Return result
-    }
-  }
-
-
-  //**************************************************************************************************
-  //                                       S D T A S K                                               *
-  //**************************************************************************************************
-  // This task will constantly try to fill the ringbuffer with filenames on SD.                      *
-  //**************************************************************************************************
-  void SDtask ( void * parameter )
-  {
-    fnbuf = xRingbufferCreate ( RINGBUFFERSPACE,          // Create 15k ringbuffer
-                                RINGBUF_TYPE_NOSPLIT ) ;
-    if ( fnbuf == nullptr )
-    {
-      dbgprint ( "No space for SD ringbuffer" ) ;
-      vTaskDelete ( NULL ) ;                              // End this task
-    }
-    vTaskDelay ( 20000 / portTICK_PERIOD_MS ) ;           // Start delay
-    while ( true )                                        // Endless task
-    {
-      SDInsertCheck() ;                                   // See if new card is inserted
-      while ( SD_okay )
-      {
-        SD_okay = getsdtracks ( "/", SD_MAXDEPTH ) ;      // Get filenames, store in the ringbuffer
-      }
-      vTaskDelay ( 100 / portTICK_PERIOD_MS ) ;           // Allow other tasks
-    }
+    return true ;
   }
 
 
@@ -350,27 +348,21 @@
       uint8_t tagsize[4] ;                                    // Size of the tag
       uint8_t tagflags[2] ;                                   // Tag flags
     } ID3tag ;
-    uint8_t  tmpbuf[4] ;                                      // Scratch buffer
-    uint8_t  tenc ;                                           // Text encoding
-    String   albttl = String() ;                              // Album and title
+    uint8_t   tmpbuf[4] ;                                     // Scratch buffer
+    uint8_t   tenc ;                                          // Text encoding
+    String    albttl = String() ;                              // Album and title
     bool      talb ;                                          // Tag is TALB (album title)
     bool      tpe1 ;                                          // Tag is TPE1 (artist)
 
     tftset ( 2, "Playing from local file" ) ;                 // Assume no ID3
     p = (char*)path.c_str() + 1 ;                             // Point to filename (after the slash)
     showstreamtitle ( p, true ) ;                             // Show the filename as title (middle part)
-    claimSPI ( "sdopen1" ) ;                              // Claim SPI bus
     mp3file = SD.open ( path ) ;                              // Open the file
-    releaseSPI() ;                                        // Release SPI bus
-    if ( path.endsWith ( ".mu3" ) )                           // Is it a playlist?
-    {
-      return ;                                                // Yes, no ID's, but leave file open
-    }
     mp3file.read ( (uint8_t*)&ID3head, sizeof(ID3head) ) ;    // Read first part of ID3 info
     if ( strncmp ( ID3head.fid, "ID3", 3 ) == 0 )
     {
       sttg = ssconv ( ID3head.ttagsize ) ;                    // Convert tagsize
-      dbgprint ( "Found ID3 info" ) ;
+      ESP_LOGI ( STAG, "Found ID3 info" ) ;
       if ( ID3head.hflags & 0x40 )                            // Extended header?
       {
         stx = ssconv ( exthsiz ) ;                            // Yes, get size of extended header
@@ -382,7 +374,7 @@
       while ( sttg > 10 )                                     // Now handle the tags
       {
         sttg -= mp3file.read ( (uint8_t*)&ID3tag,
-                              sizeof(ID3tag) ) ;             // Read first part of a tag
+                              sizeof(ID3tag) ) ;              // Read first part of a tag
         if ( ID3tag.tagid[0] == 0 )                           // Reached the end of the list?
         {
           break ;                                             // Yes, quit the loop
@@ -403,12 +395,12 @@
           break ;                                             // No, skip this and further tags
         }
         sttg -= mp3file.read ( (uint8_t*)metalinebf,
-                              stg ) ;                        // Read tag contents
+                               stg ) ;                        // Read tag contents
         metalinebf[stg] = '\0' ;                              // Add delimeter
         tenc = metalinebf[0] ;                                // First byte is encoding type
         if ( tenc == '\0' )                                   // Debug all tags with encoding 0
         {
-          dbgprint ( "ID3 %s = %s", ID3tag.tagid,
+          ESP_LOGI ( STAG, "ID3 %s = %s", ID3tag.tagid,
                     metalinebf + 1 ) ;
         }
         talb = ( strncmp ( ID3tag.tagid, "TALB", 4 ) == 0 ) ; // Album title
@@ -434,7 +426,7 @@
       }
       tftset ( 1, albttl ) ;                                  // Show album and title
     }
-    mp3file.seek ( 0 ) ;                                      // Back to begin of filr
+    //mp3file.seek ( 0 ) ;                                      // Back to begin of file
   }
 
 
@@ -454,12 +446,11 @@
     path = String ( getCurrentSDFileName() ) ;              // Set path to file to play
     icystreamtitle = path ;                                 // If no ID3 available
     icyname = String ( "" ) ;                               // If no ID3 available
-    claimSPI ( "sdopen3" ) ;                                // Claim SPI bus
     handle_ID3_SD ( path ) ;                                // See if there are ID3 tags in this file
-    releaseSPI() ;                                          // Release SPI bus
     if ( !mp3file )
     {
-      dbgprint ( "Error opening file %s", path.c_str() ) ;  // No luck
+      ESP_LOGI ( STAG, "Error opening file %s",             // No luck
+                 path.c_str() ) ;
       return false ;
     }
     mp3filelength = mp3file.available() ;                   // Get length
@@ -477,58 +468,173 @@
   //**************************************************************************************************
   bool mount_SDCARD ( int8_t csPin )
   {
-    static const char* lastmsg = NULL ;                     // Last debug message
-    const char*        newmsg = NULL ;                      // New debug message
+    bool       okay = false ;                              // True if SD card in place and readable
+
+    if ( csPin >= 0 )                                      // SD configured?
+    {
+      SD_mounted = SD.begin ( csPin, SPI,                  // Yes, try to init SD card driver
+                              SDSPEED, "/sd", 3 ) ;
+      if ( !SD_mounted )                                   // Init (mount) okay?
+      {
+        //ESP_LOGE ( STAG, "SD Card Mount Failed!" ) ;     // No success, check formatting (FAT)
+      }
+      else
+      {
+        okay = ( SD.cardType() != CARD_NONE ) ;            // See if known card
+      }
+    }
+    if ( !okay )
+    {
+      ESP_LOGI ( STAG, "No SD card attached" ) ;           // Card not readable
+    }
+    return okay ;
+  }
+
+
+  //**************************************************************************************************
+  //                                       C L O S E _ S D C A R D                                   *
+  //**************************************************************************************************
+  // Close file on SD card.                                                                          *
+  //**************************************************************************************************
+  void close_SDCARD()
+  {
+    ESP_LOGI ( STAG, "Close SD file" ) ;
+    mp3file.close() ;                                     // Close the file
+  }
+
+
+  //**************************************************************************************************
+  //                                   S D I N S E R T C H E C K                                     *
+  //**************************************************************************************************
+  // Check if new SD card is inserted and can be read.                                               *
+  //**************************************************************************************************
+  bool SDInsertCheck()
+  {
+    static uint32_t nextCheckTime = 0 ;                     // To prevent checking too often
+    uint32_t        newmillis ;                             // Current timestamp
+    bool            sdinsNew ;                              // Result of insert check
+    void*           p ;                                     // Pointer to item from ringbuffer
+    size_t          f0 ;                                    // Length of item from ringbuffer
+    static bool     sdInserted = false ;                    // Yes, flag for inserted SD
+    int8_t          dpin = ini_block.sd_detect_pin ;        // SD inserted detect pin
 
-    if ( csPin >= 0 )                                       // SD configured?
+    if ( ( newmillis = millis() ) < nextCheckTime )         // Time to check?
     {
-      claimSPI ( "mountSD" ) ;                              // Claim SPI bus
-      SD_okay = SD.begin ( csPin, SPI, SDSPEED ) ;          // Yes, try to init SD card driver
-      releaseSPI() ;                                        // Release SPI bus
-      if ( ! SD_okay )                                      // Success?
+      return false ;                                        // No, return "no new insert"
+    }
+    nextCheckTime = newmillis + 5000 ;                      // Yes, set new check time
+    if ( dpin >= 0 )                                        // Hardware detection possible?
+    {
+      sdinsNew = ( digitalRead ( dpin ) == LOW ) ;          // Yes, see if card inserted
+      if ( sdinsNew == sdInserted )                         // Situation changed?
       {
-        newmsg = "SD Card Mount Failed!" ;                  // No success, check formatting (FAT)
+        return false ;                                      // No, return "no new insert"
       }
       else
       {
-        SD_okay = ( SD.cardType() != CARD_NONE ) ;          // See if known card
-        if ( SD_okay )
+        sdInserted = sdinsNew ;                             // Remember status
+        if ( ! sdInserted )                                 // Card out?
         {
-          newmsg = "SD card attached" ;                     // Yes, card is okay
+          ESP_LOGI ( STAG, "SD card removed" ) ;
+          if ( SD_mounted )                                 // Still mounted?
+          {
+            SD.end() ;                                      // Unmount SD card
+            SD_okay = false ;                               // Not okay anymore
+            SD_mounted = false ;                            // And not mounted anymore
+          }
         }
-        else
+        else                                                // Card inserted
         {
-          newmsg = "No SD card attached!" ;                 // Card not readable
+          ESP_LOGI ( STAG, "SD card inserted" ) ;
+          SD_okay = mount_SDCARD ( ini_block.sd_cs_pin ) ;  // Try to mount
         }
       }
     }
-    if ( newmsg != lastmsg )                                // Status change?
+    else                                                    // Handle SD without detect pin
     {
-      dbgprint ( newmsg ) ;                                 // Yes, print message
-      lastmsg = newmsg ;                                    // Remember last message
+      ESP_LOGI ( STAG, "Try to mount SD card" ) ;
+      SD_okay = mount_SDCARD ( ini_block.sd_cs_pin ) ;      // Try to mount
     }
-    return SD_okay ;
+    return SD_okay ;                                        // Return result
   }
 
 
   //**************************************************************************************************
-  //                                       C L O S E _ S D C A R D                                   *
+  //                                    C O U N T F I L E S                                          *
   //**************************************************************************************************
-  // Close file on SD card.                                                                          *
+  // Count number of tracks in the track list.                                                       *
   //**************************************************************************************************
-  void close_SDCARD()
+  int countfiles()
   {
-    mp3file.close() ;
+    int count = 0 ;                                         // Files found
+  
+    while ( trackfile.available() > 1 )
+    {
+      uint8_t* pm = (uint8_t*)&mp3entry ;                   // Point to entrylength of mp3entry
+      trackfile.read ( pm, sizeof(mp3entry.entrylen) ) ;    // Get total size of entry
+      pm += sizeof(mp3entry.entrylen) ;                     // Bump pointer
+      trackfile.read ( pm, mp3entry.entrylen -              // Read rest of entry
+                        sizeof ( mp3entry.entrylen ) ) ;
+      count++ ;                                             // count entries
+      vTaskDelay ( 10 / portTICK_PERIOD_MS  ) ;             // Allow other tasks
+    }
+    ESP_LOGI ( STAG, "%d files on SD card", count ) ;
+    return count ;                                          // Return number of tracks
   }
 
 
   //**************************************************************************************************
-  //                                       R E A D _ S D C A R D                                     *
+  //                                       S D T A S K                                               *
   //**************************************************************************************************
-  // Read a block of data from SD card file.                                                         *
+  // This task will constantly try to fill the ringbuffer with filenames on SD.                      *
+  // if the SD detect pin is defined, a test will on SD change will be performed every 5 seconds.    *
+  // Otherwise, the check is made only once, after reset.                                            *
   //**************************************************************************************************
-  size_t read_SDCARD ( uint8_t* buf, uint32_t len )
+  void SDtask ( void * parameter )
   {
-    return mp3file.read ( buf, len ) ;                   // Read a block of data
+    const char* ffn ;                                     // First filename on SD card
+    int8_t      dpin = ini_block.sd_detect_pin ;          // SD inserted detect pin
+    bool        once = true ;                             // Always check once
+  
+    vTaskDelay ( 1000 / portTICK_PERIOD_MS ) ;            // Start delay
+    while ( true )                                        // Endless task
+    {
+      vTaskDelay ( 200 / portTICK_PERIOD_MS ) ;           // Allow other tasks
+      if ( ( dpin < 0 ) && ( once == false ) )            // Just one check if no detect pin
+      {
+        continue ;
+      }
+      once = false ;                                      // Stop detect without detect pin
+      if ( SDInsertCheck() )                              // See if new card is inserted
+      {
+        SD_lastmp3spec[0] = '\0' ;                        // No last track
+        if ( ( openTrackfile() ) &&                       // Try to open trackfile
+             ( trackfile.size() > 0 ) )                   // Tracklist on this SD card?
+        {
+          ESP_LOGI ( STAG, "Track list is on SD card, "   // Yes, show it
+                     "read tracks" ) ;
+          SD_filecount = countfiles() ;                   // Count number of files on this card
+          closeTrackfile() ;                              // Close the tracklist file
+          ESP_LOGI ( STAG, "%d tracks on SD card",        // Yes, show it
+                     SD_filecount ) ;
+        }
+        else
+        {
+          ESP_LOGI ( STAG, "Locate mp3 files on SD, "
+                     "may take a while..." ) ;
+          if ( openTrackfile ( FILE_WRITE ) )             // Try to open trackfile for write
+          {
+            SD_okay = getsdtracks ( "/", SD_MAXDEPTH ) ;  // Get filenames, store on the SD card
+            closeTrackfile() ;                            // Close the tracklist file
+          }
+        }
+        ffn = getFirstSDFileName() ;
+        if ( ffn )
+        {
+          ESP_LOGI ( STAG, "First file on SD card is %s", // Show the first track name
+                     ffn ) ;
+        }
+      }
+    }
   }
 #endif
diff --git a/include/config.h b/include/config.h
index 8ab7845..d74a643 100644
--- a/include/config.h
+++ b/include/config.h
@@ -4,38 +4,44 @@
 // Configuration definition for your particular set-up.                                             *
 //***************************************************************************************************
 //
-//#define NAME "ESP32-Radio"                              // Define name of the radio, also AP SSID
-                                                          // Default is "ESP32-Radio"
-
-//#define SDCARD                                            // Experimental: For SD card support (reading MP3-files)
-
-//#define ETHERNET                                        // For wired Ethernet (WT32-ETH-01 or similar)
-
-#define FIXEDWIFI "LAPTOP-ED/wifiwifi"                    // Add a fixed SSID to the list (WiFi only)
-
-// Define (just one) type of MP3/AAC decoder
-#define DEC_VS1053                                        // Hardware decoder for MP3, AAC, OGG
-//#define DEC_VS1003                                      // Hardware decoder for MP3
-//#define DEC_HELIX                                       // Software decoder for MP3, AAC. I2S output
-//#define DEC_HELIX_AI                                    // Software decoder for AI Audio kit (AC101)
-//#define DEC_HELIX_INT                                   // Software decoder for MP3, AAC. DAC output
-                                                          // Needs platform = espressif32@3.1.0 !!!!
-
-// Define (just one) type of display.  See documentation.
-#define BLUETFT                                         // Works also for RED TFT 128x160
-//#define ST7789                                          // 240x240 TFT
-//#define OLED1306                                        // 64x128 I2C OLED SSD1306
-//#define OLED1309                                        // 64x128 I2C OLED SSD1309
-//#define OLED1106                                        // 64x128 I2C OLED SH1106
-//#define DUMMYTFT                                        // Dummy display
-//#define LCD1602I2C                                      // LCD 1602 display with I2C backpack
-//#define LCD2004I2C                                      // LCD 2004 display with I2C backpack
-//#define ILI9341                                         // ILI9341 240*320
-//#define NEXTION                                         // Nextion display
-//
-
-// Define ZIPPYB5 if a ZIPPY B5 Side Switch is used instead of a rotary switch
-///#define ZIPPYB5
-
-// End of configuration parameters.
-
+#ifndef CONFIG_H
+  //#define NAME "ESP32-Radio"                              // Define name of the radio, also AP SSID,
+                                                            // also namespace in NVS.
+                                                            // Default is "ESP32-Radio"
+
+  //#define SDCARD                                          // Experimental: For SD card support (reading MP3-files)
+
+  //#define ETHERNET                                        // For wired Ethernet (WT32-ETH-01 or similar)
+
+  //#define FIXEDWIFI "SSID-11/PW12345"                     // Add a fixed SSID to the list (WiFi only)
+  
+  //#define ENABLEOTA                                       // OTA feature
+
+  // Define (just one) type of MP3/AAC decoder
+  #define DEC_VS1053                                        // Hardware decoder for MP3, AAC, OGG
+  //#define DEC_VS1003                                      // Hardware decoder for MP3 only
+  //#define DEC_HELIX                                       // Software decoder for MP3, AAC. I2S output
+  //#define DEC_HELIX_SPDIF                                 // Toslink/Spdif output for MP3, AAC (experimental)
+  //#define DEC_HELIX_AI                                    // Software decoder for AI Audio kit (AC101)
+  //#define DEC_HELIX_INT                                   // Software decoder for MP3, AAC. DAC output
+                                                            // Needs platform = espressif32@3.1.0 !!!!
+
+  // Define (just one) type of display.  See documentation.
+  #define BLUETFT                                         // Works also for RED TFT 128x160
+  //#define ST7789                                          // 240x240 TFT (SPI)
+  //#define OLED1306                                        // 64x128 I2C OLED SSD1306
+  //#define OLED1309                                        // 64x128 I2C OLED SSD1309
+  //#define OLED1106                                        // 64x128 I2C OLED SH1106
+  //#define DUMMYTFT                                          // Dummy display
+  //#define LCD1602I2C                                      // LCD 1602 display with I2C backpack
+  //#define LCD2004I2C                                      // LCD 2004 display with I2C backpack
+  //#define ILI9341                                         // ILI9341 240*320
+  //#define NEXTION                                         // Nextion display
+  //
+
+  // Define ZIPPYB5 if a ZIPPY B5 Side Switch is used instead of a rotary switch
+  //#define ZIPPYB5
+
+  // End of configuration parameters.
+  #define CONFIG_H
+#endif
diff --git a/include/config_ed.h b/include/config_ed.h
deleted file mode 100644
index 0d3bb52..0000000
--- a/include/config_ed.h
+++ /dev/null
@@ -1,29 +0,0 @@
-//***************************************************************************************************
-// config.h                                                                                         *
-//***************************************************************************************************
-//
-#define NAME "ESP32-Radio"                                // Define name of the radio, also AP SSID
-
-//#define SDCARD                                            // For SD card support (reading MP3-files)
-
-// Define (just one) type of MP3/AAC decoder
-#define DEC_VS1053                                        // Hardware decoder for MP3, AAC, OGG
-//#define DEC_VS1003                                      // Hardware decoder for MP3
-//#define DEC_HELIX                                       // Software decoder for MP3, AAC. I2S output
-
-// Define (just one) type of display.  See documentation.
-#define BLUETFT                                           // Works also for RED TFT 128x160
-//define ST7789                                           // 240x240 TFT
-//#define OLED1306                                        // 64x128 I2C OLED SSD1306
-//#define OLED1309                                        // 64x128 I2C OLED SSD1309
-//#define OLED1106                                        // 64x128 I2C OLED SH1106
-//#define DUMMYTFT                                        // Dummy display
-//#define LCD1602I2C                                      // LCD 1602 display with I2C backpack
-//#define LCD2004I2C                                      // LCD 2004 display with I2C backpack
-//#define ILI9341                                         // ILI9341 240*320
-//#define NEXTION                                         // Nextion display. Uses UART 2 (pin 16 and 17)
-//
-
-// Define ZIPPYB5 if a ZIPPY B5 Side Switch is used instead of a rotary switch
-//#define ZIPPYB5
-
diff --git a/include/helixfuncs.h b/include/helixfuncs.h
index 0055d6b..4440c69 100644
--- a/include/helixfuncs.h
+++ b/include/helixfuncs.h
@@ -1,11 +1,17 @@
 // helixfuncs.h
 // Functions for HELIX decoder.
+// Code for SPDIF leans heavily on https://github.com/earlephilhower/ESP8266Audio/blob/master/src/AudioOutputSPDIF.cpp
 //
+// 26-04-2023, ES: correction setting disable_pin
+#include "config.h"
+
 #define player_AdjustRate(a)                         // Not supported function
 #define player_setTone(a)                            // Not supported function
 
 #define FRAMESIZE               1600                 // Max. frame size in bytes (mp3 and aac)
-#define OUTSIZE                 2048                 // Max number of samples per channel (mp3 and aac)
+#define OUTSIZE                 1152                 // Max number of samples per channel (mp3 and aac)
+                                                     // AAC is max 1024, MP3 is 1152
+#define I2SSIZE                 128                  // For I2S buffer (16/32 bits words).  Multiple of 8.
 
 extern bool      muteflag ;                          // True if output must be muted
 extern String    audio_ct ;                          // Content type, like "audio/aacp"
@@ -16,8 +22,54 @@ static uint8_t   mp3buff[FRAMESIZE+32] ;             // Space for enough chunks
 static uint8_t*  mp3bpnt ;                           // Points into mp3buff
 static int       mp3bcnt ;                           // Number of samples in buffer
 static bool      searchFrame ;                       // True if search for startframe is needed
-static int16_t   outbuf[OUTSIZE*2] ;                 // I2S buffer
+static int16_t   outbuf[OUTSIZE*2] ;                 // MP3 output (PCM) buffer
+
+const  char*     HTAG = "helixfuncs" ;
 
+#ifdef DEC_HELIX_SPDIF
+  // BMC (Biphase Mark Coded) values (bit order reversed, i.e. LSB first)
+  static const uint16_t PROGMEM spdif_bmclookup[256] =
+    { 
+      0xcccc, 0x4ccc, 0x2ccc, 0xaccc, 0x34cc, 0xb4cc, 0xd4cc, 0x54cc, // 00..07
+      0x32cc, 0xb2cc, 0xd2cc, 0x52cc, 0xcacc, 0x4acc, 0x2acc, 0xaacc, // 08..0F
+      0x334c, 0xb34c, 0xd34c, 0x534c, 0xcb4c, 0x4b4c, 0x2b4c, 0xab4c, // 10..17
+      0xcd4c, 0x4d4c, 0x2d4c, 0xad4c, 0x354c, 0xb54c, 0xd54c, 0x554c, // 18..1F
+      0x332c, 0xb32c, 0xd32c, 0x532c, 0xcb2c, 0x4b2c, 0x2b2c, 0xab2c, // 20..27
+      0xcd2c, 0x4d2c, 0x2d2c, 0xad2c, 0x352c, 0xb52c, 0xd52c, 0x552c, // 28..2F
+      0xccac, 0x4cac, 0x2cac, 0xacac, 0x34ac, 0xb4ac, 0xd4ac, 0x54ac, // 30..37
+      0x32ac, 0xb2ac, 0xd2ac, 0x52ac, 0xcaac, 0x4aac, 0x2aac, 0xaaac, // 38..3F
+      0x3334, 0xb334, 0xd334, 0x5334, 0xcb34, 0x4b34, 0x2b34, 0xab34, // 40..47
+      0xcd34, 0x4d34, 0x2d34, 0xad34, 0x3534, 0xb534, 0xd534, 0x5534, // 48..4F
+      0xccb4, 0x4cb4, 0x2cb4, 0xacb4, 0x34b4, 0xb4b4, 0xd4b4, 0x54b4, // 50..57
+      0x32b4, 0xb2b4, 0xd2b4, 0x52b4, 0xcab4, 0x4ab4, 0x2ab4, 0xaab4, // 58..5F
+      0xccd4, 0x4cd4, 0x2cd4, 0xacd4, 0x34d4, 0xb4d4, 0xd4d4, 0x54d4, // 60..67
+      0x32d4, 0xb2d4, 0xd2d4, 0x52d4, 0xcad4, 0x4ad4, 0x2ad4, 0xaad4, // 68..6F
+      0x3354, 0xb354, 0xd354, 0x5354, 0xcb54, 0x4b54, 0x2b54, 0xab54, // 70..77
+      0xcd54, 0x4d54, 0x2d54, 0xad54, 0x3554, 0xb554, 0xd554, 0x5554, // 78..7F
+      0x3332, 0xb332, 0xd332, 0x5332, 0xcb32, 0x4b32, 0x2b32, 0xab32, // 80..87
+      0xcd32, 0x4d32, 0x2d32, 0xad32, 0x3532, 0xb532, 0xd532, 0x5532, // 88..8F
+      0xccb2, 0x4cb2, 0x2cb2, 0xacb2, 0x34b2, 0xb4b2, 0xd4b2, 0x54b2, // 90..97
+      0x32b2, 0xb2b2, 0xd2b2, 0x52b2, 0xcab2, 0x4ab2, 0x2ab2, 0xaab2, // 98..9F
+      0xccd2, 0x4cd2, 0x2cd2, 0xacd2, 0x34d2, 0xb4d2, 0xd4d2, 0x54d2, // A0..A7
+      0x32d2, 0xb2d2, 0xd2d2, 0x52d2, 0xcad2, 0x4ad2, 0x2ad2, 0xaad2, // A8..AF
+      0x3352, 0xb352, 0xd352, 0x5352, 0xcb52, 0x4b52, 0x2b52, 0xab52, // B0..B7
+      0xcd52, 0x4d52, 0x2d52, 0xad52, 0x3552, 0xb552, 0xd552, 0x5552, // B8..BF
+      0xccca, 0x4cca, 0x2cca, 0xacca, 0x34ca, 0xb4ca, 0xd4ca, 0x54ca, // C0..C7
+      0x32ca, 0xb2ca, 0xd2ca, 0x52ca, 0xcaca, 0x4aca, 0x2aca, 0xaaca, // C8..CF
+      0x334a, 0xb34a, 0xd34a, 0x534a, 0xcb4a, 0x4b4a, 0x2b4a, 0xab4a, // D0..D7
+      0xcd4a, 0x4d4a, 0x2d4a, 0xad4a, 0x354a, 0xb54a, 0xd54a, 0x554a, // D8..DF
+      0x332a, 0xb32a, 0xd32a, 0x532a, 0xcb2a, 0x4b2a, 0x2b2a, 0xab2a, // E0..E7
+      0xcd2a, 0x4d2a, 0x2d2a, 0xad2a, 0x352a, 0xb52a, 0xd52a, 0x552a, // E8..EF
+      0xccaa, 0x4caa, 0x2caa, 0xacaa, 0x34aa, 0xb4aa, 0xd4aa, 0x54aa, // F0..F7
+      0x32aa, 0xb2aa, 0xd2aa, 0x52aa, 0xcaaa, 0x4aaa, 0x2aaa, 0xaaaa  // F8..FF
+    } ;
+    const uint32_t VUCP_PREAMBLE_B = 0xCCE80000 ;     // 11001100 11101000
+    const uint32_t VUCP_PREAMBLE_M = 0xCCE20000 ;     // 11001100 11100010
+    const uint32_t VUCP_PREAMBLE_W = 0xCCE40000 ;     // 11001100 11100100
+    static uint32_t i2sbuf[I2SSIZE] ;                 // Buffer for I2S biphase buffer
+#else
+    static int16_t  i2sbuf[I2SSIZE] ;                 // Buffer for I2S
+#endif
 
 //**************************************************************************************************
 //                              P L A Y E R _ S E T V O L U M E                                    *
@@ -29,7 +81,7 @@ void player_setVolume ( int16_t v )
   if ( vol != v )
   {
     vol = v ;   	                                     // Save volume percentage
-    dbgprint ( "Volume set to %d", vol ) ;
+    ESP_LOGI ( HTAG, "Volume set to %d", vol ) ;
     #ifdef DEC_HELIX_AI                                // For AI Audio kit: set volume directly
       int8_t db = map ( vol, 0, 100, 0x0, 0x3F ) ;     // 0..100% to -43.5 .. 0 dB (0..63)
       dac.SetVolumeSpeaker ( db ) ;                    // Set volume control of amplifier
@@ -55,25 +107,94 @@ int16_t player_getVolume()
 //**************************************************************************************************
 // Initialize helix buffering.                                                                     *
 //**************************************************************************************************
-void helixInit ( uint8_t enable_pin, uint8_t disable_pin )
+void helixInit ( int8_t enable_pin, int8_t disable_pin )
 {
-  dbgprint ( "helixInit called for %s, e is %d, "     // Show activity
-             "d is %d",
-             audio_ct.c_str(),
-             enable_pin, disable_pin ) ;
+  ESP_LOGI ( HTAG, "helixInit called for %s",         // Show activity
+             audio_ct.c_str() ) ;
   mp3mode = ( audio_ct.indexOf ( "mpeg" ) > 0 ) ;     // Set mp3/aac mode
   mp3bpnt = mp3buff ;                                 // Reset pointer
   mp3bcnt = 0 ;                                       // Buffer empty
   searchFrame = true ;                                // Start searching for frame
-  if ( enable_pin != 0xFF )                           // Enable pin defined?
+  if ( enable_pin >= 0 )                              // Enable pin defined?
   {
     pinMode ( enable_pin, OUTPUT ) ;                  // Yes, set pin to output
     digitalWrite ( enable_pin, HIGH ) ;               // Enable output
   }
-  if ( disable_pin != 0xFF )                          // Disable pin defined?
+  if ( disable_pin >= 0 )                             // Disable pin defined?
   {
     pinMode ( disable_pin, OUTPUT ) ;                 // Yes, set pin to output
-    digitalWrite ( enable_pin, LOW ) ;                // Enable output
+    digitalWrite ( disable_pin, LOW ) ;               // Enable output
+  }
+}
+
+
+//**************************************************************************************************
+//                               O U T P U T S A M P L E                                           *
+//**************************************************************************************************
+// Add a sample to the I2S buffer.  Send to I2S driver if buffer is full.                          *
+// For SPDIFF: convert to a valid frame.  16-bit sample to a frame of 2 x 32 bits.                 *
+//**************************************************************************************************
+void outputSample ( int16_t c )
+{
+  static uint8_t  frame_num = 0 ;                     // Frame number for spdif
+  static bool     left = true ;                       // Switch between left and right sample
+  static uint8_t  i2sinx = 0 ;                        // Index in i2sbuf
+  size_t          bw ;                                // Number of bytes written to I2S
+  
+  #ifndef DEC_HELIX_AI
+    #ifdef DEC_HELIX_INT                              // Internal DAC used?
+      c = c * vol / 100 + 0x8000 ;                    // Yes, scale according to volume and shift above negative values 
+    #else
+      c = c * vol / 100 ;                             // Scale according to volume
+    #endif
+  #endif
+  #ifdef DEC_HELIX_SPDIF                              // Spdif output?
+    uint16_t hi, lo, aux ;                            // Needed for spdif conversion
+    hi = spdif_bmclookup[(uint8_t)(c >> 8)] ;         // Convert high byte of sample, sign extend later
+    lo = spdif_bmclookup[(uint8_t)c] ;                // Convert low byte of sample
+    // Low word is inverted depending on sign bit of high word. Positive causes inversion (XOR with 0xFFFF).
+    lo ^= ( ~( (int16_t)hi ) >> 16 ) ;                // XOR with 0x0000 or 0xFFFF
+    // Compute auxiliary audio databits, XOR with 0x0000 or 0X7FFF
+    aux = 0xb333 ^ (((uint32_t)((int16_t)lo)) >> 17) ;
+    if ( left )                                       // Left channel?
+    {
+      if ( frame_num )                                // First frame?
+      {
+        i2sbuf[i2sinx++] = VUCP_PREAMBLE_M | aux ;    // No, use preamble M
+      }
+      else
+      {
+        i2sbuf[i2sinx++] = VUCP_PREAMBLE_B | aux ;    // Yes, use preamble B
+      }
+      left = false ;                                  // Next channel is right
+    }
+    else                                              // Right channel
+    {
+      i2sbuf[i2sinx++] = VUCP_PREAMBLE_W | aux ;      // Use preamble W
+      if ( ++frame_num == 192 )                       // Update and check frame number
+      {
+        frame_num = 0 ;                               // Start a new frame
+      }
+      left = true ;                                   // Next sample is left
+    }
+    i2sbuf[i2sinx++] = ( (uint32_t)lo << 16 ) | hi ;  // Store the 32 data bits (16 bit sample) 
+  #else
+    i2sbuf[i2sinx++] = c ;                            // Store 16 bits data
+  #endif
+  if ( i2sinx == I2SSIZE )                            // Buffer filled?
+  {
+    if ( i2s_write ( I2S_NUM_0, i2sbuf,               // Yes, send to I2S
+                     sizeof(i2sbuf), &bw,
+                     portMAX_DELAY ) != ESP_OK )
+    {
+      ESP_LOGI ( HTAG, "i2s_write error!" ) ;
+    }
+    if ( bw != sizeof(i2sbuf) )
+    {
+      ESP_LOGI ( HTAG, "i2s_write bytes written %d, should be %d!",
+                 bw, sizeof(i2sbuf) ) ;
+    }
+    i2sinx = 0 ;                                      // Start at new buffer
   }
 }
 
@@ -83,7 +204,7 @@ void helixInit ( uint8_t enable_pin, uint8_t disable_pin )
 //**************************************************************************************************
 // Play the next 32 bytes.                                                                         *
 //**************************************************************************************************
-void playChunk ( i2s_port_t i2s_num, const uint8_t* chunk )
+void playChunk ( const uint8_t* chunk )
 {
   static uint32_t samprate ;                          // Sample rate
   static int      channels ;                          // Number of channels
@@ -92,11 +213,8 @@ void playChunk ( i2s_port_t i2s_num, const uint8_t* chunk )
   int             s ;                                 // Position of syncword
   static bool     once ;                              // To execute part of code once
   int             n ;                                 // Number of samples decoded
-
   int             br = 0 ;                            // Bit rate
   int             bps = 0 ;                           // Bits per sample
-  int             ops = 0 ;                           // Number of output samples
-  size_t          bw ;                                // Number of bytes written to I2S
 
   memcpy ( mp3bpnt, chunk, 32 ) ;                     // Add chunk to frame buffer
   mp3bcnt += 32 ;                                     // Update counter
@@ -105,11 +223,11 @@ void playChunk ( i2s_port_t i2s_num, const uint8_t* chunk )
   {
     if ( mp3mode )
     {
-      s = MP3FindSyncWord ( mp3buff, mp3bcnt ) ;    // Search for first frame
+      s = MP3FindSyncWord ( mp3buff, mp3bcnt ) ;      // Search for first mp3 frame
     }
     else
     {
-      s = AACFindSyncWord ( mp3buff, mp3bcnt ) ;      // Search for first frame
+      s = AACFindSyncWord ( mp3buff, mp3bcnt ) ;      // Search for first aac frame
     }
     if ( ( searchFrame = ( s < 0 ) ) )                // Sync found?
     {
@@ -121,7 +239,7 @@ void playChunk ( i2s_port_t i2s_num, const uint8_t* chunk )
     else
     {
       once = true ;                                   // Get samplerate once
-      dbgprint ( "Sync found at 0x%04X", s ) ;
+      ESP_LOGI ( HTAG, "Sync found at 0x%04X", s ) ;
       if ( s > 0 )
       {
         mp3bcnt -= s ;                                // Frame found, update count
@@ -143,9 +261,9 @@ void playChunk ( i2s_port_t i2s_num, const uint8_t* chunk )
         {
           samprate = MP3GetSampRate() ;               // Get sample rate
           channels = MP3GetChannels() ;               // Get number of channels
-          br = MP3GetBitrate() ;                      // Get bit rate
-          bps = MP3GetBitsPerSample() ;               // Get bits per sample
-          ops = MP3GetOutputSamps() ;                 // Get number of output samples
+          br       = MP3GetBitrate() ;                // Get bit rate
+          bps      = MP3GetBitsPerSample() ;          // Get bits per sample
+          smpwords = MP3GetOutputSamps() ;            // Get number of output samples
         }
       }
     }
@@ -158,58 +276,52 @@ void playChunk ( i2s_port_t i2s_num, const uint8_t* chunk )
         {
           samprate = AACGetSampRate() ;               // Get sample rate
           channels = AACGetChannels() ;               // Get number of channels
-          br = AACGetBitrate() ;                      // Get bit rate
-          bps = AACGetBitsPerSample() ;               // Get bits per sample
-          ops = AACGetOutputSamps() ;                 // Get number of output samples (bytes)
+          br       = AACGetBitrate() ;                // Get bit rate
+          bps      = AACGetBitsPerSample() ;          // Get bits per sample
+          smpwords = AACGetOutputSamps() ;            // Get number of output (16 bit) samples
         }
       }
     }
     int hb = mp3bcnt - newcnt ;                       // Number of bytes handled
     if ( n < 0 )                                      // Check if decode is okay
     {
-      dbgprint ( "MP3Decode error %d", n ) ;
+      ESP_LOGI ( HTAG, "MP3Decode error %d", n ) ;
       helixInit ( -1, -1 ) ;                          // Totally wrong, start all over
       return ;
     }
     if ( once )
     {
-      smpbytes = ops * channels ;                     // Number of bytes in outbuf
-      smpwords = smpbytes / 2 ;                       // Number of samples in outbuf
-      dbgprint ( "Bitrate     is %d", br ) ;          // Show decoder parameters
-      dbgprint ( "Samprate    is %d", samprate ) ;
-      dbgprint ( "Channels    is %d", channels ) ;
-      dbgprint ( "Bitpersamp  is %d", bps ) ;
-      dbgprint ( "Outputsamps is %d", ops ) ;
-      i2s_set_sample_rates ( i2s_num, samprate ) ;    // Set samplerate
-      i2s_start ( i2s_num ) ;                         // Start DAC
+      smpbytes = smpwords * 2 ;                       // Number of bytes in outbuf
+      ESP_LOGI ( HTAG, "Bitrate     is %d", br ) ;    // Show decoder parameters
+      ESP_LOGI ( HTAG, "Samprate    is %d", samprate ) ;
+      ESP_LOGI ( HTAG, "Channels    is %d", channels ) ;
+      ESP_LOGI ( HTAG, "Bitpersamp  is %d", bps ) ;
+      ESP_LOGI ( HTAG, "Outputsamps is %d", smpwords ) ;
+      if ( br )                                       // Prevent division by zero
+      {
+       #ifdef DEC_HELIX_SPDIF
+        i2s_set_sample_rates ( I2S_NUM_0,             // Set samplerate (biphase)
+                               samprate*2 ) ;
+       #else
+        i2s_set_sample_rates ( I2S_NUM_0,             // Set samplerate
+                               samprate ) ;
+       #endif
+      }
+      i2s_start ( I2S_NUM_0 ) ;                       // Start I2S output
       once = false ;                                  // No need to set samplerate again
     }
     if ( muteflag )                                   // Muted?
     {
       memset ( outbuf, 0, smpbytes ) ;                // Yes, clear buffer
     }
-    else
+    for ( int i = 0 ; i < smpwords ; i++ )            // Handle all samples in outbuf
     {
-      #ifdef DEC_HELIX                                // Helix conversion?
-        #ifdef DEC_HELIX_INT                          // Internal DAC used?
-          for ( int i = 0 ; i < smpwords ; i++ )      // Yes, modify output buffer because
-          {                                           // internal DAC is not signed
-            outbuf[i] = ( outbuf[i] * vol / 100 ) +   // Scale according to volume
-                          0x8000 ;
-          }
-        #else
-          for ( int i = 0 ; i < smpwords ; i++ )        // Volume scaling
-          {
-            outbuf[i] = outbuf[i] * vol / 100 ;         // Scale according to volume
-          }
-        #endif
-      #endif
-      #ifdef DEC_HELIX_AI
-        //                                            // Volume will be set directly
-      #endif
+      outputSample ( outbuf[i] ) ;
+      if ( channels == 1 )                            // Mono signal?
+      {
+        outputSample ( outbuf[i] ) ;                  // Yes, right sample equals left sample
+      }
     }
-    i2s_write ( i2s_num, outbuf, smpbytes, &bw,       // Send to I2S
-                portMAX_DELAY  ) ;
     mp3bcnt -= hb ;
     memcpy ( mp3buff, mp3buff + hb,                   // Shift mp3 data to begin of buffer
              mp3bcnt ) ;
diff --git a/lib/ILI9341/src/ILI9341.cpp b/lib/ILI9341/src/ILI9341.cpp
index c753348..e491872 100644
--- a/lib/ILI9341/src/ILI9341.cpp
+++ b/lib/ILI9341/src/ILI9341.cpp
@@ -8,7 +8,7 @@
 
 #include "ILI9341.h"
 
-char*       dbgprint ( const char* format, ... ) ;          // Print a formatted debug line
+extern bool  pin_exists ( uint8_t pin ) ;                  // Check GPIO pin number
 
 // Data to display.  There are TFTSECS sections
 scrseg_struct     ILI9341_tftdata[TFTSECS] =                        // Screen divided in 3 segments + 1 overlay
@@ -20,14 +20,17 @@ scrseg_struct     ILI9341_tftdata[TFTSECS] =                        // Screen di
 } ;
 
 
-Adafruit_ILI9341*     ILI9341_tft ;                                       // For instance of display driver
+Adafruit_ILI9341*     ILI9341_tft = NULL ;                  // For instance of display driver
 
 
 bool ILI9341_dsp_begin ( int8_t cs, int8_t dc )
 {
-  if ( ( ILI9341_tft = new Adafruit_ILI9341 ( cs, dc ) ) )                // Create an instance for TFT
+  if ( pin_exists ( cs ) && pin_exists ( dc ) )
   {
-    ILI9341_tft->begin() ;                                                // Init TFT interface
+    if ( ( ILI9341_tft = new Adafruit_ILI9341 ( cs, dc ) ) )                // Create an instance for TFT
+    {
+      ILI9341_tft->begin() ;                                                // Init TFT interface
+    }
   }
   return ( ILI9341_tft != NULL ) ;
 }
diff --git a/lib/ILI9341/src/ILI9341.h b/lib/ILI9341/src/ILI9341.h
index ab163f5..22b6ed1 100644
--- a/lib/ILI9341/src/ILI9341.h
+++ b/lib/ILI9341/src/ILI9341.h
@@ -26,7 +26,7 @@
 #define MAGENTA RED | BLUE
 #define YELLOW  RED | GREEN
 #define WHITE   RED | BLUE | GREEN
-#define GRAY    0x7bf0
+#define GREY    0x7bf0
 
 #define DEFTXTSIZ   1                                 // Default text size
 
@@ -62,7 +62,6 @@ extern Adafruit_ILI9341*    ILI9341_tft ;                                 // For
 #define dsp_getwidth()          320                                       // Adjust to your display
 #define dsp_getheight()         240                                       // Get height of screen
 #define dsp_update(a)                                                     // Updates to the physical screen
-#define dsp_usesSPI()           true                                      // Does use SPI
 #define dsp_begin               ILI9341_dsp_begin                         // Init driver
 
 extern scrseg_struct     ILI9341_tftdata[TFTSECS] ;                       // Screen divided in segments
diff --git a/lib/LCD1602/src/LCD1602.cpp b/lib/LCD1602/src/LCD1602.cpp
index df490d5..61ffc01 100644
--- a/lib/LCD1602/src/LCD1602.cpp
+++ b/lib/LCD1602/src/LCD1602.cpp
@@ -22,8 +22,6 @@
 #include <Wire.h>
 #include "LCD1602.h"
 
-char*       dbgprint ( const char* format, ... ) ;          // Print a formatted debug line
-
 scrseg_struct     LCD1602_tftdata[TFTSECS] =                // Screen divided in 4 segments
                       {
                         { false, WHITE,   0,  0, "" },      // 1 top line (dummy)
@@ -35,6 +33,8 @@ scrseg_struct     LCD1602_tftdata[TFTSECS] =                // Screen divided in
 
 LCD1602* LCD1602_tft = NULL ;
 
+const char*   LTAG = "LCD1602" ;                // For debugging
+
 //***********************************************************************************************
 //                                L C D 1 6 0 2  write functions                                *
 //***********************************************************************************************
@@ -194,7 +194,7 @@ void LCD1602::reset()
 // {
 //   byte error, address ;
 
-//   dbgprint ( "Scanning I2C bus..." ) ;
+//   ESP_LOGI ( LTAG, "Scanning I2C bus..." ) ;
 
 //   for ( address = 1 ; address < 127 ; address++ ) 
 //   {
@@ -202,11 +202,11 @@ void LCD1602::reset()
 //     error = Wire.endTransmission() ;
 //     if ( error == 0 )
 //     {
-//       dbgprint ( "I2C device 0x%02X found", address ) ;
+//       ESP_LOGI ( LTAG, "I2C device 0x%02X found", address ) ;
 //     }
 //     else if ( error == 4 ) 
 //     {
-//       dbgprint ( "Error 4 at address 0x%02X", address ) ;
+//       ESP_LOGE ( LTAG, "Error 4 at address 0x%02X", address ) ;
 //     }    
 //   }
 // }
@@ -223,7 +223,7 @@ LCD1602::LCD1602 ( int8_t sda, int8_t scl )
 
   if ( ! Wire.begin ( sda, scl ) )                             // Init I2c
   {
-    dbgprint ( "I2C driver install error!" ) ;
+    ESP_LOGE ( LTAG, "I2C driver install error!" ) ;
   }
   else
   {
@@ -232,7 +232,7 @@ LCD1602::LCD1602 ( int8_t sda, int8_t scl )
     error = Wire.endTransmission() ;
     if ( error )
     {
-      dbgprint ( "Display not found on I2C 0x%02X",
+      ESP_LOGE ( LTAG, "Display not found on I2C 0x%02X",
                   LCD_I2C_ADDRESS ) ;
     }    
   }
@@ -253,14 +253,14 @@ dsp_str dline[2] = { { "", 0, 0, 0 },
 
 bool LCD1602_dsp_begin ( int8_t sda, int8_t scl )
 {
-  dbgprint ( "Init LCD1602, I2C pins %d,%d", sda, scl ) ;
+  ESP_LOGI ( LTAG, "Init LCD1602, I2C pins %d,%d", sda, scl ) ;
   if ( ( sda >= 0 ) && ( scl >= 0 ) )
   {
     LCD1602_tft = new LCD1602 ( sda, scl ) ;            // Create an instance for TFT
   }
   else
   {
-    dbgprint ( "Init LCD1602 failed!" ) ;
+    ESP_LOGE ( LTAG, "Init LCD1602 failed!" ) ;
   }
   return ( LCD1602_tft != NULL ) ;
 }
@@ -278,7 +278,7 @@ void LCD1602_dsp_update_line ( uint8_t lnr )
 
   p = dline[lnr].str.c_str() ;
   dline[lnr].len = strlen ( p ) ;
-  //dbgprint ( "Strlen is %d, str is %s", len, p ) ;
+  //ESP_LOGI ( LTAG, "Strlen is %d, str is %s", len, p ) ;
   if ( dline[lnr].len > 16 )
   {
     if ( dline[lnr].pos >= dline[lnr].len )
diff --git a/lib/LCD1602/src/LCD1602.h b/lib/LCD1602/src/LCD1602.h
index 10eb9d9..c7393ae 100644
--- a/lib/LCD1602/src/LCD1602.h
+++ b/lib/LCD1602/src/LCD1602.h
@@ -39,7 +39,7 @@
 #define MAGENTA RED | BLUE
 #define YELLOW  RED | GREEN
 #define WHITE   RED | GREEN | BLUE
-#define GRAY    RED | GREEN | BLUE
+#define GREY    RED | GREEN | BLUE
 
 #define DEFTXTSIZ   1                        // Default text size
 
@@ -77,7 +77,6 @@
 #define dsp_erase()         LCD1602_tft->sclear()                  // Clear the screen
 #define dsp_getwidth()      16                                     // Get width of screen
 #define dsp_getheight()     2                                      // Get height of screen
-#define dsp_usesSPI()       false                                  // Does not use SPI
 #define dsp_begin           LCD1602_dsp_begin                      // Init driver
 #define dsp_update          LCD1602_dsp_update                     // Update one line
 
diff --git a/lib/LCD2004/src/LCD2004.cpp b/lib/LCD2004/src/LCD2004.cpp
index b21462a..a6843b4 100644
--- a/lib/LCD2004/src/LCD2004.cpp
+++ b/lib/LCD2004/src/LCD2004.cpp
@@ -28,7 +28,6 @@
 #include "LCD2004.h"
 #include <time.h>
 
-char*       dbgprint ( const char* format, ... ) ;          // Print a formatted debug line
 extern      struct tm timeinfo ;                            // Will be filled by NTP server
 
 
@@ -41,17 +40,19 @@ scrseg_struct     LCD2004_tftdata[TFTSECS] =                // Screen divided in
 } ;
 
 LCD2004* LCD2004_tft = NULL ;
+const char*   LTAG = "LCD1602" ;                            // For debugging
+
 
 bool LCD2004_dsp_begin (  int8_t sda, int8_t scl  )
 {
-  dbgprint ( "Init LCD2004, I2C pins %d,%d", sda, scl ) ;
+  ESP_LOGI ( LTAG, "Init LCD2004, I2C pins %d,%d", sda, scl ) ;
   if ( ( sda >= 0 ) && ( scl >= 0 ) )
   {
     LCD2004_tft = new LCD2004 ( sda, scl ) ;                // Create an instance for TFT
   }
   else
   {
-    dbgprint ( "Init LCD2004 failed!" ) ;
+    ESP_LOGE ( LTAG, "Init LCD2004 failed!" ) ;
   }
   return ( LCD2004_tft != NULL ) ;
 }
@@ -220,7 +221,7 @@ void LCD2004::reset()
 // {
 //   byte error, address ;
 
-//   dbgprint ( "Scanning I2C bus..." ) ;
+//   ESP_LOGI ( LTAG, "Scanning I2C bus..." ) ;
 
 //   for ( address = 1 ; address < 127 ; address++ ) 
 //   {
@@ -228,11 +229,11 @@ void LCD2004::reset()
 //     error = Wire.endTransmission() ;
 //     if ( error == 0 )
 //     {
-//       dbgprint ( "I2C device 0x%02X found", address ) ;
+//       ESP_LOGI ( LTAG, "I2C device 0x%02X found", address ) ;
 //     }
 //     else if ( error == 4 ) 
 //     {
-//       dbgprint ( "Error 4 at address 0x%02X", address ) ;
+//       ESP_LOGE ( LTAG, "Error 4 at address 0x%02X", address ) ;
 //     }    
 //   }
 // }
@@ -249,7 +250,7 @@ LCD2004::LCD2004 ( int8_t sda, int8_t scl )
 
   if ( ! Wire.begin ( sda, scl ) )                             // Init I2c
   {
-    dbgprint ( "I2C driver install error!" ) ;
+    ESP_LOGE ( LTAG, "I2C driver install error!" ) ;
   }
   else
   {
@@ -258,7 +259,7 @@ LCD2004::LCD2004 ( int8_t sda, int8_t scl )
     error = Wire.endTransmission() ;
     if ( error )
     {
-      dbgprint ( "Display not found on I2C 0x%02X",
+      ESP_LOGE ( LTAG, "Display not found on I2C 0x%02X",
                   LCD_I2C_ADDRESS ) ;
     }    
   }
@@ -294,7 +295,7 @@ void LCD2004_dsp_update_line ( uint8_t lnr )
 
   p = line->str.c_str() ;                             // Get pointer to string
   line->len = strlen ( p ) ;                          // Get string length
-  //dbgprint ( "Str %d, len is %d, str is %s",
+  //ESP_LOGI ( LTAG, "Str %d, len is %d, str is %s",
   //           lnr,
   //           line->len, p ) ;
   if ( line->len > dsp_getwidth() )                   // Full string fits?
@@ -393,7 +394,7 @@ void LCD2004_displayvolume ( uint8_t vol )
 
   if ( vol != oldvol )                                // Volume changed?
   {
-    dbgprint ( "Update volume to %d", vol ) ;
+    ESP_LOGI ( LTAG, "Update volume to %d", vol ) ;
     oldvol = vol ;                                    // Remember for next compare
     pos = map ( vol, 0, 100, 0, dsp_getwidth() ) ;    // Compute end position on TFT
     for ( int i = 0 ; i < dsp_getwidth() ; i++ )      // Set oldstr to dots
diff --git a/lib/LCD2004/src/LCD2004.h b/lib/LCD2004/src/LCD2004.h
index 9110b03..f80f0cf 100644
--- a/lib/LCD2004/src/LCD2004.h
+++ b/lib/LCD2004/src/LCD2004.h
@@ -88,7 +88,6 @@ extern scrseg_struct     LCD2004_tftdata[TFTSECS] ;                // Screen div
 #define dsp_erase()         LCD2004_tft->sclear()                  // Clear the screen
 #define dsp_getwidth()      20                                     // Get width of screen
 #define dsp_getheight()     4                                      // Get height of screen
-#define dsp_usesSPI()       false                                  // Does not use SPI
 #define dsp_begin           LCD2004_dsp_begin                      // Init driver
 #define dsp_update          LCD2004_dsp_update                     // Update one line
 #define tftdata             LCD2004_tftdata
diff --git a/lib/NEXTION/src/NEXTION.cpp b/lib/NEXTION/src/NEXTION.cpp
index 160f9ba..e7a7ecb 100644
--- a/lib/NEXTION/src/NEXTION.cpp
+++ b/lib/NEXTION/src/NEXTION.cpp
@@ -5,11 +5,11 @@
 //**************************************************************************************************
 #include "NEXTION.h"
 
-char*       dbgprint ( const char* format, ... ) ;          // Print a formatted debug line
 char        strbuf[40] ;                                    // Buffer for incomplete line
 
 HardwareSerial*   nxtserial = NULL ;                        // Serial port for NEXTION
 void*             NEXTION_tft = (void*)1 ;                  // Dummy declaration
+const char*       NTAG = "NEXTION" ;                        // For debugging
 
 // Data to display.  There are TFTSECS sections
 scrseg_struct     tftdata[TFTSECS] =                        // Screen divided in 3 segments + 1 overlay
@@ -24,14 +24,14 @@ uint8_t pagenr = 0 ;
 
 void NEXTION_nextioncmd ( const char *cmd )
 {
-  dbgprint ( "Nextion command %s", cmd ) ;
+  ESP_LOGI ( NTAG, "Nextion command %s", cmd ) ;
   nxtserial->printf ( "%s\xFF\xFF\xFF", cmd ) ;
 }
 
 
 bool NEXTION_dsp_begin ( int8_t rx, int8_t tx )
 {
-  dbgprint ( "Init Nextion, pins %d, %d", rx, tx ) ;
+  ESP_LOGI ( NTAG, "Init Nextion, pins %d, %d", rx, tx ) ;
   nxtserial = new HardwareSerial ( 2 ) ;
   nxtserial->begin ( 115200, SERIAL_8N1, rx, tx ) ;         // Initialize serial port
   NEXTION_nextioncmd ( "cls BLACK" ) ;                      // Erase screen, non vital
@@ -56,7 +56,7 @@ void NEXTION_dsp_println ( const char* str )
     else
     {
       lnnr = ( lnnr % 10 ) + 1 ;
-      dbgprint ( "NEXTION output '%s' to %d",
+      ESP_LOGI ( NTAG, "NEXTION output '%s' to %d",
                  str, lnnr ) ;
       nxtserial->printf ( "t%d.txt=\"%s\"\xFF\xFF\xFF", lnnr, str ) ;
     }
@@ -93,7 +93,7 @@ void NEXTION_dsp_update ( bool a )                          // Updates to the ph
     {
       if ( tftdata[inx].update_req )
       {
-        dbgprint ( "Nextion t%d.txt=\"%s\"", inx, tftdata[inx].str.c_str() ) ; 
+        ESP_LOGI ( NTAG, "Nextion t%d.txt=\"%s\"", inx, tftdata[inx].str.c_str() ) ; 
         nxtserial->printf ( "t%d.txt=\"%s\"\xFF\xFF\xFF", inx, tftdata[inx].str.c_str() ) ;
         tftdata[inx].update_req = false ;
       }
diff --git a/lib/NEXTION/src/NEXTION.h b/lib/NEXTION/src/NEXTION.h
index 1f5c8b4..a2816e8 100644
--- a/lib/NEXTION/src/NEXTION.h
+++ b/lib/NEXTION/src/NEXTION.h
@@ -50,7 +50,6 @@ struct scrseg_struct                                  // For screen segments
 #define dsp_getwidth()      320                                    // Get width of screen
 #define dsp_getheight()     240                                    // Get height of screen
 #define dsp_update(a)       NEXTION_dsp_update(a)                  // Updates to the physical screen
-#define dsp_usesSPI()       false                                  // Does not use SPI
 #define dsp_begin           NEXTION_dsp_begin                      // Init driver
 
 
diff --git a/lib/OLED/src/oled.cpp b/lib/OLED/src/oled.cpp
index 5c7946c..c97f5f6 100644
--- a/lib/OLED/src/oled.cpp
+++ b/lib/OLED/src/oled.cpp
@@ -10,7 +10,6 @@
 #include <string.h>
 #include "oled.h"
 
-char*       dbgprint ( const char* format, ... ) ;    // Print a formatted debug line
 
 uint16_t     oledtyp ;                                // Type of OLED
 OLED*        tft ;                                    // Object for display
@@ -22,6 +21,8 @@ scrseg_struct OLED_tftdata[TFTSECS] =                 // Screen divided in 3 seg
   { false, GREEN,  40, 22, "" }                       // 3 lines at the bottom for rotary encoder
 } ;
 
+const char*   LTAG = "OLED" ;                            // For debugging
+
 
 //***********************************************************************************************
 //                                  O L E D _ D S P _ B E G I N                                 *
@@ -31,7 +32,7 @@ scrseg_struct OLED_tftdata[TFTSECS] =                 // Screen divided in 3 seg
 bool oled_dsp_begin ( int8_t sda_pin, int8_t scl_pin, uint16_t olt )
 {
   oledtyp = olt ;                                  // Save OLED type
-  dbgprint ( "Init OLED %d, I2C pins %d,%d",
+  ESP_LOGI ( LTAG, "Init OLED %d, I2C pins %d,%d",
              oledtyp,
              sda_pin,
              scl_pin ) ;
@@ -43,7 +44,7 @@ bool oled_dsp_begin ( int8_t sda_pin, int8_t scl_pin, uint16_t olt )
   }
   else
   {
-    dbgprint ( "Init OLED failed!" ) ;
+    ESP_LOGE ( LTAG, "Init OLED failed!" ) ;
   }
   return ( tft != NULL ) ;
 }
diff --git a/lib/OLED/src/oled.h b/lib/OLED/src/oled.h
index cb30ca9..be816e2 100644
--- a/lib/OLED/src/oled.h
+++ b/lib/OLED/src/oled.h
@@ -99,7 +99,6 @@ extern scrseg_struct OLED_tftdata[TFTSECS] ;          // Screen divided in segme
 #define dsp_getwidth()          128                                // Get width of screen
 #define dsp_getheight()         64                                 // Get height of screen
 #define dsp_update(a)           tft->display()                     // Updates to the physical screen
-#define dsp_usesSPI()           false                              // Does not use SPI
 #define dsp_begin               oled_dsp_begin                     // Init driver
 #define displayvolume           oled_displayvolume
 #define displaybattery          oled_displaybattery
diff --git a/lib/SD/README.md b/lib/SD/README.md
deleted file mode 100644
index 2cc472d..0000000
--- a/lib/SD/README.md
+++ /dev/null
@@ -1,42 +0,0 @@
-
-# SD library
-
-This library provides the integration of ESP32 and SD (Secure Digital) cards without additional modules.
-
-
-## Sample wiring diagram:
-
-
-![SD card pins](http://i.imgur.com/4CoXOuR.png)
-
-For others SD formats:
-
-
-![Other SD card formats](https://upload.wikimedia.org/wikipedia/commons/thumb/a/ab/MMC-SD-miniSD-microSD-Color-Numbers-Names.gif/330px-MMC-SD-miniSD-microSD-Color-Numbers-Names.gif)
-
-
-Image source: [Wikipedia](https://upload.wikimedia.org/wikipedia/commons/thumb/a/ab/MMC-SD-miniSD-microSD-Color-Numbers-Names.gif/330px-MMC-SD-miniSD-microSD-Color-Numbers-Names.gif)
-
-```diff
-- Warning: Some ESP32 modules have different pinouts!
-```
-
-
-
-## FAQ:
-
-**Do I need any additional modules, like Arduino SD module?**
-
-No, just wire your SD card directly to ESP32.
-
-
-
-**What is the difference between SD and SD_MMC libraries?**
-
-SD runs on SPI, and SD_MMC uses the SDMMC hardware bus on the ESP32.
-
-
-
-**Can I change the CS pin?**
-
-Yes, just use: `SD.begin(CSpin)`
diff --git a/lib/SD/examples/SD_Test/SD_Test.ino b/lib/SD/examples/SD_Test/SD_Test.ino
deleted file mode 100644
index 8084ee1..0000000
--- a/lib/SD/examples/SD_Test/SD_Test.ino
+++ /dev/null
@@ -1,221 +0,0 @@
-/*
- * Connect the SD card to the following pins:
- *
- * SD Card | ESP32
- *    D2       -
- *    D3       SS
- *    CMD      MOSI
- *    VSS      GND
- *    VDD      3.3V
- *    CLK      SCK
- *    VSS      GND
- *    D0       MISO
- *    D1       -
- */
-#include "FS.h"
-#include "SD.h"
-#include "SPI.h"
-
-void listDir(fs::FS &fs, const char * dirname, uint8_t levels){
-    Serial.printf("Listing directory: %s\n", dirname);
-
-    File root = fs.open(dirname);
-    if(!root){
-        Serial.println("Failed to open directory");
-        return;
-    }
-    if(!root.isDirectory()){
-        Serial.println("Not a directory");
-        return;
-    }
-
-    File file = root.openNextFile();
-    while(file){
-        if(file.isDirectory()){
-            Serial.print("  DIR : ");
-            Serial.println(file.name());
-            if(levels){
-                listDir(fs, file.path(), levels -1);
-            }
-        } else {
-            Serial.print("  FILE: ");
-            Serial.print(file.name());
-            Serial.print("  SIZE: ");
-            Serial.println(file.size());
-        }
-        file = root.openNextFile();
-    }
-}
-
-void createDir(fs::FS &fs, const char * path){
-    Serial.printf("Creating Dir: %s\n", path);
-    if(fs.mkdir(path)){
-        Serial.println("Dir created");
-    } else {
-        Serial.println("mkdir failed");
-    }
-}
-
-void removeDir(fs::FS &fs, const char * path){
-    Serial.printf("Removing Dir: %s\n", path);
-    if(fs.rmdir(path)){
-        Serial.println("Dir removed");
-    } else {
-        Serial.println("rmdir failed");
-    }
-}
-
-void readFile(fs::FS &fs, const char * path){
-    Serial.printf("Reading file: %s\n", path);
-
-    File file = fs.open(path);
-    if(!file){
-        Serial.println("Failed to open file for reading");
-        return;
-    }
-
-    Serial.print("Read from file: ");
-    while(file.available()){
-        Serial.write(file.read());
-    }
-    file.close();
-}
-
-void writeFile(fs::FS &fs, const char * path, const char * message){
-    Serial.printf("Writing file: %s\n", path);
-
-    File file = fs.open(path, FILE_WRITE);
-    if(!file){
-        Serial.println("Failed to open file for writing");
-        return;
-    }
-    if(file.print(message)){
-        Serial.println("File written");
-    } else {
-        Serial.println("Write failed");
-    }
-    file.close();
-}
-
-void appendFile(fs::FS &fs, const char * path, const char * message){
-    Serial.printf("Appending to file: %s\n", path);
-
-    File file = fs.open(path, FILE_APPEND);
-    if(!file){
-        Serial.println("Failed to open file for appending");
-        return;
-    }
-    if(file.print(message)){
-        Serial.println("Message appended");
-    } else {
-        Serial.println("Append failed");
-    }
-    file.close();
-}
-
-void renameFile(fs::FS &fs, const char * path1, const char * path2){
-    Serial.printf("Renaming file %s to %s\n", path1, path2);
-    if (fs.rename(path1, path2)) {
-        Serial.println("File renamed");
-    } else {
-        Serial.println("Rename failed");
-    }
-}
-
-void deleteFile(fs::FS &fs, const char * path){
-    Serial.printf("Deleting file: %s\n", path);
-    if(fs.remove(path)){
-        Serial.println("File deleted");
-    } else {
-        Serial.println("Delete failed");
-    }
-}
-
-void testFileIO(fs::FS &fs, const char * path){
-    File file = fs.open(path);
-    static uint8_t buf[512];
-    size_t len = 0;
-    uint32_t start = millis();
-    uint32_t end = start;
-    if(file){
-        len = file.size();
-        size_t flen = len;
-        start = millis();
-        while(len){
-            size_t toRead = len;
-            if(toRead > 512){
-                toRead = 512;
-            }
-            file.read(buf, toRead);
-            len -= toRead;
-        }
-        end = millis() - start;
-        Serial.printf("%u bytes read for %u ms\n", flen, end);
-        file.close();
-    } else {
-        Serial.println("Failed to open file for reading");
-    }
-
-
-    file = fs.open(path, FILE_WRITE);
-    if(!file){
-        Serial.println("Failed to open file for writing");
-        return;
-    }
-
-    size_t i;
-    start = millis();
-    for(i=0; i<2048; i++){
-        file.write(buf, 512);
-    }
-    end = millis() - start;
-    Serial.printf("%u bytes written for %u ms\n", 2048 * 512, end);
-    file.close();
-}
-
-void setup(){
-    Serial.begin(115200);
-    if(!SD.begin()){
-        Serial.println("Card Mount Failed");
-        return;
-    }
-    uint8_t cardType = SD.cardType();
-
-    if(cardType == CARD_NONE){
-        Serial.println("No SD card attached");
-        return;
-    }
-
-    Serial.print("SD Card Type: ");
-    if(cardType == CARD_MMC){
-        Serial.println("MMC");
-    } else if(cardType == CARD_SD){
-        Serial.println("SDSC");
-    } else if(cardType == CARD_SDHC){
-        Serial.println("SDHC");
-    } else {
-        Serial.println("UNKNOWN");
-    }
-
-    uint64_t cardSize = SD.cardSize() / (1024 * 1024);
-    Serial.printf("SD Card Size: %lluMB\n", cardSize);
-
-    listDir(SD, "/", 0);
-    createDir(SD, "/mydir");
-    listDir(SD, "/", 0);
-    removeDir(SD, "/mydir");
-    listDir(SD, "/", 2);
-    writeFile(SD, "/hello.txt", "Hello ");
-    appendFile(SD, "/hello.txt", "World!\n");
-    readFile(SD, "/hello.txt");
-    deleteFile(SD, "/foo.txt");
-    renameFile(SD, "/hello.txt", "/foo.txt");
-    readFile(SD, "/foo.txt");
-    testFileIO(SD, "/test.txt");
-    Serial.printf("Total space: %lluMB\n", SD.totalBytes() / (1024 * 1024));
-    Serial.printf("Used space: %lluMB\n", SD.usedBytes() / (1024 * 1024));
-}
-
-void loop(){
-
-}
diff --git a/lib/SD/examples/SD_time/SD_time.ino b/lib/SD/examples/SD_time/SD_time.ino
deleted file mode 100644
index ff35d67..0000000
--- a/lib/SD/examples/SD_time/SD_time.ino
+++ /dev/null
@@ -1,217 +0,0 @@
-/*
- * Connect the SD card to the following pins:
- *
- * SD Card | ESP32
- *    D2       -
- *    D3       SS
- *    CMD      MOSI
- *    VSS      GND
- *    VDD      3.3V
- *    CLK      SCK
- *    VSS      GND
- *    D0       MISO
- *    D1       -
- */
-
-#include "FS.h"
-#include "SD.h"
-#include "SPI.h"
-#include <time.h> 
-#include <WiFi.h>
-
-const char* ssid     = "your-ssid";
-const char* password = "your-password";
-
-long timezone = 1; 
-byte daysavetime = 1;
-
-void listDir(fs::FS &fs, const char * dirname, uint8_t levels){
-    Serial.printf("Listing directory: %s\n", dirname);
-
-    File root = fs.open(dirname);
-    if(!root){
-        Serial.println("Failed to open directory");
-        return;
-    }
-    if(!root.isDirectory()){
-        Serial.println("Not a directory");
-        return;
-    }
-
-    File file = root.openNextFile();
-    while(file){
-        if(file.isDirectory()){
-            Serial.print("  DIR : ");
-            Serial.print (file.name());
-            time_t t= file.getLastWrite();
-            struct tm * tmstruct = localtime(&t);
-            Serial.printf("  LAST WRITE: %d-%02d-%02d %02d:%02d:%02d\n",(tmstruct->tm_year)+1900,( tmstruct->tm_mon)+1, tmstruct->tm_mday,tmstruct->tm_hour , tmstruct->tm_min, tmstruct->tm_sec);
-            if(levels){
-                listDir(fs, file.path(), levels -1);
-            }
-        } else {
-            Serial.print("  FILE: ");
-            Serial.print(file.name());
-            Serial.print("  SIZE: ");
-            Serial.print(file.size());
-            time_t t= file.getLastWrite();
-            struct tm * tmstruct = localtime(&t);
-            Serial.printf("  LAST WRITE: %d-%02d-%02d %02d:%02d:%02d\n",(tmstruct->tm_year)+1900,( tmstruct->tm_mon)+1, tmstruct->tm_mday,tmstruct->tm_hour , tmstruct->tm_min, tmstruct->tm_sec);
-        }
-        file = root.openNextFile();
-    }
-}
-
-void createDir(fs::FS &fs, const char * path){
-    Serial.printf("Creating Dir: %s\n", path);
-    if(fs.mkdir(path)){
-        Serial.println("Dir created");
-    } else {
-        Serial.println("mkdir failed");
-    }
-}
-
-void removeDir(fs::FS &fs, const char * path){
-    Serial.printf("Removing Dir: %s\n", path);
-    if(fs.rmdir(path)){
-        Serial.println("Dir removed");
-    } else {
-        Serial.println("rmdir failed");
-    }
-}
-
-void readFile(fs::FS &fs, const char * path){
-    Serial.printf("Reading file: %s\n", path);
-
-    File file = fs.open(path);
-    if(!file){
-        Serial.println("Failed to open file for reading");
-        return;
-    }
-
-    Serial.print("Read from file: ");
-    while(file.available()){
-        Serial.write(file.read());
-    }
-    file.close();
-}
-
-void writeFile(fs::FS &fs, const char * path, const char * message){
-    Serial.printf("Writing file: %s\n", path);
-
-    File file = fs.open(path, FILE_WRITE);
-    if(!file){
-        Serial.println("Failed to open file for writing");
-        return;
-    }
-    if(file.print(message)){
-        Serial.println("File written");
-    } else {
-        Serial.println("Write failed");
-    }
-    file.close();
-}
-
-void appendFile(fs::FS &fs, const char * path, const char * message){
-    Serial.printf("Appending to file: %s\n", path);
-
-    File file = fs.open(path, FILE_APPEND);
-    if(!file){
-        Serial.println("Failed to open file for appending");
-        return;
-    }
-    if(file.print(message)){
-        Serial.println("Message appended");
-    } else {
-        Serial.println("Append failed");
-    }
-    file.close();
-}
-
-void renameFile(fs::FS &fs, const char * path1, const char * path2){
-    Serial.printf("Renaming file %s to %s\n", path1, path2);
-    if (fs.rename(path1, path2)) {
-        Serial.println("File renamed");
-    } else {
-        Serial.println("Rename failed");
-    }
-}
-
-void deleteFile(fs::FS &fs, const char * path){
-    Serial.printf("Deleting file: %s\n", path);
-    if(fs.remove(path)){
-        Serial.println("File deleted");
-    } else {
-        Serial.println("Delete failed");
-    }
-}
-
-void setup(){
-    Serial.begin(115200);
-    // We start by connecting to a WiFi network
-    Serial.println();
-    Serial.println();
-    Serial.print("Connecting to ");
-    Serial.println(ssid);
-
-    WiFi.begin(ssid, password);
-
-    while (WiFi.status() != WL_CONNECTED) {
-        delay(500);
-        Serial.print(".");
-    }
-    Serial.println("WiFi connected");
-    Serial.println("IP address: ");
-    Serial.println(WiFi.localIP());
-    Serial.println("Contacting Time Server");
-    /*
-        Note: Bundled Arduino lwip supports only ONE ntp server, 2nd and 3rd options are silently ignored
-        see CONFIG_LWIP_DHCP_MAX_NTP_SERVERS define in ./tools/sdk/esp32/sdkconfig
-     */
-	configTime(3600*timezone, daysavetime*3600, "time.nist.gov", "0.pool.ntp.org", "1.pool.ntp.org");
-	struct tm tmstruct ;
-    delay(2000);
-    tmstruct.tm_year = 0;
-    getLocalTime(&tmstruct, 5000);
-	Serial.printf("\nNow is : %d-%02d-%02d %02d:%02d:%02d\n",(tmstruct.tm_year)+1900,( tmstruct.tm_mon)+1, tmstruct.tm_mday,tmstruct.tm_hour , tmstruct.tm_min, tmstruct.tm_sec);
-    Serial.println("");
-    
-    if(!SD.begin()){
-        Serial.println("Card Mount Failed");
-        return;
-    }
-    uint8_t cardType = SD.cardType();
-
-    if(cardType == CARD_NONE){
-        Serial.println("No SD card attached");
-        return;
-    }
-
-    Serial.print("SD Card Type: ");
-    if(cardType == CARD_MMC){
-        Serial.println("MMC");
-    } else if(cardType == CARD_SD){
-        Serial.println("SDSC");
-    } else if(cardType == CARD_SDHC){
-        Serial.println("SDHC");
-    } else {
-        Serial.println("UNKNOWN");
-    }
-
-    uint64_t cardSize = SD.cardSize() / (1024 * 1024);
-    Serial.printf("SD Card Size: %lluMB\n", cardSize);
-
-    listDir(SD, "/", 0);
-    removeDir(SD, "/mydir");
-    createDir(SD, "/mydir");
-    deleteFile(SD, "/hello.txt");
-    writeFile(SD, "/hello.txt", "Hello ");
-    appendFile(SD, "/hello.txt", "World!\n");
-	listDir(SD, "/", 0);
-}
-
-void loop(){
-
-}
-
-
diff --git a/lib/SD/library.properties b/lib/SD/library.properties
deleted file mode 100644
index 449d0b0..0000000
--- a/lib/SD/library.properties
+++ /dev/null
@@ -1,9 +0,0 @@
-name=SD
-version=2.0.0
-author=Arduino, SparkFun
-maintainer=Arduino <info@arduino.cc>
-sentence=Enables reading and writing on SD cards. For all Arduino boards.
-paragraph=Once an SD memory card is connected to the SPI interfare of the Arduino board you are enabled to create files and read/write on them. You can also move through directories on the SD card.
-category=Data Storage
-url=http://www.arduino.cc/en/Reference/SD
-architectures=esp32
diff --git a/lib/SD/src/SD.cpp b/lib/SD/src/SD.cpp
deleted file mode 100644
index 8e2b6d2..0000000
--- a/lib/SD/src/SD.cpp
+++ /dev/null
@@ -1,117 +0,0 @@
-// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "vfs_api.h"
-#include "sd_diskio.h"
-#include "ff.h"
-#include "FS.h"
-#include "SD.h"
-
-using namespace fs;
-
-SDFS::SDFS(FSImplPtr impl): FS(impl), _pdrv(0xFF) {}
-
-bool SDFS::begin(uint8_t ssPin, SPIClass &spi, uint32_t frequency, const char * mountpoint, uint8_t max_files, bool format_if_empty)
-{
-    if(_pdrv != 0xFF) {
-        return true;
-    }
-
-    spi.begin();
-
-    _pdrv = sdcard_init(ssPin, &spi, frequency);
-    if(_pdrv == 0xFF) {
-        return false;
-    }
-
-    if(!sdcard_mount(_pdrv, mountpoint, max_files, format_if_empty)){
-        sdcard_unmount(_pdrv);
-        sdcard_uninit(_pdrv);
-        _pdrv = 0xFF;
-        return false;
-    }
-
-    _impl->mountpoint(mountpoint);
-    return true;
-}
-
-void SDFS::end()
-{
-    if(_pdrv != 0xFF) {
-        _impl->mountpoint(NULL);
-        sdcard_unmount(_pdrv);
-
-        sdcard_uninit(_pdrv);
-        _pdrv = 0xFF;
-    }
-}
-
-sdcard_type_t SDFS::cardType()
-{
-    if(_pdrv == 0xFF) {
-        return CARD_NONE;
-    }
-    return sdcard_type(_pdrv);
-}
-
-uint64_t SDFS::cardSize()
-{
-    if(_pdrv == 0xFF) {
-        return 0;
-    }
-    size_t sectors = sdcard_num_sectors(_pdrv);
-    size_t sectorSize = sdcard_sector_size(_pdrv);
-    return (uint64_t)sectors * sectorSize;
-}
-
-uint64_t SDFS::totalBytes()
-{
-	FATFS* fsinfo;
-	DWORD fre_clust;
-	if(f_getfree("0:",&fre_clust,&fsinfo)!= 0) return 0;
-    uint64_t size = ((uint64_t)(fsinfo->csize))*(fsinfo->n_fatent - 2)
-#if _MAX_SS != 512
-        *(fsinfo->ssize);
-#else
-        *512;
-#endif
-	return size;
-}
-
-uint64_t SDFS::usedBytes()
-{
-	FATFS* fsinfo;
-	DWORD fre_clust;
-	if(f_getfree("0:",&fre_clust,&fsinfo)!= 0) return 0;
-	uint64_t size = ((uint64_t)(fsinfo->csize))*((fsinfo->n_fatent - 2) - (fsinfo->free_clst))
-#if _MAX_SS != 512
-        *(fsinfo->ssize);
-#else
-        *512;
-#endif
-	return size;
-}
-
-bool SDFS::readRAW(uint8_t* buffer, uint32_t sector)
-{
-    return sd_read_raw(_pdrv, buffer, sector);
-}
-
-bool SDFS::writeRAW(uint8_t* buffer, uint32_t sector)
-{
-    return sd_write_raw(_pdrv, buffer, sector);
-}
-
-
-SDFS SD = SDFS(FSImplPtr(new VFSImpl()));
diff --git a/lib/SD/src/SD.h b/lib/SD/src/SD.h
deleted file mode 100644
index 665b333..0000000
--- a/lib/SD/src/SD.h
+++ /dev/null
@@ -1,50 +0,0 @@
-// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#ifndef _SD_H_
-#define _SD_H_
-
-#include "FS.h"
-#include "SPI.h"
-#include "sd_defines.h"
-
-namespace fs
-{
-
-class SDFS : public FS
-{
-protected:
-    uint8_t _pdrv;
-
-public:
-    SDFS(FSImplPtr impl);
-    bool begin(uint8_t ssPin=SS, SPIClass &spi=SPI, uint32_t frequency=4000000, const char * mountpoint="/sd", uint8_t max_files=5, bool format_if_empty=false);
-    void end();
-    sdcard_type_t cardType();
-    uint64_t cardSize();
-    uint64_t totalBytes();
-    uint64_t usedBytes();
-    bool readRAW(uint8_t* buffer, uint32_t sector);
-    bool writeRAW(uint8_t* buffer, uint32_t sector);
-};
-
-}
-
-extern fs::SDFS SD;
-
-using namespace fs;
-typedef fs::File        SDFile;
-typedef fs::SDFS        SDFileSystemClass;
-#define SDFileSystem    SD
-
-#endif /* _SD_H_ */
diff --git a/lib/SD/src/sd_defines.h b/lib/SD/src/sd_defines.h
deleted file mode 100644
index 6e42855..0000000
--- a/lib/SD/src/sd_defines.h
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#ifndef _SD_DEFINES_H_
-#define _SD_DEFINES_H_
-
-typedef enum {
-    CARD_NONE,
-    CARD_MMC,
-    CARD_SD,
-    CARD_SDHC,
-    CARD_UNKNOWN
-} sdcard_type_t;
-
-#endif /* _SD_DISKIO_H_ */
diff --git a/lib/SD/src/sd_diskio.cpp b/lib/SD/src/sd_diskio.cpp
deleted file mode 100644
index e69050a..0000000
--- a/lib/SD/src/sd_diskio.cpp
+++ /dev/null
@@ -1,844 +0,0 @@
-// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#include "sd_diskio.h"
-#include "esp_system.h"
-extern "C" {
-    #include "ff.h"
-    #include "diskio.h"
-#if ESP_IDF_VERSION_MAJOR > 3
-    #include "diskio_impl.h"
-#endif
-    //#include "esp_vfs.h"
-    #include "esp_vfs_fat.h"
-    char CRC7(const char* data, int length);
-    unsigned short CRC16(const char* data, int length);
-}
-
-typedef enum {
-    GO_IDLE_STATE           = 0,
-    SEND_OP_COND            = 1,
-    SEND_CID                = 2,
-    SEND_RELATIVE_ADDR      = 3,
-    SEND_SWITCH_FUNC        = 6,
-    SEND_IF_COND            = 8,
-    SEND_CSD                = 9,
-    STOP_TRANSMISSION       = 12,
-    SEND_STATUS             = 13,
-    SET_BLOCKLEN            = 16,
-    READ_BLOCK_SINGLE       = 17,
-    READ_BLOCK_MULTIPLE     = 18,
-    SEND_NUM_WR_BLOCKS      = 22,
-    SET_WR_BLK_ERASE_COUNT  = 23,
-    WRITE_BLOCK_SINGLE      = 24,
-    WRITE_BLOCK_MULTIPLE    = 25,
-    APP_OP_COND             = 41,
-    APP_CLR_CARD_DETECT     = 42,
-    APP_CMD                 = 55,
-    READ_OCR                = 58,
-    CRC_ON_OFF              = 59
-} ardu_sdcard_command_t;
-
-typedef struct {
-    uint8_t ssPin;
-    SPIClass * spi;
-    int frequency;
-    char * base_path;
-    sdcard_type_t type;
-    unsigned long sectors;
-    bool supports_crc;
-    int status;
-} ardu_sdcard_t;
-
-static ardu_sdcard_t* s_cards[FF_VOLUMES] = { NULL };
-
-#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_ERROR
-const char * fferr2str[] = {
-    "(0) Succeeded",
-    "(1) A hard error occurred in the low level disk I/O layer",
-    "(2) Assertion failed",
-    "(3) The physical drive cannot work",
-    "(4) Could not find the file",
-    "(5) Could not find the path",
-    "(6) The path name format is invalid",
-    "(7) Access denied due to prohibited access or directory full",
-    "(8) Access denied due to prohibited access",
-    "(9) The file/directory object is invalid",
-    "(10) The physical drive is write protected",
-    "(11) The logical drive number is invalid",
-    "(12) The volume has no work area",
-    "(13) There is no valid FAT volume",
-    "(14) The f_mkfs() aborted due to any problem",
-    "(15) Could not get a grant to access the volume within defined period",
-    "(16) The operation is rejected according to the file sharing policy",
-    "(17) LFN working buffer could not be allocated",
-    "(18) Number of open files > FF_FS_LOCK",
-    "(19) Given parameter is invalid"
-};
-#endif
-
-/*
- * SD SPI
- * */
-
-bool sdWait(uint8_t pdrv, int timeout)
-{
-    char resp;
-    uint32_t start = millis();
-
-    do {
-        resp = s_cards[pdrv]->spi->transfer(0xFF);
-    } while (resp == 0x00 && (millis() - start) < (unsigned int)timeout);
-
-    if (!resp) {
-        log_w("Wait Failed");
-    }
-    return (resp > 0x00);
-}
-
-void sdStop(uint8_t pdrv)
-{
-    s_cards[pdrv]->spi->write(0xFD);
-}
-
-void sdDeselectCard(uint8_t pdrv)
-{
-    ardu_sdcard_t * card = s_cards[pdrv];
-    digitalWrite(card->ssPin, HIGH);
-}
-
-bool sdSelectCard(uint8_t pdrv)
-{
-    ardu_sdcard_t * card = s_cards[pdrv];
-    digitalWrite(card->ssPin, LOW);
-    bool s = sdWait(pdrv, 300);
-    if (!s) {
-        log_e("Select Failed");
-        digitalWrite(card->ssPin, HIGH);
-        return false;
-    }
-    return true;
-}
-
-char sdCommand(uint8_t pdrv, char cmd, unsigned int arg, unsigned int* resp)
-{
-    char token;
-    ardu_sdcard_t * card = s_cards[pdrv];
-
-    for (int f = 0; f < 3; f++) {
-        if (cmd == SEND_NUM_WR_BLOCKS || cmd == SET_WR_BLK_ERASE_COUNT || cmd == APP_OP_COND || cmd == APP_CLR_CARD_DETECT) {
-            token = sdCommand(pdrv, APP_CMD, 0, NULL);
-            sdDeselectCard(pdrv);
-            if (token > 1) {
-                break;
-            }
-            if(!sdSelectCard(pdrv)) {
-                token = 0xFF;
-                break;
-            }
-        }
-
-        char cmdPacket[7];
-        cmdPacket[0] = cmd | 0x40;
-        cmdPacket[1] = arg >> 24;
-        cmdPacket[2] = arg >> 16;
-        cmdPacket[3] = arg >> 8;
-        cmdPacket[4] = arg;
-        if(card->supports_crc || cmd == GO_IDLE_STATE || cmd == SEND_IF_COND) {
-            cmdPacket[5] = (CRC7(cmdPacket, 5) << 1) | 0x01;
-        } else {
-            cmdPacket[5] = 0x01;
-        }
-        cmdPacket[6] = 0xFF;
-
-        card->spi->writeBytes((uint8_t*)cmdPacket, (cmd == STOP_TRANSMISSION)?7:6);
-
-        for (int i = 0; i < 9; i++) {
-            token = card->spi->transfer(0xFF);
-            if (!(token & 0x80)) {
-                break;
-            }
-        }
-
-        if (token == 0xFF) {
-            log_w("no token received");
-            sdDeselectCard(pdrv);
-            delay(100);
-            sdSelectCard(pdrv);
-            continue;
-        } else if (token & 0x08) {
-            log_w("crc error");
-            sdDeselectCard(pdrv);
-            delay(100);
-            sdSelectCard(pdrv);
-            continue;
-        } else if (token > 1) {
-            log_w("token error [%u] 0x%x", cmd, token);
-            break;
-        }
-
-        if (cmd == SEND_STATUS && resp) {
-            *resp = card->spi->transfer(0xFF);
-        } else if ((cmd == SEND_IF_COND || cmd == READ_OCR) && resp) {
-            *resp = card->spi->transfer32(0xFFFFFFFF);
-        }
-
-        break;
-    }
-    if (token == 0xFF) {
-        log_e("Card Failed! cmd: 0x%02x", cmd);
-        card->status = STA_NOINIT;
-    }
-    return token;
-}
-
-bool sdReadBytes(uint8_t pdrv, char* buffer, int length)
-{
-    char token;
-    unsigned short crc;
-    ardu_sdcard_t * card = s_cards[pdrv];
-
-    uint32_t start = millis();
-    do {
-        token = card->spi->transfer(0xFF);
-    } while (token == 0xFF && (millis() - start) < 500);
-
-    if (token != 0xFE) {
-        return false;
-    }
-
-    card->spi->transferBytes(NULL, (uint8_t*)buffer, length);
-    crc = card->spi->transfer16(0xFFFF);
-    return (!card->supports_crc || crc == CRC16(buffer, length));
-}
-
-char sdWriteBytes(uint8_t pdrv, const char* buffer, char token)
-{
-    ardu_sdcard_t * card = s_cards[pdrv];
-    unsigned short crc = (card->supports_crc)?CRC16(buffer, 512):0xFFFF;
-    if (!sdWait(pdrv, 500)) {
-        return false;
-    }
-
-    card->spi->write(token);
-    card->spi->writeBytes((uint8_t*)buffer, 512);
-    card->spi->write16(crc);
-    return (card->spi->transfer(0xFF) & 0x1F);
-}
-
-/*
- * SPI SDCARD Communication
- * */
-
-char sdTransaction(uint8_t pdrv, char cmd, unsigned int arg, unsigned int* resp)
-{
-    if(!sdSelectCard(pdrv)) {
-        return 0xFF;
-    }
-    char token = sdCommand(pdrv, cmd, arg, resp);
-    sdDeselectCard(pdrv);
-    return token;
-}
-
-bool sdReadSector(uint8_t pdrv, char* buffer, unsigned long long sector)
-{
-    for (int f = 0; f < 3; f++) {
-        if(!sdSelectCard(pdrv)) {
-            return false;
-        }
-        if (!sdCommand(pdrv, READ_BLOCK_SINGLE, (s_cards[pdrv]->type == CARD_SDHC) ? sector : sector << 9, NULL)) {
-            bool success = sdReadBytes(pdrv, buffer, 512);
-            sdDeselectCard(pdrv);
-            if (success) {
-                return true;
-            }
-        } else {
-            break;
-        }
-    }
-    sdDeselectCard(pdrv);
-    return false;
-}
-
-bool sdReadSectors(uint8_t pdrv, char* buffer, unsigned long long sector, int count)
-{
-    for (int f = 0; f < 3;) {
-        if(!sdSelectCard(pdrv)) {
-            return false;
-        }
-
-        if (!sdCommand(pdrv, READ_BLOCK_MULTIPLE, (s_cards[pdrv]->type == CARD_SDHC) ? sector : sector << 9, NULL)) {
-            do {
-                if (!sdReadBytes(pdrv, buffer, 512)) {
-                    f++;
-                    break;
-                }
-
-                sector++;
-                buffer += 512;
-                f = 0;
-            } while (--count);
-
-            if (sdCommand(pdrv, STOP_TRANSMISSION, 0, NULL)) {
-                log_e("command failed");
-                break;
-            }
-
-            sdDeselectCard(pdrv);
-            if (count == 0) {
-                return true;
-            }
-        } else {
-            break;
-        }
-    }
-    sdDeselectCard(pdrv);
-    return false;
-}
-
-bool sdWriteSector(uint8_t pdrv, const char* buffer, unsigned long long sector)
-{
-    for (int f = 0; f < 3; f++) {
-        if(!sdSelectCard(pdrv)) {
-            return false;
-        }
-        if (!sdCommand(pdrv, WRITE_BLOCK_SINGLE, (s_cards[pdrv]->type == CARD_SDHC) ? sector : sector << 9, NULL)) {
-            char token = sdWriteBytes(pdrv, buffer, 0xFE);
-            sdDeselectCard(pdrv);
-
-            if (token == 0x0A) {
-                continue;
-            } else if (token == 0x0C) {
-                return false;
-            }
-
-            unsigned int resp;
-            if (sdTransaction(pdrv, SEND_STATUS, 0, &resp) || resp) {
-                return false;
-            }
-            return true;
-        } else {
-            break;
-        }
-    }
-    sdDeselectCard(pdrv);
-    return false;
-}
-
-bool sdWriteSectors(uint8_t pdrv, const char* buffer, unsigned long long sector, int count)
-{
-    char token;
-    const char* currentBuffer = buffer;
-    unsigned long long currentSector = sector;
-    int currentCount = count;
-    ardu_sdcard_t * card = s_cards[pdrv];
-
-    for (int f = 0; f < 3;) {
-        if (card->type != CARD_MMC) {
-            if (sdTransaction(pdrv, SET_WR_BLK_ERASE_COUNT, currentCount, NULL)) {
-                return false;
-            }
-        }
-
-        if(!sdSelectCard(pdrv)) {
-            return false;
-        }
-
-        if (!sdCommand(pdrv, WRITE_BLOCK_MULTIPLE, (card->type == CARD_SDHC) ? currentSector : currentSector << 9, NULL)) {
-            do {
-                token = sdWriteBytes(pdrv, currentBuffer, 0xFC);
-                if (token != 0x05) {
-                    f++;
-                    break;
-                }
-                currentBuffer += 512;
-                f = 0;
-            } while (--currentCount);
-
-            if (!sdWait(pdrv, 500)) {
-                break;
-            }
-
-            if (currentCount == 0) {
-                sdStop(pdrv);
-                sdDeselectCard(pdrv);
-
-                unsigned int resp;
-                if (sdTransaction(pdrv, SEND_STATUS, 0, &resp) || resp) {
-                    return false;
-                }
-                return true;
-            } else {
-                if (sdCommand(pdrv, STOP_TRANSMISSION, 0, NULL)) {
-                    break;
-                }
-
-                if (token == 0x0A) {
-                    sdDeselectCard(pdrv);
-                    unsigned int writtenBlocks = 0;
-                    if (card->type != CARD_MMC && sdSelectCard(pdrv)) {
-                        if (!sdCommand(pdrv, SEND_NUM_WR_BLOCKS, 0, NULL)) {
-                            char acmdData[4];
-                            if (sdReadBytes(pdrv, acmdData, 4)) {
-                                writtenBlocks = acmdData[0] << 24;
-                                writtenBlocks |= acmdData[1] << 16;
-                                writtenBlocks |= acmdData[2] << 8;
-                                writtenBlocks |= acmdData[3];
-                            }
-                        }
-                        sdDeselectCard(pdrv);
-                    }
-                    currentBuffer = buffer + (writtenBlocks << 9);
-                    currentSector = sector + writtenBlocks;
-                    currentCount = count - writtenBlocks;
-                    continue;
-                } else {
-                    break;
-                }
-            }
-        } else {
-            break;
-        }
-    }
-    sdDeselectCard(pdrv);
-    return false;
-}
-
-unsigned long sdGetSectorsCount(uint8_t pdrv)
-{
-    for (int f = 0; f < 3; f++) {
-        if(!sdSelectCard(pdrv)) {
-            return false;
-        }
-
-        if (!sdCommand(pdrv, SEND_CSD, 0, NULL)) {
-            char csd[16];
-            bool success = sdReadBytes(pdrv, csd, 16);
-            sdDeselectCard(pdrv);
-            if (success) {
-                if ((csd[0] >> 6) == 0x01) {
-                    unsigned long size = (
-                         ((unsigned long)(csd[7] & 0x3F) << 16)
-                         | ((unsigned long)csd[8] << 8)
-                         | csd[9]
-                     ) + 1;
-                    return size << 10;
-                }
-                unsigned long size = (
-                     ((unsigned long)(csd[6] & 0x03) << 10)
-                     | ((unsigned long)csd[7] << 2)
-                     | ((csd[8] & 0xC0) >> 6)
-                 ) + 1;
-                size <<= ((
-                     ((csd[9] & 0x03) << 1)
-                     | ((csd[10] & 0x80) >> 7)
-                 ) + 2);
-                size <<= (csd[5] & 0x0F);
-                return size >> 9;
-            }
-        } else {
-            break;
-        }
-    }
-
-    sdDeselectCard(pdrv);
-    return 0;
-}
-
-
-namespace
-{
-
-struct AcquireSPI
-{
-    ardu_sdcard_t *card;
-    explicit AcquireSPI(ardu_sdcard_t* card)
-        : card(card)
-    {
-        card->spi->beginTransaction(SPISettings(card->frequency, MSBFIRST, SPI_MODE0));
-    }
-    AcquireSPI(ardu_sdcard_t* card, int frequency)
-        : card(card)
-    {
-        card->spi->beginTransaction(SPISettings(frequency, MSBFIRST, SPI_MODE0));
-    }
-    ~AcquireSPI()
-    {
-        card->spi->endTransaction();
-    }
-private:
-    AcquireSPI(AcquireSPI const&);
-    AcquireSPI& operator=(AcquireSPI const&);
-};
-
-}
-
-
-/*
- * FATFS API
- * */
-
-DSTATUS ff_sd_initialize(uint8_t pdrv)
-{
-    char token;
-    unsigned int resp;
-    unsigned int start;
-    ardu_sdcard_t * card = s_cards[pdrv];
-
-    if (!(card->status & STA_NOINIT)) {
-        return card->status;
-    }
-
-    AcquireSPI card_locked(card, 400000);
-
-    digitalWrite(card->ssPin, HIGH);
-    for (uint8_t i = 0; i < 20; i++) {
-        card->spi->transfer(0XFF);
-    }
-
-    if (sdTransaction(pdrv, GO_IDLE_STATE, 0, NULL) != 1) {
-        log_w("GO_IDLE_STATE failed");
-        goto unknown_card;
-    }
-
-    token = sdTransaction(pdrv, CRC_ON_OFF, 1, NULL);
-    if (token == 0x5) {
-        //old card maybe
-        card->supports_crc = false;
-    } else if (token != 1) {
-        log_w("CRC_ON_OFF failed: %u", token);
-        goto unknown_card;
-    }
-
-    if (sdTransaction(pdrv, SEND_IF_COND, 0x1AA, &resp) == 1) {
-        if ((resp & 0xFFF) != 0x1AA) {
-            log_w("SEND_IF_COND failed: %03X", resp & 0xFFF);
-            goto unknown_card;
-        }
-
-        if (sdTransaction(pdrv, READ_OCR, 0, &resp) != 1 || !(resp & (1 << 20))) {
-            log_w("READ_OCR failed: %X", resp);
-            goto unknown_card;
-        }
-
-        start = millis();
-        do {
-            token = sdTransaction(pdrv, APP_OP_COND, 0x40100000, NULL);
-        } while (token == 1 && (millis() - start) < 1000);
-
-        if (token) {
-            log_w("APP_OP_COND failed: %u", token);
-            goto unknown_card;
-        }
-
-        if (!sdTransaction(pdrv, READ_OCR, 0, &resp)) {
-            if (resp & (1 << 30)) {
-                card->type = CARD_SDHC;
-            } else {
-                card->type = CARD_SD;
-            }
-        } else {
-            log_w("READ_OCR failed: %X", resp);
-            goto unknown_card;
-        }
-    } else {
-        if (sdTransaction(pdrv, READ_OCR, 0, &resp) != 1 || !(resp & (1 << 20))) {
-            log_w("READ_OCR failed: %X", resp);
-            goto unknown_card;
-        }
-
-        start = millis();
-        do {
-            token = sdTransaction(pdrv, APP_OP_COND, 0x100000, NULL);
-        } while (token == 0x01 && (millis() - start) < 1000);
-
-        if (!token) {
-            card->type = CARD_SD;
-        } else {
-            start = millis();
-            do {
-                token = sdTransaction(pdrv, SEND_OP_COND, 0x100000, NULL);
-            } while (token != 0x00 && (millis() - start) < 1000);
-
-            if (token == 0x00) {
-                card->type = CARD_MMC;
-            } else {
-                log_w("SEND_OP_COND failed: %u", token);
-                goto unknown_card;
-            }
-        }
-    }
-
-    if (card->type != CARD_MMC) {
-        if (sdTransaction(pdrv, APP_CLR_CARD_DETECT, 0, NULL)) {
-            log_w("APP_CLR_CARD_DETECT failed");
-            goto unknown_card;
-        }
-    }
-
-    if (card->type != CARD_SDHC) {
-        if (sdTransaction(pdrv, SET_BLOCKLEN, 512, NULL) != 0x00) {
-            log_w("SET_BLOCKLEN failed");
-            goto unknown_card;
-        }
-    }
-
-    card->sectors = sdGetSectorsCount(pdrv);
-
-    if (card->frequency > 25000000) {
-        card->frequency = 25000000;
-    }
-
-    card->status &= ~STA_NOINIT;
-    return card->status;
-
-unknown_card:
-    card->type = CARD_UNKNOWN;
-    return card->status;
-}
-
-DSTATUS ff_sd_status(uint8_t pdrv)
-{
-    if(sdCommand(pdrv, SEND_STATUS, 0, NULL) == 0xFF)
-    {
-        log_e("Check status failed");
-        return STA_NOINIT;
-    }
-    return s_cards[pdrv]->status;
-}
-
-DRESULT ff_sd_read(uint8_t pdrv, uint8_t* buffer, DWORD sector, UINT count)
-{
-    ardu_sdcard_t * card = s_cards[pdrv];
-    if (card->status & STA_NOINIT) {
-        return RES_NOTRDY;
-    }
-    DRESULT res = RES_OK;
-
-    AcquireSPI lock(card);
-
-    if (count > 1) {
-        res = sdReadSectors(pdrv, (char*)buffer, sector, count) ? RES_OK : RES_ERROR;
-    } else {
-        res = sdReadSector(pdrv, (char*)buffer, sector) ? RES_OK : RES_ERROR;
-    }
-    return res;
-}
-
-DRESULT ff_sd_write(uint8_t pdrv, const uint8_t* buffer, DWORD sector, UINT count)
-{
-    ardu_sdcard_t * card = s_cards[pdrv];
-    if (card->status & STA_NOINIT) {
-        return RES_NOTRDY;
-    }
-
-    if (card->status & STA_PROTECT) {
-        return RES_WRPRT;
-    }
-    DRESULT res = RES_OK;
-
-    AcquireSPI lock(card);
-
-    if (count > 1) {
-        res = sdWriteSectors(pdrv, (const char*)buffer, sector, count) ? RES_OK : RES_ERROR;
-    } else {
-        res = sdWriteSector(pdrv, (const char*)buffer, sector) ? RES_OK : RES_ERROR;
-    }
-    return res;
-}
-
-DRESULT ff_sd_ioctl(uint8_t pdrv, uint8_t cmd, void* buff)
-{
-    switch(cmd) {
-    case CTRL_SYNC:
-        {
-            AcquireSPI lock(s_cards[pdrv]);
-            if (sdSelectCard(pdrv)) {
-                sdDeselectCard(pdrv);
-                return RES_OK;
-            }
-        }
-        return RES_ERROR;
-    case GET_SECTOR_COUNT:
-        *((unsigned long*) buff) = s_cards[pdrv]->sectors;
-        return RES_OK;
-    case GET_SECTOR_SIZE:
-        *((WORD*) buff) = 512;
-        return RES_OK;
-    case GET_BLOCK_SIZE:
-        *((uint32_t*)buff) = 1;
-        return RES_OK;
-    }
-    return RES_PARERR;
-}
-
-bool sd_read_raw(uint8_t pdrv, uint8_t* buffer, DWORD sector)
-{
-    return ff_sd_read(pdrv, buffer, sector, 1) == ESP_OK;
-}
-
-bool sd_write_raw(uint8_t pdrv, uint8_t* buffer, DWORD sector)
-{
-    return ff_sd_write(pdrv, buffer, sector, 1) == ESP_OK;
-}
-
-/*
- * Public methods
- * */
-
-uint8_t sdcard_uninit(uint8_t pdrv)
-{
-    ardu_sdcard_t * card = s_cards[pdrv];
-    if (pdrv >= FF_VOLUMES || card == NULL) {
-        return 1;
-    }
-    sdTransaction(pdrv, GO_IDLE_STATE, 0, NULL);
-    ff_diskio_register(pdrv, NULL);
-    s_cards[pdrv] = NULL;
-    esp_err_t err = ESP_OK;
-    if (card->base_path) {
-        err = esp_vfs_fat_unregister_path(card->base_path);
-        free(card->base_path);
-    }
-    free(card);
-    return err;
-}
-
-uint8_t sdcard_init(uint8_t cs, SPIClass * spi, int hz)
-{
-
-    uint8_t pdrv = 0xFF;
-    if (ff_diskio_get_drive(&pdrv) != ESP_OK || pdrv == 0xFF) {
-        return pdrv;
-    }
-
-    ardu_sdcard_t * card = (ardu_sdcard_t *)malloc(sizeof(ardu_sdcard_t));
-    if (!card) {
-        return 0xFF;
-    }
-
-    card->base_path = NULL;
-    card->frequency = hz;
-    card->spi = spi;
-    card->ssPin = cs;
-
-    card->supports_crc = true;
-    card->type = CARD_NONE;
-    card->status = STA_NOINIT;
-
-    pinMode(card->ssPin, OUTPUT);
-    digitalWrite(card->ssPin, HIGH);
-
-    s_cards[pdrv] = card;
-
-    static const ff_diskio_impl_t sd_impl = {
-        .init = &ff_sd_initialize,
-        .status = &ff_sd_status,
-        .read = &ff_sd_read,
-        .write = &ff_sd_write,
-        .ioctl = &ff_sd_ioctl
-    };
-    ff_diskio_register(pdrv, &sd_impl);
-
-    return pdrv;
-}
-
-uint8_t sdcard_unmount(uint8_t pdrv)
-{
-    ardu_sdcard_t * card = s_cards[pdrv];
-    if (pdrv >= FF_VOLUMES || card == NULL) {
-        return 1;
-    }
-    card->status |= STA_NOINIT;
-    card->type = CARD_NONE;
-
-    char drv[3] = {(char)('0' + pdrv), ':', 0};
-    f_mount(NULL, drv, 0);
-    return 0;
-}
-
-bool sdcard_mount(uint8_t pdrv, const char* path, uint8_t max_files, bool format_if_empty)
-{
-    ardu_sdcard_t * card = s_cards[pdrv];
-    if(pdrv >= FF_VOLUMES || card == NULL){
-        return false;
-    }
-
-    if(card->base_path){
-        free(card->base_path);
-    }
-    card->base_path = strdup(path);
-
-    FATFS* fs;
-    char drv[3] = {(char)('0' + pdrv), ':', 0};
-    esp_err_t err = esp_vfs_fat_register(path, drv, max_files, &fs);
-    if (err == ESP_ERR_INVALID_STATE) {
-        log_e("esp_vfs_fat_register failed 0x(%x): SD is registered.", err);
-        return false;
-    } else if (err != ESP_OK) {
-        log_e("esp_vfs_fat_register failed 0x(%x)", err);
-        return false;
-    }
-
-    FRESULT res = f_mount(fs, drv, 1);
-    if (res != FR_OK) {
-        log_e("f_mount failed: %s", fferr2str[res]);
-        if(res == 13 && format_if_empty){
-            BYTE work[FF_MAX_SS];
-            res = f_mkfs(drv, FM_ANY, 0, work, sizeof(work));
-            if (res != FR_OK) {
-                log_e("f_mkfs failed: %s", fferr2str[res]);
-                esp_vfs_fat_unregister_path(path);
-                return false;
-            }
-            res = f_mount(fs, drv, 1);
-            if (res != FR_OK) {
-                log_e("f_mount failed: %s", fferr2str[res]);
-                esp_vfs_fat_unregister_path(path);
-                return false;
-            }
-        } else {
-            esp_vfs_fat_unregister_path(path);
-            return false;
-        }
-    }
-    AcquireSPI lock(card);
-    card->sectors = sdGetSectorsCount(pdrv);
-    return true;
-}
-
-uint32_t sdcard_num_sectors(uint8_t pdrv)
-{
-    ardu_sdcard_t * card = s_cards[pdrv];
-    if(pdrv >= FF_VOLUMES || card == NULL){
-        return 0;
-    }
-    return card->sectors;
-}
-
-uint32_t sdcard_sector_size(uint8_t pdrv)
-{
-    if(pdrv >= FF_VOLUMES || s_cards[pdrv] == NULL){
-        return 0;
-    }
-    return 512;
-}
-
-sdcard_type_t sdcard_type(uint8_t pdrv)
-{
-    ardu_sdcard_t * card = s_cards[pdrv];
-    if(pdrv >= FF_VOLUMES || card == NULL){
-        return CARD_NONE;
-    }
-    return card->type;
-}
diff --git a/lib/SD/src/sd_diskio.h b/lib/SD/src/sd_diskio.h
deleted file mode 100644
index 06a861b..0000000
--- a/lib/SD/src/sd_diskio.h
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#ifndef _SD_DISKIO_H_
-#define _SD_DISKIO_H_
-
-#include "Arduino.h"
-#include "SPI.h"
-#include "sd_defines.h"
-// #include "diskio.h"
-
-uint8_t sdcard_init(uint8_t cs, SPIClass * spi, int hz);
-uint8_t sdcard_uninit(uint8_t pdrv);
-
-bool sdcard_mount(uint8_t pdrv, const char* path, uint8_t max_files, bool format_if_empty);
-uint8_t sdcard_unmount(uint8_t pdrv);
-
-sdcard_type_t sdcard_type(uint8_t pdrv);
-uint32_t sdcard_num_sectors(uint8_t pdrv);
-uint32_t sdcard_sector_size(uint8_t pdrv);
-bool sd_read_raw(uint8_t pdrv, uint8_t* buffer, uint32_t sector);
-bool sd_write_raw(uint8_t pdrv, uint8_t* buffer, uint32_t sector);
-
-#endif /* _SD_DISKIO_H_ */
diff --git a/lib/SD/src/sd_diskio_crc.c b/lib/SD/src/sd_diskio_crc.c
deleted file mode 100644
index 0372df8..0000000
--- a/lib/SD/src/sd_diskio_crc.c
+++ /dev/null
@@ -1,103 +0,0 @@
-/* SD/MMC File System Library
- * Copyright (c) 2014 Neil Thiessen
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-const char m_CRC7Table[] = {
-    0x00, 0x09, 0x12, 0x1B, 0x24, 0x2D, 0x36, 0x3F,
-    0x48, 0x41, 0x5A, 0x53, 0x6C, 0x65, 0x7E, 0x77,
-    0x19, 0x10, 0x0B, 0x02, 0x3D, 0x34, 0x2F, 0x26,
-    0x51, 0x58, 0x43, 0x4A, 0x75, 0x7C, 0x67, 0x6E,
-    0x32, 0x3B, 0x20, 0x29, 0x16, 0x1F, 0x04, 0x0D,
-    0x7A, 0x73, 0x68, 0x61, 0x5E, 0x57, 0x4C, 0x45,
-    0x2B, 0x22, 0x39, 0x30, 0x0F, 0x06, 0x1D, 0x14,
-    0x63, 0x6A, 0x71, 0x78, 0x47, 0x4E, 0x55, 0x5C,
-    0x64, 0x6D, 0x76, 0x7F, 0x40, 0x49, 0x52, 0x5B,
-    0x2C, 0x25, 0x3E, 0x37, 0x08, 0x01, 0x1A, 0x13,
-    0x7D, 0x74, 0x6F, 0x66, 0x59, 0x50, 0x4B, 0x42,
-    0x35, 0x3C, 0x27, 0x2E, 0x11, 0x18, 0x03, 0x0A,
-    0x56, 0x5F, 0x44, 0x4D, 0x72, 0x7B, 0x60, 0x69,
-    0x1E, 0x17, 0x0C, 0x05, 0x3A, 0x33, 0x28, 0x21,
-    0x4F, 0x46, 0x5D, 0x54, 0x6B, 0x62, 0x79, 0x70,
-    0x07, 0x0E, 0x15, 0x1C, 0x23, 0x2A, 0x31, 0x38,
-    0x41, 0x48, 0x53, 0x5A, 0x65, 0x6C, 0x77, 0x7E,
-    0x09, 0x00, 0x1B, 0x12, 0x2D, 0x24, 0x3F, 0x36,
-    0x58, 0x51, 0x4A, 0x43, 0x7C, 0x75, 0x6E, 0x67,
-    0x10, 0x19, 0x02, 0x0B, 0x34, 0x3D, 0x26, 0x2F,
-    0x73, 0x7A, 0x61, 0x68, 0x57, 0x5E, 0x45, 0x4C,
-    0x3B, 0x32, 0x29, 0x20, 0x1F, 0x16, 0x0D, 0x04,
-    0x6A, 0x63, 0x78, 0x71, 0x4E, 0x47, 0x5C, 0x55,
-    0x22, 0x2B, 0x30, 0x39, 0x06, 0x0F, 0x14, 0x1D,
-    0x25, 0x2C, 0x37, 0x3E, 0x01, 0x08, 0x13, 0x1A,
-    0x6D, 0x64, 0x7F, 0x76, 0x49, 0x40, 0x5B, 0x52,
-    0x3C, 0x35, 0x2E, 0x27, 0x18, 0x11, 0x0A, 0x03,
-    0x74, 0x7D, 0x66, 0x6F, 0x50, 0x59, 0x42, 0x4B,
-    0x17, 0x1E, 0x05, 0x0C, 0x33, 0x3A, 0x21, 0x28,
-    0x5F, 0x56, 0x4D, 0x44, 0x7B, 0x72, 0x69, 0x60,
-    0x0E, 0x07, 0x1C, 0x15, 0x2A, 0x23, 0x38, 0x31,
-    0x46, 0x4F, 0x54, 0x5D, 0x62, 0x6B, 0x70, 0x79
-};
-
-char CRC7(const char* data, int length)
-{
-    char crc = 0;
-    for (int i = 0; i < length; i++) {
-        crc = m_CRC7Table[(crc << 1) ^ data[i]];
-    }
-    return crc;
-}
-
-const unsigned short m_CRC16Table[256] = {
-    0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
-    0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
-    0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
-    0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
-    0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
-    0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
-    0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
-    0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
-    0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
-    0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
-    0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
-    0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
-    0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
-    0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
-    0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
-    0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
-    0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
-    0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
-    0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
-    0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
-    0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
-    0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
-    0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
-    0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
-    0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
-    0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
-    0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
-    0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
-    0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
-    0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
-    0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
-    0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
-};
-
-unsigned short CRC16(const char* data, int length)
-{
-    unsigned short crc = 0;
-    for (int i = 0; i < length; i++) {
-        crc = (crc << 8) ^ m_CRC16Table[((crc >> 8) ^ data[i]) & 0x00FF];
-    }
-    return crc;
-}
diff --git a/lib/ST7789/src/ST7789.cpp b/lib/ST7789/src/ST7789.cpp
index 8c69b61..af89389 100644
--- a/lib/ST7789/src/ST7789.cpp
+++ b/lib/ST7789/src/ST7789.cpp
@@ -6,21 +6,26 @@
 //**************************************************************************************************
 #include "ST7789.h"
 
-Adafruit_ST7789*     ST7789_tft ;                          // For instance of display driver
+extern bool  pin_exists ( uint8_t pin ) ;                  // Check GPIO pin number
+
+Adafruit_ST7789*     ST7789_tft = NULL ;                   // For instance of display driver
 scrseg_struct        ST7789_tftdata[TFTSECS] =             // Screen divided in 3 segments + 1 overlay
                       {                                    // One text line is 8 pixels
-                        { false, GRAY,    0,  16,  "" },   // 1 top line
+                        { false, GREY,    0,  16,  "" },   // 1 top line
                         { false, CYAN,    40, 128, "" },   // 8 lines in the middle
                         { false, YELLOW, 180,  64, "" },   // 4 lines at the bottom
-                        { false, GRAY,   180,  64, "" }    // 4 lines at the bottom for rotary encoder
+                        { false, GREY,   180,  64, "" }    // 4 lines at the bottom for rotary encoder
                       } ;
 
 
 bool ST7789_dsp_begin ( int8_t cs, int8_t dc )
 {
-  if ( ( ST7789_tft = new Adafruit_ST7789 ( cs, dc , -1 ) ) )      // Create an instant for TFT
+  if ( pin_exists ( cs ) && pin_exists ( dc ) )
   {
-    dsp_init() ;
+    if ( ( ST7789_tft = new Adafruit_ST7789 ( cs, dc , -1 ) ) )      // Create an instant for TFT
+    {
+      dsp_init() ;
+    }
   }
   return ( ST7789_tft != NULL ) ;
 }
diff --git a/lib/ST7789/src/ST7789.h b/lib/ST7789/src/ST7789.h
index ecb3fea..e3fed91 100644
--- a/lib/ST7789/src/ST7789.h
+++ b/lib/ST7789/src/ST7789.h
@@ -22,7 +22,7 @@
 #define MAGENTA RED | BLUE
 #define YELLOW  RED | GREEN
 #define WHITE   RED | BLUE | GREEN
-#define GRAY    0x7bf0
+#define GREY    0x7bf0
 
 #define DEFTXTSIZ  2                                  // Default text size
 
@@ -59,7 +59,6 @@ extern Adafruit_ST7789*     ST7789_tft ;                                 // For
 #define dsp_getwidth()          240                                      // Adjust to your display
 #define dsp_getheight()         240                                      // Get height of screen
 #define dsp_update(a)                                                    // Updates to the physical screen
-#define dsp_usesSPI()           true                                     // Does use SPI
 #define dsp_begin               ST7789_dsp_begin                         // Init driver
 #define dsp_init()              ST7789_tft->init ( 240, 240 ) ;
 
diff --git a/lib/bluetft/src/bluetft.cpp b/lib/bluetft/src/bluetft.cpp
index 9b4b336..b00be4e 100644
--- a/lib/bluetft/src/bluetft.cpp
+++ b/lib/bluetft/src/bluetft.cpp
@@ -21,6 +21,10 @@ scrseg_struct        bluetft_tftdata[TFTSECS] =             // Screen divided in
 
 bool bluetft_dsp_begin ( int8_t cs, int8_t dc )
 {
+  if ( cs < 0 || dc < 0 )
+  {
+    return false ;                                                  // Wrong pin configuration
+  }
   if ( ( bluetft_tft = new Adafruit_ST7735 ( cs, dc , -1 ) ) )      // Create an instant for TFT
   {
     // Uncomment one of the following initR lines for ST7735R displays
diff --git a/lib/bluetft/src/bluetft.h b/lib/bluetft/src/bluetft.h
index d0653f9..60bb25c 100644
--- a/lib/bluetft/src/bluetft.h
+++ b/lib/bluetft/src/bluetft.h
@@ -25,7 +25,7 @@
 #define MAGENTA RED | BLUE
 #define YELLOW  RED | GREEN
 #define WHITE   RED | BLUE | GREEN
-#define GRAY    0x7bf0
+#define GREY    0x7bf0
 
 #define DEFTXTSIZ  1                                  // Default text size
 
@@ -62,7 +62,6 @@ extern Adafruit_ST7735*     bluetft_tft ;                                 // For
 #define dsp_getwidth()          160                                       // Adjust to your display
 #define dsp_getheight()         128                                       // Get height of screen
 #define dsp_update(a)                                                     // Updates to the physical screen
-#define dsp_usesSPI()           true                                      // Does use SPI
 #define dsp_begin               bluetft_dsp_begin                         // Init driver
 
 extern scrseg_struct     bluetft_tftdata[TFTSECS] ;                       // Screen divided in segments
diff --git a/lib/codecs/src/VS1053.cpp b/lib/codecs/src/VS1053.cpp
index 3ed7ba2..ca1fac0 100644
--- a/lib/codecs/src/VS1053.cpp
+++ b/lib/codecs/src/VS1053.cpp
@@ -3,10 +3,10 @@
 //**************************************************************************************************
 #include "VS1053.h"
 
-extern char* dbgprint( const char* format, ... ) ;  // For debugging
-
 VS1053*     vs1053player ;                          // The object for the MP3 player
 
+extern bool  pin_exists ( uint8_t pin ) ;           // Check GPIO pin number
+
 //**************************************************************************************************
 // VS1053 constructor.                                                                             *
 //**************************************************************************************************
@@ -17,37 +17,61 @@ VS1053::VS1053 ( int8_t _cs_pin, int8_t _dcs_pin, int8_t _dreq_pin,
 {
 }
 
+void VS1053::control_mode_on() const
+{
+  SPI.beginTransaction ( VS1053_SPI ) ;       // Prevent other SPI users
+  digitalWrite ( cs_pin, LOW ) ;
+}
+
+void VS1053::control_mode_off() const
+{
+  digitalWrite ( cs_pin, HIGH ) ;             // End control mode
+  SPI.endTransaction() ;                      // Allow other SPI users
+}
+
+void VS1053::data_mode_on() const
+{
+  SPI.beginTransaction ( VS1053_SPI ) ;       // Prevent other SPI users
+  //digitalWrite ( cs_pin, HIGH ) ;           // Bring slave in data mode
+  digitalWrite ( dcs_pin, LOW ) ;
+}
+
+void VS1053::data_mode_off() const
+{
+  digitalWrite ( dcs_pin, HIGH ) ;            // End data mode
+  SPI.endTransaction() ;                      // Allow other SPI users
+}
+
 uint16_t VS1053::read_register ( uint8_t _reg ) const
 {
   uint16_t result ;
 
-  control_mode_on() ;
-  SPI.write ( 3 ) ;                                // Read operation
-  SPI.write ( _reg ) ;                             // Register to read (0..0xF)
+  control_mode_on() ;                               // Start control-mode transaction
+  SPI.write ( 3 ) ;                                 // Read operation
+  SPI.write ( _reg ) ;                              // Register to read (0..0xF)
   // Note: transfer16 does not seem to work
-  result = ( SPI.transfer ( 0xFF ) << 8 ) |        // Read 16 bits data
+  result = ( SPI.transfer ( 0xFF ) << 8 ) |         // Read 16 bits data
            ( SPI.transfer ( 0xFF ) ) ;
-  await_data_request() ;                           // Wait for DREQ to be HIGH again
-  control_mode_off() ;
+  await_data_request() ;                            // Wait for DREQ to be HIGH again
+  control_mode_off() ;                              // End control_mode transaction
   return result ;
 }
 
 void VS1053::write_register ( uint8_t _reg, uint16_t _value ) const
 {
-  control_mode_on( );
-  SPI.write ( 2 ) ;                                // Write operation
-  SPI.write ( _reg ) ;                             // Register to write (0..0xF)
-  SPI.write16 ( _value ) ;                         // Send 16 bits data
+  control_mode_on() ;                               // Start control-mode transaction
+  SPI.write ( 2 ) ;                                 // Write operation
+  SPI.write ( _reg ) ;                              // Register to write (0..0xF)
+  SPI.write16 ( _value ) ;                          // Send 16 bits data
   await_data_request() ;
-  control_mode_off() ;
+  control_mode_off() ;                              // End control_mode transaction
 }
 
 bool VS1053::sdi_send_buffer ( uint8_t* data, size_t len )
 {
-  size_t chunk_length ;                            // Length of chunk 32 byte or shorter
+  size_t chunk_length ;                             // Length of chunk 32 byte or shorter
 
-  data_mode_on() ;
-  while ( len )                                    // More to do?
+  while ( len )                                     // More to do?
   {
     chunk_length = len ;
     if ( len > vs1053_chunk_size )
@@ -55,34 +79,27 @@ bool VS1053::sdi_send_buffer ( uint8_t* data, size_t len )
       chunk_length = vs1053_chunk_size ;
     }
     len -= chunk_length ;
-    await_data_request() ;                         // Wait for space available
+    await_data_request() ;                          // Wait for space available
+    data_mode_on() ;                                // Start data-mode transaction
     SPI.writeBytes ( data, chunk_length ) ;
+    data_mode_off() ;                               // End data-mode transaction
     data += chunk_length ;
   }
-  data_mode_off() ;
-  return data_request() ;                          // True if more data can de stored in fifo
+  return data_request() ;                           // True if more data can be stored in fifo
 }
 
-void VS1053::sdi_send_fillers ( size_t len )
+void VS1053::sdi_send_fillers ( uint8_t numchunks )
 {
-  size_t chunk_length ;                            // Length of chunk 32 byte or shorter
-
-  data_mode_on() ;
-  while ( len )                                    // More to do?
+  while ( numchunks-- )                             // More to do?
   {
-    await_data_request() ;                         // Wait for space available
-    chunk_length = len ;
-    if ( len > vs1053_chunk_size )
-    {
-      chunk_length = vs1053_chunk_size ;
-    }
-    len -= chunk_length ;
-    while ( chunk_length-- )
+    await_data_request() ;                          // Wait for space available
+    data_mode_on() ;                                // Start data-mode transaction
+    for ( uint8_t i = 0 ; i < vs1053_chunk_size ; i++ )
     {
       SPI.write ( endFillByte ) ;
     }
+    data_mode_off() ;                               // End data-mode transaction
   }
-  data_mode_off();
 }
 
 void VS1053::wram_write ( uint16_t address, uint16_t data )
@@ -109,12 +126,10 @@ bool VS1053::testComm ( const char *header )
   const uint16_t vstype[] = { 1001, 1011, 1002, 1003,   // Possible chip versions
                               1053, 1033, 0000, 1103 } ;
   
-  dbgprint ( header ) ;                                 // Show a header
+  ESP_LOGI ( VTAG, "%s", header ) ;                     // Show a header
   if ( !digitalRead ( dreq_pin ) )
   {
-    dbgprint ( "VS1053 not properly installed!" ) ;
-    // Allow testing without the VS1053 module
-    pinMode ( dreq_pin,  INPUT_PULLUP ) ;               // DREQ is now input with pull-up
+    ESP_LOGE ( VTAG, "VS1053 not properly installed!" ) ;
     return false ;                                      // Return bad result
   }
   // Further TESTING.  Check if SCI bus can write and read without errors.
@@ -132,7 +147,7 @@ bool VS1053::testComm ( const char *header )
     r2 = read_register ( SCI_VOL ) ;                    // Read back a second time
     if  ( r1 != r2 || i != r1 || i != r2 )              // Check for 2 equal reads
     {
-      dbgprint ( "VS1053 SPI error. SB:%04X R1:%04X R2:%04X", i, r1, r2 ) ;
+      ESP_LOGE ( VTAG, "SPI error. SB:%04X R1:%04X R2:%04X", i, r1, r2 ) ;
       cnt++ ;
       delay ( 10 ) ;
     }
@@ -142,7 +157,7 @@ bool VS1053::testComm ( const char *header )
   r1 = ( read_register ( SCI_STATUS ) >> 4 ) & 0x7 ;    // Read status to get the version
   if ( r1 !=  4 )                                       // Version 4 is a genuine VS1053
   {
-    dbgprint ( "This is not a VS1053, "                 // Report the wrong chip
+    ESP_LOGW ( VTAG, "This is not a VS1053, "           // Report the wrong chip
                "but a VS%d instead!",
                vstype[r1] ) ;
     //okay = false ;                                    // Standard codecs not fully supported
@@ -152,26 +167,25 @@ bool VS1053::testComm ( const char *header )
 
 void VS1053::begin()
 {
-  pinMode      ( dreq_pin,  INPUT ) ;                   // DREQ is an input
+  pinMode      ( dreq_pin,  INPUT_PULLUP ) ;            // DREQ is an input
   pinMode      ( cs_pin,    OUTPUT ) ;                  // The SCI and SDI signals
   pinMode      ( dcs_pin,   OUTPUT ) ;
   digitalWrite ( dcs_pin,   HIGH ) ;                    // Start HIGH for SCI en SDI
   digitalWrite ( cs_pin,    HIGH ) ;
-  if ( shutdown_pin >= 0 )                              // Shutdown in use?
+  if ( pin_exists ( shutdown_pin ) )                    // Shutdown in use?
   {
     pinMode ( shutdown_pin,   OUTPUT ) ;
   }
-  if ( shutdownx_pin >= 0 )                            // Shutdown (inversed logic) in use?
+  if ( pin_exists ( shutdownx_pin ) )                   // Shutdown (inversed logic) in use?
   {
     pinMode ( shutdownx_pin,   OUTPUT ) ;
   }
-  output_enable ( false ) ;                            // Disable amplifier through shutdown pin(s)
+  output_enable ( false ) ;                             // Disable amplifier through shutdown pin(s)
   delay ( 100 ) ;
   // Init SPI in slow mode ( 0.2 MHz )
-  VS1053_SPI = SPISettings ( 200000, MSBFIRST, SPI_MODE0 ) ;
-  SPI.setDataMode ( SPI_MODE0 ) ;
-  SPI.setBitOrder ( MSBFIRST ) ;
-  //printDetails ( "Right after reset/startup" ) ;
+  VS1053_SPI._clock = 200000  ;
+  VS1053_SPI._bitOrder = MSBFIRST ;
+  VS1053_SPI._dataMode = SPI_MODE0 ;
   delay ( 20 ) ;
   //printDetails ( "20 msec after reset" ) ;
   if ( testComm ( "Slow SPI, Testing VS1053 read/write registers..." ) )
@@ -188,8 +202,7 @@ void VS1053::begin()
     // The next clocksetting allows SPI clocking at 5 MHz, 4 MHz is safe then.
     write_register ( SCI_CLOCKF, 6 << 12 ) ;              // Normal clock settings
     // multiplyer 3.0 = 12.2 MHz
-    //SPI Clock to 4 MHz. Now you can set high speed SPI clock.
-    VS1053_SPI = SPISettings ( 5000000, MSBFIRST, SPI_MODE0 ) ;
+    VS1053_SPI._clock = 5000000 ;                         // SPI Clock to 5 MHz.
     write_register ( SCI_MODE, _BV ( SM_SDINEW ) | _BV ( SM_LINE1 ) ) ;
     testComm ( "Fast SPI, Testing VS1053 read/write registers again..." ) ;
     delay ( 10 ) ;
@@ -245,7 +258,7 @@ void VS1053::setTone ( uint8_t *rtone )                 // Set bass/treble (4 ni
 
 void VS1053::startSong()
 {
-  sdi_send_fillers ( 10 ) ;
+  sdi_send_fillers ( 60 ) ;
   output_enable ( true ) ;                              // Enable amplifier through shutdown pin(s)
 }
 
@@ -259,23 +272,23 @@ void VS1053::stopSong()
   uint16_t modereg ;                                    // Read from mode register
   int      i ;                                          // Loop control
 
-  sdi_send_fillers ( 2052 ) ;
+  sdi_send_fillers ( 60 ) ;                             // Send 60 * 32 fillers
   output_enable ( false ) ;                             // Disable amplifier through shutdown pin(s)
   delay ( 10 ) ;
   write_register ( SCI_MODE, _BV ( SM_SDINEW ) | _BV ( SM_CANCEL ) ) ;
   for ( i = 0 ; i < 20 ; i++ )
   {
-    sdi_send_fillers ( 32 ) ;
+    sdi_send_fillers ( 1 ) ;                            // Send 32 fillers
     modereg = read_register ( SCI_MODE ) ;              // Read mode status
     if ( ( modereg & _BV ( SM_CANCEL ) ) == 0 )         // SM_CANCEL will be cleared when finished
     {
-      sdi_send_fillers ( 2052 ) ;
-      dbgprint ( "Song stopped correctly after %d msec", i * 10 ) ;
+      sdi_send_fillers ( 60 ) ;
+      ESP_LOGI ( VTAG, "Song stopped correctly after %d msec", i * 10 ) ;
       return ;
     }
     delay ( 10 ) ;
   }
-  printDetails ( "Song stopped incorrectly!" ) ;
+  //printDetails ( "Song stopped incorrectly!" ) ;
 }
 
 void VS1053::softReset()
@@ -285,24 +298,24 @@ void VS1053::softReset()
   await_data_request() ;
 }
 
-void VS1053::printDetails ( const char *header )
-{
-  uint16_t     regbuf[16] ;
-  uint8_t      i ;
-
-  dbgprint ( header ) ;
-  dbgprint ( "REG   Contents" ) ;
-  dbgprint ( "---   -----" ) ;
-  for ( i = 0 ; i <= SCI_num_registers ; i++ )
-  {
-    regbuf[i] = read_register ( i ) ;
-  }
-  for ( i = 0 ; i <= SCI_num_registers ; i++ )
-  {
-    delay ( 5 ) ;
-    dbgprint ( "%3X - %5X", i, regbuf[i] ) ;
-  }
-}
+// void VS1053::printDetails ( const char *header )
+// {
+//   uint16_t     regbuf[16] ;
+//   uint8_t      i ;
+
+//   ESP_LOGI ( VTAG, header ) ;
+//   ESP_LOGI ( VTAG, "REG   Contents" ) ;
+//   ESP_LOGI ( VTAG, "---   -----" ) ;
+//   for ( i = 0 ; i <= SCI_num_registers ; i++ )
+//   {
+//     regbuf[i] = read_register ( i ) ;
+//   }
+//   for ( i = 0 ; i <= SCI_num_registers ; i++ )
+//   {
+//     delay ( 5 ) ;
+//     ESP_LOGI ( VTAG, "%3X - %5X", i, regbuf[i] ) ;
+//   }
+// }
 
 void  VS1053::output_enable ( bool ena )               // Enable amplifier through shutdown pin(s)
 {
@@ -343,10 +356,19 @@ void VS1053::streamMode ( bool onoff )                // Set stream mode on/off
   await_data_request() ;
 }
 
-void VS1053_begin ( int8_t cs, int8_t dcs, int8_t dreq, int8_t shutdown, int8_t shutdownx )
+bool VS1053_begin ( int8_t cs, int8_t dcs, int8_t dreq, int8_t shutdown, int8_t shutdownx )
 {
-  vs1053player = new VS1053 ( cs, dcs, dreq,             // Create object
+  //if ( ! pin_exists ( dreq ) )                      // Check DREC pin
+  //{
+  //  return false ;
+  //}
+  vs1053player = new VS1053 ( cs, dcs, dreq,          // Create object
                               shutdown, shutdownx ) ;
-  vs1053player->streamMode ( true ) ;                    // Set streammode (experimental)
-  vs1053player->begin() ;                                // Initialize VS1053 player
+  if ( ! vs1053player->data_request() )               // DREC should be high
+  {
+    return false ;
+  }
+  vs1053player->streamMode ( true ) ;                 // Set streammode (experimental)
+  vs1053player->begin() ;                             // Initialize VS1053 player
+  return true ;
 }
\ No newline at end of file
diff --git a/lib/codecs/src/VS1053.h b/lib/codecs/src/VS1053.h
index 0900718..ef49b3f 100644
--- a/lib/codecs/src/VS1053.h
+++ b/lib/codecs/src/VS1053.h
@@ -13,12 +13,13 @@
 #define player_setVolume      vs1053player->setVolume
 #define player_setTone        vs1053player->setTone
 
-void VS1053_begin ( int8_t cs, int8_t dcs, int8_t dreq, int8_t shutdown, int8_t shutdownx ) ;
+bool VS1053_begin ( int8_t cs, int8_t dcs, int8_t dreq, int8_t shutdown, int8_t shutdownx ) ;
 
 
 class VS1053
 {
   private:
+    const char*   VTAG = "VS1053" ;                // For debugging
     int8_t        cs_pin ;                         // Pin where CS line is connected
     int8_t        dcs_pin ;                        // Pin where DCS line is connected
     int8_t        dreq_pin ;                       // Pin where DREQ line is connected
@@ -52,42 +53,19 @@ class VS1053
   protected:
     inline void await_data_request() const
     {
-      while ( ( dreq_pin >= 0 ) &&
-              ( !digitalRead ( dreq_pin ) ) )
+      while ( !digitalRead ( dreq_pin ) )
       {
         NOP() ;                                   // Very short delay
       }
     }
-
-    inline void control_mode_on() const
-    {
-      SPI.beginTransaction ( VS1053_SPI ) ;       // Prevent other SPI users
-      digitalWrite ( cs_pin, LOW ) ;
-    }
-
-    inline void control_mode_off() const
-    {
-      digitalWrite ( cs_pin, HIGH ) ;             // End control mode
-      SPI.endTransaction() ;                      // Allow other SPI users
-    }
-
-    inline void data_mode_on() const
-    {
-      SPI.beginTransaction ( VS1053_SPI ) ;       // Prevent other SPI users
-      //digitalWrite ( cs_pin, HIGH ) ;           // Bring slave in data mode
-      digitalWrite ( dcs_pin, LOW ) ;
-    }
-
-    inline void data_mode_off() const
-    {
-      digitalWrite ( dcs_pin, HIGH ) ;            // End data mode
-      SPI.endTransaction() ;                      // Allow other SPI users
-    }
-
+    void        control_mode_on() const ;
+    void        control_mode_off() const ;
+    void        data_mode_on() const ;
+    void        data_mode_off() const ;
     uint16_t    read_register ( uint8_t _reg ) const ;
     void        write_register ( uint8_t _reg, uint16_t _value ) const ;
     inline bool sdi_send_buffer ( uint8_t* data, size_t len ) ;
-    void        sdi_send_fillers ( size_t length ) ;
+    void        sdi_send_fillers ( uint8_t numchunks ) ;
     void        wram_write ( uint16_t address, uint16_t data ) ;
     uint16_t    wram_read ( uint16_t address ) ;
     void        output_enable ( bool ena ) ;             // Enable amplifier through shutdown pin(s)
@@ -114,7 +92,7 @@ class VS1053
     {                                                    // higher is louder.
       return curvol ;
     }
-    void     printDetails ( const char *header ) ;       // Print config details to serial output
+    //void   printDetails ( const char *header ) ;       // Print config details to serial output
     void     softReset() ;                               // Do a soft reset
     bool     testComm ( const char *header ) ;           // Test communication with module
     inline bool data_request() const
diff --git a/lib/codecs/src/aac_decoder.cpp b/lib/codecs/src/aac_decoder.cpp
index 58c5b6f..d1c049c 100644
--- a/lib/codecs/src/aac_decoder.cpp
+++ b/lib/codecs/src/aac_decoder.cpp
@@ -4,6 +4,7 @@
  *
  *  Created on: 26.10.2018
  *  Updated on: 10.09.2021
+ *  Updated on: 09-07-2024, ES: fixed Arduino IDE compiation error.
  ************************************************************************************/
 
 #include "aac_decoder.h"
@@ -5294,7 +5295,7 @@ void GenerateNoiseVector(int *coef, int *last, int nVals)
     int i;
 
     for (i = 0; i < nVals; i++)
-        coef[i] = ((int32_t)Get32BitVal((uint32_t *)last)) >> 16;
+        coef[i] = ((int32_t)Get32BitVal((unsigned int*)last)) >> 16;
 }
 
 /***********************************************************************************************************************
diff --git a/lib/dummytft/src/dummytft.cpp b/lib/dummytft/src/dummytft.cpp
index 0fa4380..0170528 100644
--- a/lib/dummytft/src/dummytft.cpp
+++ b/lib/dummytft/src/dummytft.cpp
@@ -4,7 +4,7 @@
 
 scrseg_struct     dummytft_tftdata[TFTSECS] =               // Screen divided in 1 segment
 {                                                           // One text line is 8 pixels
-  { false, WHITE,   0,  8, "" },                            // 1 top line
+  { false, WHITE,   0,  8, "" },                            // 1 top line for minimal memory usage
 } ;
 
 
@@ -14,7 +14,8 @@ scrseg_struct     dummytft_tftdata[TFTSECS] =               // Screen divided in
 // Dummy routine to fill a rectangle.                                                              *
 //**************************************************************************************************
 void dummytft_dsp_fillRect ( int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color )
-{} ;                                                        // Fill a rectange
+{
+} ;
 
 
 //**************************************************************************************************
@@ -24,7 +25,7 @@ void dummytft_dsp_fillRect ( int16_t x, int16_t y, int16_t w, int16_t h, uint16_
 //**************************************************************************************************
 void dummytft_displaybattery ( uint16_t bat0, uint16_t bat100, uint16_t adcval )
 {
-}
+} ;
 
 
 //**************************************************************************************************
@@ -34,7 +35,7 @@ void dummytft_displaybattery ( uint16_t bat0, uint16_t bat100, uint16_t adcval )
 //**************************************************************************************************
 void dummytft_displayvolume ( uint8_t vol )
 {
-}
+} ;
 
 
 //**************************************************************************************************
@@ -44,4 +45,4 @@ void dummytft_displayvolume ( uint8_t vol )
 //**************************************************************************************************
 void dummytft_displaytime ( const char* str, uint16_t color )
 {
-}
\ No newline at end of file
+} ;
\ No newline at end of file
diff --git a/lib/dummytft/src/dummytft.h b/lib/dummytft/src/dummytft.h
index 887ee87..30c393c 100644
--- a/lib/dummytft/src/dummytft.h
+++ b/lib/dummytft/src/dummytft.h
@@ -30,7 +30,6 @@
 #define dsp_getwidth()      0                                      // Get width of screen
 #define dsp_getheight()     0                                      // Get height of screen
 #define dsp_update(a)                                              // Updates to the physical screen
-#define dsp_usesSPI()       false                                  // Does not use SPI
 #define dsp_begin(a)        false
 
 #define tftdata             dummytft_tftdata
diff --git a/platformio.ini b/platformio.ini
index 456fa37..ac198dd 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -3,29 +3,32 @@ platform = espressif32
 ;platform = espressif32@3.1.0
 ;board = esp-wrover-kit
 board = esp32doit-devkit-v1
+;board = esp32-s3-devkitm-1
 framework = arduino
-;board_build.partitions = huge_app.csv
-upload_port = COM3
-;upload_protocol = espota
-;upload_port = 192.168.2.19
-monitor_port = COM3
+board_build.partitions = radiopart.csv
+upload_port = COM13
+;upload_protocol = espota       ; OTA must be enabled in the running version, see config.h
+;upload_port = 192.168.2.18     ; Adjust to the IP of the radio
+monitor_port = COM13
 monitor_speed = 115200
 monitor_dtr = 0
 monitor_rts = 0
-monitor_flags = 
-	--filter=esp32_exception_decoder
-	--echo
+monitor_filters = esp32_exception_decoder
+monitor_echo = yes
 build_flags =
-	-DCORE_DEBUG_LEVEL=0
+	-DCORE_DEBUG_LEVEL=5	; Set to 0 for no debug; saves memory
+                                ; Set to 5 for full debug
 	-Os
 ;	-Wl,-Map,ESP32-Radio.map
-lib_ldf_mode = chain+						; Obey #include lines
+lib_ldf_mode = chain+		; Obey #include lines
 lib_deps = 
-	Wire
-	knolleary/PubSubClient@^2.8
-	adafruit/Adafruit BusIO@^1.9.3
-	adafruit/Adafruit GFX Library@^1.10.4
-	adafruit/Adafruit ILI9341 @ ^1.5.9
-	adafruit/Adafruit ST7735 and ST7789 Library @ ^1.7.5
-	ESP Async WebServer@^1.2.3
-	yveaux/AC101 @ ^0.0.1
+  Wire
+  knolleary/PubSubClient@^2.8
+  adafruit/Adafruit BusIO@^1.9.3
+  adafruit/Adafruit GFX Library@^1.10.4
+  adafruit/Adafruit ILI9341@^1.5.9
+  adafruit/Adafruit ST7735 and ST7789 Library@^1.7.5
+  me-no-dev/AsyncTCP@1.1.1
+  me-no-dev/ESP Async WebServer@^1.2.3
+  yveaux/AC101@^0.0.1
+  djuseeq/Ch376msc @ ^1.4.4
\ No newline at end of file
diff --git a/radiopart.csv b/radiopart.csv
index f03920b..17cc365 100644
--- a/radiopart.csv
+++ b/radiopart.csv
@@ -1,10 +1,11 @@
 # Special 4MB partition map.  app0/1 have some more space,
 # SPIFFS has less space than default setting
 #
-# Name,   Type, SubType, Offset,  Size, Flags
-nvs,      data, nvs,     0x9000,  0x5000,
-otadata,  data, ota,     0xe000,  0x2000,
-app0,     app,  ota_0,   0x10000, 0x170000,
-app1,     app,  ota_1,   0x180000,0x170000,
-spiffs,   data, spiffs,  0x2F0000,0x110000,
-#                END =   0x400000
\ No newline at end of file
+# Name,   Type, SubType,  Offset,   Size,    Flags
+nvs,      data, nvs,      0x9000,   0x5000,
+otadata,  data, ota,      0xe000,   0x2000,
+app0,     app,  ota_0,    0x10000,  0x170000,
+app1,     app,  ota_1,    0x180000, 0x170000,
+spiffs,   data, spiffs,   0x2F0000, 0x100000,
+coredump, data, coredump, 0x3F0000, 0x10000,
+#                END =    0x400000
\ No newline at end of file
diff --git a/src/main.cpp b/src/main.cpp
index dfd0322..a10d820 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -44,7 +44,7 @@
 // ESP32dev Signal  Wired to LCD        Wired to VS1053      AI Audio board    Wired to the rest
 // -------- ------  --------------      -------------------  ---------------   ------------------------
 // GPIO32           -                   pin 1 XDCS           I2C Clock
-// GPIO33           -                   pin 1 XDCS           I2C Data
+// GPIO33           -                   -                    I2C Data
 // GPIO5            -                   pin 2 XCS            KEY 6             -
 // GPIO4            -                   pin 4 DREQ           AMPLIFIER_ENABLE  -
 // GPIO2            pin 3 D/C or A0     -                    SPI_MISO          -
@@ -95,18 +95,34 @@
 // 15-05-2022, ES: Correction mp3 list for web interface.
 // 17-11-2022, ES: Support of AI Audio kit V2.1.
 // 22-11-2022, ES: Fixed memory leak.
+// 28-04-2023, ES: Correct "Request station:port failed!"
+// 10-05-2023, ES: SD card files stored on the SDcard.
+// 19-05-2023, ES: Mute and unmute with 2 buttons or commands.
+// 22-05-2023, ES: Use internal mutex for SPI bus.
+// 16-06-2023, ES: Add sleep commmeand.
+// 09-10-2023, ES: Reduce GPIO errors by checking GPIO pins.
+// 14-12-2023, ES: Add mqtt trigger to refresh all items.
+// 16-01-2024, ES: Disable brownout.
+// 16-02-2024, ES: SPDIFF output (experimental).
+// 19-02-2024, ES: Fixed mono stream, correct handling of reset command.
+// 27-06-2024, ES: Simplified WiFi network set.
+// 17-10-2024, ES: Support for ESP32-S3.
+
 //
 // Define the version number, the format used is the HTTP standard.
-#define VERSION     "Tue, 22 Nov 2022 15:30:00 GMT"
+#define VERSION     "Thu, 17 Oct 2024 10:10:00 GMT"
 //
 #include <Arduino.h>                                      // Standard include for Platformio Arduino projects
+#include "soc/soc.h"                                      // For brown-out detector setting
+#include "soc/rtc_cntl_reg.h"                             // For brown-out detector settingtest
+//#include <esp_log.h>
 #include <WiFi.h>
 #include "config.h"                                       // Specify display type, decoder type
 #include <nvs.h>                                          // Access to NVS
 #include <PubSubClient.h>                                 // MTTQ access
 #ifdef ETHERNET
-  // Definitions for Ethernet controller
-  #include <ETH.h>
+  #include <ETH.h>                                        // Definitions for Ethernet controller
+  //#include <AsyncWebServer_WT32_ETH01.h>
   #define ETH_CLK_MODE    ETH_CLOCK_GPIO0_IN              // External clock from crystal oscillator
   #define ETH_TYPE        ETH_PHY_LAN8720                 // Type of controller
   #define ETH_ADDR        1                               // I2C address of Ethernet PHY
@@ -114,11 +130,13 @@
   #include <WiFiMulti.h>                                  // Handle multiple WiFi networks
   WiFiMulti wifiMulti ;                                   // Object for WiFiMulti
 #endif
+#include <ESPAsyncWebServer.h>                            // For Async Web server
 #include <ESPmDNS.h>                                      // For multicast DNS
 #include <time.h>                                         // Time functions
 #include <SPI.h>                                          // For SPI handling
-#include <ArduinoOTA.h>                                   // Over the air updates
-#include <ESPAsyncWebServer.h>                            // For Async Web server
+#ifdef ENABLEOTA
+  #include <ArduinoOTA.h>                                 // Over the air updates
+#endif
 #include <freertos/queue.h>                               // FreeRtos queue support
 #include <freertos/task.h>                                // FreeRtos task handling
 #include <esp_task_wdt.h>
@@ -126,15 +144,15 @@
 #include <base64.h>                                       // For Basic authentication
 #include <SPIFFS.h>                                       // Filesystem
 #include "utils.h"                                        // Some handy utilities
-#if defined(DEC_HELIX_INT) || defined(DEC_HELIX_AI)       // Software decoder using internal DAC?
-  #define DEC_HELIX                                       // Yes, make sure to include software decoders
-  #ifdef DEC_HELIX_AI                                     // AI Audio kit board?
-   #include <AC101.h>
-   #define GPIO_PA_EN 21                                  // GPIO for enabling amplifier
-   AC101 dac ;                                            // AC101 controls
-  #endif
+#if defined(DEC_HELIX_SPDIF) || defined(DEC_HELIX_INT) || defined(DEC_HELIX_AI)
+  #define DEC_HELIX
+#endif
+#if defined(DEC_HELIX_AI)                                 // AI Audio kit board?
+  #include <AC101.h>
+  #define GPIO_PA_EN 21                                   // GPIO for enabling amplifier
+  AC101 dac ;                                             // AC101 controls
 #endif
-#ifdef DEC_HELIX                                          // Software decoder?
+#if defined(DEC_HELIX)
   #include <driver/i2s.h>                                 // Driver for I2S output
   #include "mp3_decoder.h"                                // Yes, include libhelix_HMP3DECODER
   #include "aac_decoder.h"                                // and libhelix_HAACDECODER
@@ -142,8 +160,9 @@
 #else
   #include "VS1053.h"                                     // Driver for VS1053
 #endif
+#define MAXKEYS           200                             // Max. number of NVS keys in table
 #define FSIF              true                            // Format SPIFFS if not existing
-#define QSIZ              400                             // Number of entries in the queue
+#define QSIZ              400                             // Number of entries in the MP3 stream queue
 #define NVSBUFSIZE        150                             // Max size of a string in NVS
 // Access point name if connection to WiFi network fails.  Also the hostname for WiFi and OTA.
 // Note that the password of an AP must be at least as long as 8 characters.
@@ -154,7 +173,6 @@
 #define MAXPRESETS        200                             // Max number of presets in preferences
 #define MAXMQTTCONNECTS   5                               // Maximum number of MQTT reconnects before give-up
 #define METASIZ           1024                            // Size of metaline buffer
-#define MAXKEYS           200                             // Max. number of NVS keys in table
 #define BL_TIME           45                              // Time-out [sec] for blanking TFT display (BL pin)
 //
 // Subscription topics for MQTT.  The topic will be pefixed by "PREFIX/", where PREFIX is replaced
@@ -168,7 +186,6 @@
 // Forward declaration and prototypes of various functions.                                        *
 //**************************************************************************************************
 void        tftlog ( const char *str, bool newline = false ) ;
-void        otastart() ;
 bool        showstreamtitle ( const char* ml, bool full = false ) ;
 void        handlebyte_ch ( uint8_t b ) ;
 void        handleCmd()  ;
@@ -181,12 +198,10 @@ void        sdfuncs() ;
 void        stop_mp3client () ;
 void        tftset ( uint16_t inx, const char *str ) ;
 void        tftset ( uint16_t inx, String& str ) ;
-void        playtask ( void* parameter ) ;             // Task to play the stream on VS1053 or HELIX decoder
+void        playtask ( void* parameter ) ;                 // Task to play the stream on VS1053 or HELIX decoder
 void        displayinfo ( uint16_t inx ) ;
 void        gettime() ;
 void        reservepin ( int8_t rpinnr ) ;
-void        claimSPI ( const char* p ) ;                // Claim SPI bus for exclusive access
-void        releaseSPI() ;                              // Release the claim
 uint32_t    ssconv ( const uint8_t* bytes ) ;
 void        scan_content_length ( const char* metalinebf ) ;
 void        handle_notfound  ( AsyncWebServerRequest *request ) ;
@@ -195,7 +210,8 @@ void        handle_saveprefs ( AsyncWebServerRequest *request ) ;
 void        handle_getdefs   ( AsyncWebServerRequest *request ) ;
 void        handle_settings  ( AsyncWebServerRequest *request ) ;
 void        handle_mp3list   ( AsyncWebServerRequest *request ) ;
-void        readhostfrompref ( int16_t preset, String* host, String* hsym = NULL ) ;
+void        handle_reset     ( AsyncWebServerRequest *request ) ;
+bool        readhostfrompref ( int16_t preset, String* host, String* hsym = NULL ) ;
 
 
 
@@ -251,6 +267,7 @@ struct ini_struct
   int8_t         i2s_bck_pin ;                        // GPIO Pin number for I2S "BCK"
   int8_t         i2s_lck_pin ;                        // GPIO Pin number for I2S "L(R)CK"
   int8_t         i2s_din_pin ;                        // GPIO Pin number for I2S "DIN"
+  int8_t         i2s_spdif_pin ;                      // GPIO Pin number for SPDIF output
   int8_t         eth_mdc_pin ;                        // GPIO Pin number for Ethernet controller MDC
   int8_t         eth_mdio_pin ;                       // GPIO Pin number for Ethernet controller MDIO
   int8_t         eth_power_pin ;                      // GPIO Pin number for Ethernet controller POWER
@@ -264,32 +281,6 @@ struct WifiInfo_t                                     // For list with WiFi info
   char * passphrase ;                                 // Passphrase for an entry
 } ;
 
-struct nvs_entry
-{
-  uint8_t  Ns ;                                       // Namespace ID
-  uint8_t  Type ;                                     // Type of value
-  uint8_t  Span ;                                     // Number of entries used for this item
-  uint8_t  Rvs ;                                      // Reserved, should be 0xFF
-  uint32_t CRC ;                                      // CRC
-  char     Key[16] ;                                  // Key in Ascii
-  uint64_t Data ;                                     // Data in entry
-} ;
-
-struct nvs_page                                       // For nvs entries
-{ // 1 page is 4096 bytes
-  uint32_t  State ;
-  uint32_t  Seqnr ;
-  uint32_t  Unused[5] ;
-  uint32_t  CRC ;
-  uint8_t   Bitmap[32] ;
-  nvs_entry Entry[126] ;
-} ;
-
-struct keyname_t                                      // For keys in NVS
-{
-  char      Key[16] ;                                 // Max length is 15 plus delimeter
-} ;
-
 // Preset info
 enum station_state_t { ST_PRESET, ST_REDIRECT,        // Possible preset status
                        ST_PLAYLIST, ST_STATION } ;
@@ -305,6 +296,8 @@ struct preset_info_t
     String             hsym ;                         // Symbolic name (comment after name)
 } ;
 
+const char* TAG = "main" ;                            // For debug lines
+
 
 //**************************************************************************************************
 // Global data section.                                                                            *
@@ -322,79 +315,72 @@ enum datamode_t { INIT = 0x1, HEADER = 0x2, DATA = 0x4,      // State for datast
                 } ;
 
 // Global variables
-int               numSsid ;                              // Number of available WiFi networks
-bool              ota = false ;                          // Allow OTA updates
-preset_info_t     presetinfo ;                           // Info about the current or new station
-ini_struct        ini_block ;                            // Holds configurable data
-AsyncWebServer    cmdserver ( 80 ) ;                     // Instance of embedded webserver, port 80
-AsyncClient*      mp3client = NULL ;                     // An instance of the mp3 client
-WiFiClient        wmqttclient ;                          // An instance for mqtt
-PubSubClient      mqttclient ( wmqttclient ) ;           // Client for MQTT subscriber
-TaskHandle_t      maintask ;                             // Taskhandle for main task
-TaskHandle_t      xplaytask ;                            // Task handle for playtask
-TaskHandle_t      xsdtask ;                              // Task handle for SD task
-SemaphoreHandle_t SPIsem = NULL ;                        // For exclusive SPI usage
-hw_timer_t*       timer = NULL ;                         // For timer
-char              timetxt[9] ;                           // Converted timeinfo
-char              cmd[130] ;                             // Command from MQTT or Serial
-const qdata_type  stopcmd = QSTOPSONG ;                  // Command for radio/SD
-const qdata_type  startcmd = QSTARTSONG ;                // Command for radio/SD
-QueueHandle_t     radioqueue = 0 ;                       // Queue for icecast commands
-QueueHandle_t     dataqueue = 0 ;                        // Queue for mp3 datastream
-QueueHandle_t     sdqueue = 0 ;                          // For commands to sdfuncs
-qdata_struct      outchunk ;                             // Data to queue
-qdata_struct      inchunk ;                              // Data from queue
-uint8_t*          outqp = outchunk.buf ;                 // Pointer to buffer in outchunk
-uint32_t          totalcount = 0 ;                       // Counter mp3 data
-datamode_t        datamode ;                             // State of datastream
-int               metacount ;                            // Number of bytes in metadata
-int               datacount ;                            // Counter databytes before metadata
-char              metalinebf[METASIZ + 1] ;              // Buffer for metaline/ID3 tags
-int16_t           metalinebfx ;                          // Index for metalinebf
-String            icystreamtitle ;                       // Streamtitle from metadata
-String            icyname ;                              // Icecast station name
-String            audio_ct ;                             // Content-type, like "audio/aacp"
-String            ipaddress ;                            // Own IP-address
-int               bitrate ;                              // Bitrate in kb/sec
-int               mbitrate ;                             // Measured bitrate
-int               metaint = 0 ;                          // Number of databytes between metadata
-bool              reqtone = false ;                      // New tone setting requested
-bool              muteflag = false ;                     // Mute output
-bool              resetreq = false ;                     // Request to reset the ESP32
-bool              testreq = false ;                      // Request to print test info
-bool              eth_connected = false ;                // Ethernet connected or not
-bool              NetworkFound = false ;                 // True if WiFi network connected
-bool              mqtt_on = false ;                      // MQTT in use
-String            networks = "None|" ;                   // Found networks in the surrounding
-uint16_t          mqttcount = 0 ;                        // Counter MAXMQTTCONNECTS
-int8_t            playingstat = 0 ;                      // 1 if radio is playing (for MQTT)
-int16_t           playlist_num = 0 ;                     // Nonzero for selection from playlist
-bool              chunked = false ;                      // Station provides chunked transfer
-int               chunkcount = 0 ;                       // Counter for chunked transfer
-uint16_t          ir_value = 0 ;                         // IR code
-uint32_t          ir_0 = 550 ;                           // Average duration of an IR short pulse
-uint32_t          ir_1 = 1650 ;                          // Average duration of an IR long pulse
-struct tm         timeinfo ;                             // Will be filled by NTP server
-bool              time_req = false ;                     // Set time requested
-uint16_t          adcvalraw ;                            // ADC value (raw)
-uint16_t          adcval ;                               // ADC value (battery voltage, averaged)
-uint32_t          clength ;                              // Content length found in http header
-uint16_t          bltimer = 0 ;                          // Backlight time-out counter
-bool              dsp_ok = false ;                       // Display okay or not
-int               ir_intcount = 0 ;                      // For test IR interrupts
-bool              spftrigger = false ;                   // To trigger execution of special functions
-const char*       fixedwifi = "" ;                       // Used for FIXEDWIFI option
-const esp_partition_t*  spiffs = NULL ;                  // Pointer to SPIFFS partition struct
-std::vector<WifiInfo_t> wifilist ;                       // List with wifi_xx info
+preset_info_t        presetinfo ;                        // Info about the current or new station
+ini_struct           ini_block ;                         // Holds configurable data
+AsyncWebServer       cmdserver ( 80 ) ;                  // Instance of embedded webserver, port 80
+AsyncClient*         mp3client = NULL ;                  // An instance of the mp3 client
+WiFiClient           wmqttclient ;                       // An instance for mqtt
+PubSubClient         mqttclient ( wmqttclient ) ;        // Client for MQTT subscriber
+TaskHandle_t         maintask ;                          // Taskhandle for main task
+TaskHandle_t         xplaytask ;                         // Task handle for playtask
+TaskHandle_t         xsdtask ;                           // Task handle for SD task
+hw_timer_t*          timer = NULL ;                      // For timer
+char                 timetxt[9] ;                        // Converted timeinfo
+const qdata_struct   stopcmd = {QSTOPSONG} ;             // Command for radio/SD
+const qdata_struct   startcmd = {QSTARTSONG} ;           // Command for radio/SD
+QueueHandle_t        radioqueue = 0 ;                    // Queue for icecast commands
+QueueHandle_t        dataqueue = 0 ;                     // Queue for mp3 datastream
+QueueHandle_t        sdqueue = 0 ;                       // For commands to sdfuncs
+qdata_struct         outchunk ;                          // Data to queue
+qdata_struct         inchunk ;                           // Data from queue
+uint8_t*             outqp = outchunk.buf ;              // Pointer to buffer in outchunk
+uint32_t             totalcount = 0 ;                    // Counter mp3 data
+datamode_t           datamode ;                          // State of datastream
+int                  metacount ;                         // Number of bytes in metadata
+int                  datacount ;                         // Counter databytes before metadata
+RTC_NOINIT_ATTR char metalinebf[METASIZ + 1] ;           // Buffer for metaline/ID3 tags
+RTC_NOINIT_ATTR char cmd[130] ;                          // Command from MQTT or Serial
+int16_t              metalinebfx ;                       // Index for metalinebf
+String               icystreamtitle ;                    // Streamtitle from metadata
+String               icyname ;                           // Icecast station name
+String               audio_ct ;                          // Content-type, like "audio/aacp"
+String               ipaddress ;                         // Own IP-address
+int                  bitrate ;                           // Bitrate in kb/sec
+int                  mbitrate ;                          // Measured bitrate
+int                  metaint = 0 ;                       // Number of databytes between metadata
+bool                 reqtone = false ;                   // New tone setting requested
+bool                 muteflag = false ;                  // Mute output
+bool                 resetreq = false ;                  // Request to reset the ESP32
+bool                 testreq = false ;                   // Request to print test info
+bool                 sleepreq = false ;                  // Request for deep sleep
+bool                 eth_connected = false ;             // Ethernet connected or not
+bool                 NetworkFound = false ;              // True if WiFi network connected
+bool                 mqtt_on = false ;                   // MQTT in use
+uint16_t             mqttcount = 0 ;                     // Counter MAXMQTTCONNECTS
+int8_t               playingstat = 0 ;                   // 1 if radio is playing (for MQTT)
+int16_t              playlist_num = 0 ;                  // Nonzero for selection from playlist
+bool                 chunked = false ;                   // Station provides chunked transfer
+int                  chunkcount = 0 ;                    // Counter for chunked transfer
+uint16_t             ir_value = 0 ;                      // IR code
+uint32_t             ir_0 = 550 ;                        // Average duration of an IR short pulse
+uint32_t             ir_1 = 1650 ;                       // Average duration of an IR long pulse
+struct tm            timeinfo ;                          // Will be filled by NTP server
+bool                 time_req = false ;                  // Set time requested
+uint16_t             adcvalraw ;                         // ADC value (raw)
+uint16_t             adcval ;                            // ADC value (battery voltage, averaged)
+uint32_t             clength ;                           // Content length found in http header
+uint16_t             bltimer = 0 ;                       // Backlight time-out counter
+bool                 dsp_ok = false ;                    // Display okay or not
+int                  ir_intcount = 0 ;                   // For test IR interrupts
+bool                 spftrigger = false ;                // To trigger execution of special functions
+const char*          fixedwifi = "" ;                    // Used for FIXEDWIFI option
+File                 SPIFFSfile ;                        /// File handle for SPIFFS file
 
 // nvs stuff
-nvs_page                nvsbuf ;                         // Space for 1 page of NVS info
-const esp_partition_t*  nvs ;                            // Pointer to partition struct
-esp_err_t               nvserr ;                         // Error code from nvs functions
-uint32_t                nvshandle = 0 ;                  // Handle for nvs access
-uint8_t                 namespace_ID ;                   // Namespace ID found
-char                    nvskeys[MAXKEYS][16] ;           // Space for NVS keys
-std::vector<keyname_t>  keynames ;                       // Keynames in NVS
+const esp_partition_t*  nvs ;                                     // Pointer to partition struct
+esp_err_t               nvserr ;                                  // Error code from nvs functions
+uint32_t                nvshandle = 0 ;                           // Handle for nvs access
+RTC_NOINIT_ATTR char    nvskeys[MAXKEYS][NVS_KEY_NAME_MAX_SIZE] ; // Space for NVS keys
 
 // Rotary encoder stuff
 #define sv DRAM_ATTR static volatile
@@ -418,48 +404,92 @@ struct progpin_struct                                    // For programmable inp
   bool           cur ;                                   // Current state, true = HIGH, false = LOW
 } ;
 
-progpin_struct   progpin[] =                             // Input pins and programmed function
-{
-  {  0, false, false,  "", false },
-  //{  1, true,  false,  "", false },                    // Reserved for TX Serial output
-  {  2, false, false,  "", false },
-  //{  3, true,  false,  "", false },                    // Reserved for RX Serial input
-  {  4, false, false,  "", false },
-  {  5, false, false,  "", false },
-  //{  6, true,  false,  "", false },                    // Reserved for FLASH SCK
-  //{  7, true,  false,  "", false },                    // Reserved for FLASH D0
-  //{  8, true,  false,  "", false },                    // Reserved for FLASH D1
-  //{  9, true,  false,  "", false },                    // Reserved for FLASH D2
-  //{ 10, true,  false,  "", false },                    // Reserved for FLASH D3
-  //{ 11, true,  false,  "", false },                    // Reserved for FLASH CMD
-  { 12, false, false,  "", false },
-  { 13, false, false,  "", false },
-  { 14, false, false,  "", false },
-  { 15, false, false,  "", false },
-  { 16, false, false,  "", false },                      // May be UART 2 RX for Nextion
-  { 17, false, false,  "", false },                      // May be UART 2 TX for Nextion
-  { 18, false, false,  "", false },                      // Default for SPI CLK
-  { 19, false, false,  "", false },                      // Default for SPI MISO
-  //{ 20, true,  false,  "", false },                    // Not exposed on DEV board
-  { 21, false, false,  "", false },                      // Also Wire SDA
-  { 22, false, false,  "", false },                      // Also Wire SCL
-  { 23, false, false,  "", false },                      // Default for SPI MOSI
-  //{ 24, true,  false,  "", false },                    // Not exposed on DEV board
-  { 25, false, false,  "", false },                      // DAC output / I2S output
-  { 26, false, false,  "", false },                      // DAC output / I2S output
-  { 27, false, false,  "", false },                      // I2S output
-  //{ 28, true,  false,  "", false },                    // Not exposed on DEV board
-  //{ 29, true,  false,  "", false },                    // Not exposed on DEV board
-  //{ 30, true,  false,  "", false },                    // Not exposed on DEV board
-  //{ 31, true,  false,  "", false },                    // Not exposed on DEV board
-  { 32, false, false,  "", false },
-  { 33, false, false,  "", false },
-  { 34, false, false,  "", false },                      // Note, no internal pull-up
-  { 35, false, false,  "", false },                      // Note, no internal pull-up
-  //{ 36, true,  false,  "", false },                    // Reserved for ADC battery level
-  { 39, false,  false,  "", false },                     // Note, no internal pull-up
-  { -1, false, false,  "", false }                       // End of list
-} ;
+#ifdef CONFIG_IDF_TARGET_ESP32
+  progpin_struct   progpin[] =                             // Input pins and programmed function
+  {
+    {  0, false, false,  "", false },
+    //{  1, true,  false,  "", false },                    // Reserved for TX Serial output
+    {  2, false, false,  "", false },
+    //{  3, true,  false,  "", false },                    // Reserved for RX Serial input
+    {  4, false, false,  "", false },
+    {  5, false, false,  "", false },
+    //{  6, true,  false,  "", false },                    // Reserved for FLASH SCK
+    //{  7, true,  false,  "", false },                    // Reserved for FLASH D0
+    //{  8, true,  false,  "", false },                    // Reserved for FLASH D1
+    //{  9, true,  false,  "", false },                    // Reserved for FLASH D2
+    //{ 10, true,  false,  "", false },                    // Reserved for FLASH D3
+    //{ 11, true,  false,  "", false },                    // Reserved for FLASH CMD
+    { 12, false, false,  "", false },
+    { 13, false, false,  "", false },
+    { 14, false, false,  "", false },
+    { 15, false, false,  "", false },
+    { 16, false, false,  "", false },                      // May be UART 2 RX for Nextion
+    { 17, false, false,  "", false },                      // May be UART 2 TX for Nextion
+    { 18, false, false,  "", false },                      // Default for SPI CLK
+    { 19, false, false,  "", false },                      // Default for SPI MISO
+    //{ 20, true,  false,  "", false },                    // Not exposed on DEV board
+    { 21, false, false,  "", false },                      // Also Wire SDA
+    { 22, false, false,  "", false },                      // Also Wire SCL
+    { 23, false, false,  "", false },                      // Default for SPI MOSI
+    //{ 24, true,  false,  "", false },                    // Not exposed on DEV board
+    { 25, false, false,  "", false },                      // DAC output / I2S output
+    { 26, false, false,  "", false },                      // DAC output / I2S output
+    { 27, false, false,  "", false },                      // I2S output
+    //{ 28, true,  false,  "", false },                    // Not exposed on DEV board
+    //{ 29, true,  false,  "", false },                    // Not exposed on DEV board
+    //{ 30, true,  false,  "", false },                    // Not exposed on DEV board
+    //{ 31, true,  false,  "", false },                    // Not exposed on DEV board
+    { 32, false, false,  "", false },
+    { 33, false, false,  "", false },
+    { 34, false, false,  "", false },                      // Note, no internal pull-up
+    { 35, false, false,  "", false },                      // Note, no internal pull-up
+    //{ 36, true,  false,  "", false },                    // Reserved for ADC battery level
+    { 39, false,  false,  "", false },                     // Note, no internal pull-up
+    { -1, false, false,  "", false }                       // End of list
+  } ;
+#endif
+#ifdef CONFIG_IDF_TARGET_ESP32S3
+  progpin_struct   progpin[] =                             // Input pins and programmed function
+  {
+    {  0, false, false,  "", false },                      // Also boot
+    //{  1, true,  false,  "", false },                    // Reserved for ADC battery level
+    {  2, false, false,  "", false },
+    {  3, true,  false,  "", false },
+    {  4, false, false,  "", false },
+    {  5, false, false,  "", false },
+    {  6, true,  false,  "", false },
+    {  7, true,  false,  "", false },
+    {  8, true,  false,  "", false },
+    {  9, true,  false,  "", false },
+    { 10, true,  false,  "", false },
+    { 11, true,  false,  "", false },
+    { 12, false, false,  "", false },
+    { 13, false, false,  "", false },
+    { 14, false, false,  "", false },
+    { 15, false, false,  "", false },
+    { 16, false, false,  "", false },                      // May be UART 2 RX for Nextion
+    { 17, false, false,  "", false },                      // May be UART 2 TX for Nextion
+    { 18, false, false,  "", false },                      // Default for SPI CLK
+    //{ 19, false, false,  "", false },                    // Reserved USB D-
+    //{ 20, true,  false,  "", false },                    // Reserved USB D+
+    { 21, false, false,  "", false },                      // Also Wire SDA
+    //{ 35, false, false,  "", false },                    // Reserved PSRAM
+    //{ 36, true,  false,  "", false },                    // Reserved PSRAM
+    //{ 37, true,  false,  "", false },                    // Reserved PSRAM
+    { 38, false,  false,  "", false },
+    { 39, false,  false,  "", false },
+    { 40, false,  false,  "", false },
+    { 41, false,  false,  "", false },
+    { 42, false,  false,  "", false },
+    //{ 43, false,  false,  "", false },                   // Reserved USB/Serial U0TXD
+    //{ 44, false,  false,  "", false },                   // Reserved USB/Serial U0RXD
+    //{ 45, false,  false,  "", false },                   // Reserved SPI Flash voltage
+    //{ 46, false,  false,  "", false },                   // Reserved Boot mode
+    { 47, false,  false,  "", false },
+    { 48, false,  false,  "", false },
+    { -1, false, false,  "", false }                       // End of list
+  } ;
+#endif
 
 struct touchpin_struct                                   // For programmable input pins
 {
@@ -471,14 +501,15 @@ struct touchpin_struct                                   // For programmable inp
   bool           cur ;                                   // Current state, true = HIGH, false = LOW
   int16_t        count ;                                 // Counter number of times low level
 } ;
+#ifdef CONFIG_IDF_TARGET_ESP32
 touchpin_struct   touchpin[] =                           // Touch pins and programmed function
 {
   {   4, false, false, "", false, 0 },                   // TOUCH0
   {   0, true,  false, "", false, 0 },                   // TOUCH1, reserved for BOOT button
   {   2, false, false, "", false, 0 },                   // TOUCH2
   {  15, false, false, "", false, 0 },                   // TOUCH3
-  {  13, false, false, "", false, 0 },                   // TOUCH4
-  {  12, false, false, "", false, 0 },                   // TOUCH5
+  //{  13, false, false, "", false, 0 },                   // TOUCH4, reserved for SPI
+  //{  12, false, false, "", false, 0 },                   // TOUCH5, reserved for SPI
   {  14, false, false, "", false, 0 },                   // TOUCH6
   {  27, false, false, "", false, 0 },                   // TOUCH7
   {  33, false, false, "", false, 0 },                   // TOUCH8
@@ -486,6 +517,28 @@ touchpin_struct   touchpin[] =                           // Touch pins and progr
   {  -1, false, false, "", false, 0 }                    // End of list
   // End of table
 } ;
+#endif
+#ifdef CONFIG_IDF_TARGET_ESP32S3
+touchpin_struct   touchpin[] =                           // Touch pins and programmed function
+{
+  {   1, true,  false, "", false, 0 },                   // TOUCH1
+  {   2, false, false, "", false, 0 },                   // TOUCH2
+  {   3, false, false, "", false, 0 },                   // TOUCH3
+  {   4, false, false, "", false, 0 },                   // TOUCH4
+  {   5, false, false, "", false, 0 },                   // TOUCH5
+  {   6, false, false, "", false, 0 },                   // TOUCH6
+  {   7, false, false, "", false, 0 },                   // TOUCH7
+  {   8, false, false, "", false, 0 },                   // TOUCH8
+  {   9, false, false, "", false, 0 },                   // TOUCH9
+  {  10, false, false, "", false, 0 },                   // TOUCH10
+  {  11, false, false, "", false, 0 },                   // TOUCH11
+  {  12, false, false, "", false, 0 },                   // TOUCH12
+  {  13, false, false, "", false, 0 },                   // TOUCH13
+  {  14, false, false, "", false, 0 },                   // TOUCH14
+  {  -1, false, false, "", false, 0 }                    // End of list
+  // End of table
+} ;
+#endif
 
 
 //**************************************************************************************************
@@ -529,7 +582,8 @@ class mqttpubc                                           // For MQTT publishing
       { NULL,              0,        NULL,                   false }  // End of definitions
     } ;
   public:
-    void          trigger ( uint8_t item ) ;                      // Trigger publishig for one item
+    void          trigger ( uint8_t item ) ;                      // Trigger publishing for one item
+    void          triggerall () ;                                 // Trigger all items
     void          publishtopic() ;                                // Publish triggerer items
 } ;
 
@@ -548,6 +602,21 @@ void mqttpubc::trigger ( uint8_t item )                    // Trigger publishig
   amqttpub[item].topictrigger = true ;                     // Request re-publish for an item
 }
 
+//**************************************************************************************************
+//                                       T R I G G E R A L L                                       *
+//**************************************************************************************************
+// Set request for all items to publish to MQTT.                                                   *
+//**************************************************************************************************
+void mqttpubc::triggerall()                                // Trigger publishig for one item
+{
+  int item = 0 ;                                           // Item to refresh
+
+  while ( amqttpub[item].topic )                           // Cycle through the list of items
+  {
+    trigger ( item++ ) ;                                   // Trigger this item and select next
+  }
+}
+
 //**************************************************************************************************
 //                                     P U B L I S H T O P I C                                     *
 //**************************************************************************************************
@@ -586,11 +655,11 @@ void mqttpubc::publishtopic()
         default :
           continue ;                                          // Unknown data type
       }
-      dbgprint ( "Publish to topic %s : %s",                  // Show for debug
+      ESP_LOGI ( TAG, "Publish to topic %s : %s",             // Show for debug
                  topic, payload ) ;
       if ( !mqttclient.publish ( topic, payload ) )           // Publish!
       {
-        dbgprint ( "MQTT publish failed!" ) ;                 // Failed
+        ESP_LOGE ( TAG, "MQTT publish failed!" ) ;            // Failed
       }
       return ;                                                // Do the rest later
     }
@@ -687,7 +756,7 @@ void nvsopen()
     nvserr = nvs_open ( NAME, NVS_READWRITE, &nvshandle ) ;  // No, open nvs
     if ( nvserr )
     {
-      dbgprint ( "nvs_open failed!" ) ;
+      ESP_LOGE ( TAG, "nvs_open failed!" ) ;
     }
   }
 }
@@ -720,9 +789,9 @@ String nvsgetstr ( const char* key )
   nvserr = nvs_get_str ( nvshandle, key, nvs_buf, &len ) ;
   if ( nvserr )
   {
-    dbgprint ( "nvs_get_str failed %X for key %s, keylen is %d, len is %d!",
+    ESP_LOGE ( TAG, "nvs_get_str failed %X for key %s, keylen is %d, len is %d!",
                nvserr, key, strlen ( key), len ) ;
-    dbgprint ( "Contents: %s", nvs_buf ) ;
+    ESP_LOGE ( TAG, "Contents: %s", nvs_buf ) ;
   }
   return String ( nvs_buf ) ;
 }
@@ -739,10 +808,10 @@ esp_err_t nvssetstr ( const char* key, String val )
   String curcont ;                                         // Current contents
   bool   wflag = true  ;                                   // Assume update or new key
 
-  //dbgprint ( "Setstring for %s: %s", key, val.c_str() ) ;
+  //ESP_LOGI ( TAG, "Setstring for %s: %s", key, val.c_str() ) ;
   if ( val.length() >= NVSBUFSIZE )                        // Limit length of string to store
   {
-    dbgprint ( "nvssetstr length failed!" ) ;
+    ESP_LOGE ( TAG, "nvssetstr length failed!" ) ;
     return ESP_ERR_NVS_NOT_ENOUGH_SPACE ;
   }
   if ( nvssearch ( key ) )                                 // Already in nvs?
@@ -752,35 +821,17 @@ esp_err_t nvssetstr ( const char* key, String val )
   }
   if ( wflag )                                             // Update or new?
   {
-    //dbgprint ( "nvssetstr update value" ) ;
+    //ESP_LOGI ( TAG, "nvssetstr update value" ) ;
     nvserr = nvs_set_str ( nvshandle, key, val.c_str() ) ; // Store key and value
     if ( nvserr )                                          // Check error
     {
-      dbgprint ( "nvssetstr failed!" ) ;
+      ESP_LOGE ( TAG, "nvssetstr failed!" ) ;
     }
   }
   return nvserr ;
 }
 
 
-//**************************************************************************************************
-//                                      N V S C H K E Y                                            *
-//**************************************************************************************************
-// Change a keyname in in nvs.                                                                     *
-//**************************************************************************************************
-void nvschkey ( const char* oldk, const char* newk )
-{
-  String curcont ;                                         // Current contents
-
-  if ( nvssearch ( oldk ) )                                // Old key in nvs?
-  {
-    curcont = nvsgetstr ( oldk ) ;                         // Read current value
-    nvs_erase_key ( nvshandle, oldk ) ;                    // Remove key
-    nvssetstr ( newk, curcont ) ;                          // Insert new
-  }
-}
-
-
 //**************************************************************************************************
 //                                      N V S S E A R C H                                          *
 //**************************************************************************************************
@@ -796,49 +847,6 @@ bool nvssearch ( const char* key )
 }
 
 
-//**************************************************************************************************
-//                                      C L A I M S P I                                            *
-//**************************************************************************************************
-// Claim the SPI bus.  Uses FreeRTOS semaphores.                                                   *
-// If the semaphore cannot be claimed within the time-out period, the function continues without   *
-// claiming the semaphore.  This is incorrect but allows debugging.                                *
-//**************************************************************************************************
-void claimSPI ( const char* p )
-{
-  const              TickType_t ctry = 10 ;                 // Time to wait for semaphore
-  uint32_t           count = 0 ;                            // Wait time in ticks
-  static const char* old_id = "none" ;                      // ID that holds the bus
-
-  while ( xSemaphoreTake ( SPIsem, ctry ) != pdTRUE  )      // Claim SPI bus
-  {
-    if ( count++ > 25 )
-    {
-      dbgprint ( "SPI semaphore not taken within %d ticks by CPU %d,"
-                 " id %s.  Claimed by %s",
-                 count * ctry,
-                 xPortGetCoreID(),
-                 p, old_id ) ;
-    }
-    if ( count >= 100 )
-    {
-      return ;                                               // Continue without semaphore
-    }
-  }
-  old_id = p ;                                               // Remember ID holding the semaphore
-}
-
-
-//**************************************************************************************************
-//                                   R E L E A S E S P I                                           *
-//**************************************************************************************************
-// Free the the SPI bus.  Uses FreeRTOS semaphores.                                                *
-//**************************************************************************************************
-void releaseSPI()
-{
-  xSemaphoreGive ( SPIsem ) ;                            // Release SPI bus
-}
-
-
 //**************************************************************************************************
 //                                      Q U E U E T O P T                                          *
 //**************************************************************************************************
@@ -847,14 +855,12 @@ void releaseSPI()
 //**************************************************************************************************
 void queueToPt ( qdata_type func )
 {
-  qdata_struct     specchunk ;                          // Special function to queue
+  qdata_struct     specchunk ;                            // Special function to queue
 
-  if ( uxQueueSpacesAvailable ( dataqueue ) == 0 )      // Is there space?
-  {
-    xQueueReceive ( dataqueue, &specchunk, 0 ) ;        // No, take out one element
-  }
-  specchunk.datatyp = func ;                            // Put function in datatyp
-  xQueueSendToFront ( dataqueue, &specchunk, 200 ) ;    // Send to queue (First Out)
+  while ( xQueueReceive ( dataqueue, &specchunk, 0 ) ) ;  // Empty the queue
+  specchunk.datatyp = func ;                              // Put function in datatyp
+  xQueueSendToFront ( dataqueue, &specchunk, 200 ) ;      // Send to queue (First Out)
+  vTaskDelay ( 1 ) ;                                      // Give Play task time to react
 }
 
 
@@ -885,59 +891,6 @@ void tftset ( uint16_t inx, String& str )
 }
 
 
-#ifndef ETHERNET
-//**************************************************************************************************
-//                                        L I S T N E T W O R K S                                  *
-//**************************************************************************************************
-// List the available networks.                                                                    *
-// Acceptable networks are those who have an entry in the preferences.                             *
-// SSIDs of available networks will be saved for use in webinterface.                              *
-//**************************************************************************************************
-void listNetworks()
-{
-  WifiInfo_t       winfo ;            // Entry from wifilist
-  wifi_auth_mode_t encryption ;       // TKIP(WPA), WEP, etc.
-  const char*      acceptable ;       // Netwerk is acceptable for connection
-  int              i, j ;             // Loop control
-
-  dbgprint ( "Scan Networks" ) ;                         // Scan for nearby networks
-  numSsid = WiFi.scanNetworks() ;
-  dbgprint ( "Scan completed" ) ;
-  networks = String ( "" ) ;
-  if ( numSsid <= 0 )
-  {
-    dbgprint ( "Couldn't get a wifi connection" ) ;
-    return ;
-  }
-  // print the list of networks seen:
-  dbgprint ( "Number of available networks: %d",
-             numSsid ) ;
-  // Print the network number and name for each network found and
-  for ( i = 0 ; i < numSsid ; i++ )
-  {
-    acceptable = "" ;                                    // Assume not acceptable
-    for ( j = 0 ; j < wifilist.size() ; j++ )            // Search in wifilist
-    {
-      winfo = wifilist[j] ;                              // Get one entry
-      if ( WiFi.SSID(i).indexOf ( winfo.ssid ) == 0 )    // Is this SSID acceptable?
-      {
-        acceptable = "Acceptable" ;
-        break ;
-      }
-    }
-    encryption = WiFi.encryptionType ( i ) ;
-    dbgprint ( "%2d - %-25s Signal: %3d dBm, Encryption %4s, %s",
-               i + 1, WiFi.SSID(i).c_str(), WiFi.RSSI(i),
-               getEncryptionType ( encryption ),
-               acceptable ) ;
-    // Remember this network for later use
-    networks += WiFi.SSID(i) + String ( "|" ) ;
-  }
-  dbgprint ( "End of list" ) ;
-}
-#endif
-
-
 //**************************************************************************************************
 //                                          U P D A T E N R                                        *
 //**************************************************************************************************
@@ -948,7 +901,7 @@ bool updateNr ( int16_t* pnr, int16_t maxnr, int16_t nr, bool relative )
 {
   bool res = true ;                                           // Assume positive result
 
-  //dbgprint ( "updateNr %d <= %d to %d, relative is %d",
+  //ESP_LOGI ( TAG, "updateNr %d <= %d to %d, relative is %d",
   //           *pnr, maxnr, nr, relative ) ;
   if ( relative )                                             // Relative to pnr?
   {
@@ -968,7 +921,7 @@ bool updateNr ( int16_t* pnr, int16_t maxnr, int16_t nr, bool relative )
     res = false ;                                             // Too high, set bad result
     *pnr = 0 ;                                                // and wrap
   }
-  //dbgprint ( "updateNr result is %d", *pnr ) ;
+  //ESP_LOGI ( TAG, "updateNr result is %d", *pnr ) ;
   return res ;                                                // Return the result
 }
 
@@ -978,9 +931,9 @@ bool updateNr ( int16_t* pnr, int16_t maxnr, int16_t nr, bool relative )
 //**************************************************************************************************
 // Set the preset for the next station.  May be relative.                                          *
 //**************************************************************************************************
-void nextPreset ( int16_t pnr, bool relative = false )
+bool nextPreset ( int16_t pnr, bool relative = false )
 {
-  //dbgprint ( "nextpreset called with pnr = %d", pnr ) ;
+  //ESP_LOGI ( TAG, "nextpreset called with pnr = %d", pnr ) ;
   if ( ( presetinfo.station_state == ST_STATION ) ||           // In station mode?
        ( presetinfo.station_state == ST_REDIRECT ) )           // or redirect mode?
   {
@@ -1000,10 +953,15 @@ void nextPreset ( int16_t pnr, bool relative = false )
     updateNr ( &presetinfo.preset,                             // Select next preset
                presetinfo.highest_preset,
                pnr, relative ) ;
-    readhostfrompref ( presetinfo.preset, &presetinfo.host,    // Set host
-                       &presetinfo.hsym ) ;
-    dbgprint ( "nextPreset is %d", presetinfo.preset ) ;
+    if ( ! readhostfrompref ( presetinfo.preset,              // Set host
+                              &presetinfo.host,
+                              &presetinfo.hsym ) )
+    {
+      return false ;
+    }
+    ESP_LOGI ( TAG, "nextPreset is %d", presetinfo.preset ) ;
   }
+  return true ;
 }
 
 
@@ -1026,7 +984,7 @@ void IRAM_ATTR timer10sec()
                     PLAYLISTHEADER |
                     PLAYLISTDATA ) )
   {
-    bytesplayed = totalcount - oldtotalcount ;    // Nunber of bytes played in the 10 seconds
+    bytesplayed = totalcount - oldtotalcount ;    // Number of bytes played in the 10 seconds
     oldtotalcount = totalcount ;                  // Save for comparison in next cycle
     if ( bytesplayed == 0 )                       // Still playing?
     {
@@ -1052,7 +1010,7 @@ void IRAM_ATTR timer10sec()
     {
       //                                          // Data has been send to MP3 decoder
       // Bitrate in kbits/s is bytesplayed / 10 / 1000 * 8
-      mbitrate = ( bytesplayed + 625 ) / 1250 ;   // Measured bitrate
+      mbitrate = ( bytesplayed + 625 ) / 1250 ;   // Measured bitrate, rounded
       morethanonce = 0 ;                          // Data seen, reset failcounter
     }
   }
@@ -1330,8 +1288,8 @@ bool showstreamtitle ( const char *ml, bool full )
 
   if ( strstr ( ml, "StreamTitle=" ) )
   {
-    dbgprint ( "Streamtitle found, %d bytes", strlen ( ml ) ) ;
-    dbgprint ( ml ) ;
+    ESP_LOGI ( TAG, "Streamtitle found, %d bytes", strlen ( ml ) ) ;
+    ESP_LOGI ( TAG, "%s", ml ) ;
     p1 = (char*)ml + 12 ;                       // Begin of artist and title
     if ( ( p2 = strstr ( ml, ";" ) ) )          // Search for end of title
     {
@@ -1391,7 +1349,7 @@ bool showstreamtitle ( const char *ml, bool full )
 //**************************************************************************************************
 void setdatamode ( datamode_t newmode )
 {
-  //dbgprint ( "Change datamode from 0x%03X to 0x%03X",
+  //ESP_LOGI ( TAG, "Change datamode from 0x%03X to 0x%03X",
   //           (int)datamode, (int)newmode ) ;
   datamode = newmode ;
 }
@@ -1407,10 +1365,10 @@ void stop_mp3client ()
   queueToPt ( QSTOPSONG ) ;                        // Queue a request to stop the song
   while ( mp3client && mp3client->connected() )    // Client active and connected?
   {
-    dbgprint ( "Stopping client" ) ;               // Yes, stop connection to host
+    ESP_LOGI ( TAG, "Stopping client" ) ;          // Yes, stop connection to host
     //mp3client->close() ;                         // Causes memory leak!
     mp3client->abort() ;                           // This works better
-    delay ( 500 ) ;
+    vTaskDelay ( 500 / portTICK_PERIOD_MS ) ;
   }
 }
 
@@ -1418,7 +1376,7 @@ void stop_mp3client ()
 //**************************************************************************************************
 //                                    C O N N E C T T O H O S T                                    *
 //**************************************************************************************************
-// Connect to the Internet radio server specified by presetinfo.                                   *
+// Connect to the Internet radio server specified by presetinfo and send the GET request.          *
 //**************************************************************************************************
 bool connecttohost()
 {
@@ -1429,11 +1387,13 @@ bool connecttohost()
   String      auth  ;                                // For basic authentication
   char        getreq[500] ;                          // GET command for MP3 host
   int         retrycount = 0 ;                       // Count for connect
+  size_t      len ;                                  // Length of GET request
+  bool        res = false ;                          // Function result, assume bad result
 
   stop_mp3client() ;                                 // Disconnect if still connected
   chomp ( presetinfo.host ) ;                        // Do some filtering
   hostwoext = presetinfo.host ;                      // Assume host does not have extension
-  dbgprint ( "Connect to host %s",
+  ESP_LOGI ( TAG, "Connect to host %s",
              presetinfo.host.c_str() ) ;
   tftset ( 0, NAME ) ;                               // Set screen segment text top line
   tftset ( 1, "" ) ;                                 // Clear song and artist
@@ -1445,7 +1405,7 @@ bool connecttohost()
     presetinfo.station_state = ST_PLAYLIST ;         // Yes, change station state
     presetinfo.playlisthost = presetinfo.host ;      // Save copy of playlist URL
     setdatamode ( PLAYLISTINIT ) ;                   // Yes, start in PLAYLIST mode
-    dbgprint ( "Playlist request, entry %d",
+    ESP_LOGI ( TAG, "Playlist request, entry %d",
                presetinfo.playlistnr ) ;
   }
   // In the URL there may be an extension, like noisefm.ru:8000/play.m3u&t=.m3u
@@ -1462,7 +1422,7 @@ bool connecttohost()
     port = hostwoext.substring ( inx + 1 ).toInt() ; // Get portnumber as integer
     hostwoext = hostwoext.substring ( 0, inx ) ;     // Host without portnumber
   }
-  //dbgprint ( "Connect to %s on port %d, extension %s",
+  //ESP_LOGI ( TAG, "Connect to %s on port %d, extension %s",
   //           hostwoext.c_str(), port, extension.c_str() ) ;
   if ( mp3client->connect ( hostwoext.c_str(), port ) )
   {
@@ -1495,16 +1455,20 @@ bool connecttohost()
                 extension.c_str(),
                 hostwoext.c_str(),
                 auth.c_str() ) ;
-      dbgprint ( "send GET command" ) ;
+      ESP_LOGI ( TAG, "send GET command" ) ;
       if ( mp3client->canSend() )
       {
-        mp3client->write ( getreq, strlen ( getreq ) ) ;    // Send get request
+        len = strlen ( getreq ) ;                         // Length of string to send
+        res = mp3client->write ( getreq, len ) == len  ;  // Send GET request, set result
       }
     }
   }
-  dbgprint ( "Request %s failed!",                        // Report error
-             presetinfo.host.c_str() ) ;
-  return false ;
+  else
+  {
+    ESP_LOGE ( TAG, "Request %s failed!",                    // Report error
+               presetinfo.host.c_str() ) ;
+  }
+  return res ;
 }
 
 
@@ -1538,35 +1502,35 @@ void EthEvent ( WiFiEvent_t event )
 
   switch ( event )                                    // What event?
   {
-    case SYSTEM_EVENT_ETH_START :
-      dbgprint ( "ETH Started" ) ;                    // Driver started
+    case ARDUINO_EVENT_ETH_START :
+      ESP_LOGI ( TAG, "ETH Started" ) ;               // Driver started
       ETH.setHostname ( NAME ) ;                      // Set the eth hostname now
       break ;
-    case SYSTEM_EVENT_ETH_CONNECTED :
-      dbgprint ( "ETH cable connected" ) ;            // We have a connection
+    case ARDUINO_EVENT_ETH_CONNECTED :
+      ESP_LOGI ( TAG, "ETH cable connected" ) ;       // We have a connection
       break ;
-    case SYSTEM_EVENT_ETH_GOT_IP :
+    case ARDUINO_EVENT_ETH_GOT_IP :
       if ( ETH.fullDuplex() )                         // IP received from DHCP
       {
         fd = ", FULL_DUPLEX" ;                        // It is full duplex
       }
       ipaddress = ETH.localIP().toString() ;          // Remember for display
-      dbgprint ( "IPv4: %s, %d Mbps%s",               // Show status
+      ESP_LOGI ( TAG, "IPv4: %s, %d Mbps%s",          // Show status
                  ipaddress.c_str(),
                  ETH.linkSpeed(),
                  fd ) ;
       eth_connected = true ;                          // Set global flag: connection OK
       break ;
-    case SYSTEM_EVENT_ETH_DISCONNECTED :
-      dbgprint ( "ETH cable disconnected" ) ;         // We have a disconnection
+    case ARDUINO_EVENT_ETH_DISCONNECTED :
+      ESP_LOGI ( TAG, "ETH cable disconnected" ) ;    // We have a disconnection
       eth_connected = false ;                         // Clear the global flag
       break ;
-    case SYSTEM_EVENT_ETH_STOP :
-      dbgprint ( "ETH Stopped" ) ;
+    case ARDUINO_EVENT_ETH_STOP :
+      ESP_LOGI ( TAG, "ETH Stopped" ) ;
       eth_connected = false ;
       break ;
     default :
-      dbgprint ( "ETH event %d", (int)event ) ;       // Unknown event
+      ESP_LOGI ( TAG, "ETH event %d", (int)event ) ;  // Unknown event
       break ;
   }
 }
@@ -1583,7 +1547,7 @@ bool connectETH()
   bool        res ;                                     // Result of connect
   int         tries = 0 ;                               // Counter for wait time
   
-  dbgprint ( "ETH pins %d, %d and %d",
+  ESP_LOGI ( TAG, "ETH pins %d, %d and %d",
              ini_block.eth_power_pin,
              ini_block.eth_mdc_pin,
              ini_block.eth_mdio_pin ) ;
@@ -1593,14 +1557,14 @@ bool connectETH()
                      ETH_TYPE, ETH_CLK_MODE ) ;
   while ( res & ( ! eth_connected ) )                   // Wait for connect
   {
-    delay ( 1000 ) ;
+    vTaskDelay ( 1000 / portTICK_PERIOD_MS ) ;
     if ( tries++ == 10 )                                // Limit wait time
     {
       res = false ;                                     // No luck
     }
   }
   pIP = ipaddress.c_str() ;                             // As c-string
-  dbgprint ( "IP = %s", pIP ) ;
+  ESP_LOGI ( TAG, "IP = %s", pIP ) ;
   tftlog ( "IP = " ) ;                                  // Show IP
   tftlog ( pIP, true ) ;
   #ifdef NEXTION
@@ -1624,63 +1588,57 @@ bool connectwifi()
   const char* pIP ;                                     // Pointer to IP address
   WifiInfo_t  winfo ;                                   // Entry from wifilist
 
+  WiFi.mode ( WIFI_STA ) ;                              // This ESP is a station
   WiFi.disconnect ( true ) ;                            // After restart the router could
   WiFi.softAPdisconnect ( true ) ;                      // still keep the old connection
   vTaskDelay ( 1000 / portTICK_PERIOD_MS ) ;            // Silly things to start connection
   WiFi.mode ( WIFI_STA ) ;
   vTaskDelay ( 1000 / portTICK_PERIOD_MS ) ;
-  if ( wifilist.size()  )                               // Any AP defined?
+  if ( wifiMulti.run() == WL_NO_SSID_AVAIL )            // Connect to best network
   {
-    if ( wifilist.size() == 1 )                         // Just one AP defined in preferences?
-    {
-      winfo = wifilist[0] ;                             // Get this entry
-      WiFi.begin ( winfo.ssid, winfo.passphrase ) ;     // Connect to single SSID found in wifi_xx
-      dbgprint ( "Try WiFi %s", winfo.ssid ) ;          // Message to show during WiFi connect
-    }
-    else                                                // More AP to try
-    {
-      wifiMulti.run() ;                                 // Connect to best network
-    }
-    if (  WiFi.waitForConnectResult() != WL_CONNECTED ) // Try to connect
-    {
-      localAP = true ;                                  // Error, setup own AP
-    }
+    localAP = true ;
   }
   else
   {
-    localAP = true ;                                    // Not even a single AP defined
+    if ( WiFi.waitForConnectResult() != WL_CONNECTED )  // Try to connect
+    {
+      localAP = true ;                                  // Error, setup own AP
+    }
   }
   if ( localAP )                                        // Must setup local AP?
   {
-    dbgprint ( "WiFi Failed!  Trying to setup AP with"
+    ESP_LOGI ( TAG, "WiFi Failed!  Trying to setup AP with"
                " name %s and password %s.",
                NAME, NAME ) ;
     WiFi.disconnect ( true ) ;                          // After restart the router could
     WiFi.softAPdisconnect ( true ) ;                    // still keep the old connection
-    IPAddress ipAP = WiFi.softAP ( NAME, NAME ) ;       // This ESP will be an AP
-    ipaddress = ipAP.toString() ;                       // IP address, usually 192.168.4.1
+    if ( ! WiFi.softAP ( NAME, NAME ) )                 // This ESP will be an AP
+    {
+      ESP_LOGE ( TAG, "AP failed" ) ;                   // Setup of AP failed
+    }
+    ipaddress = String ( "192.168.4.1" ) ;              // Fixed IP address
   }
   else
   {
     tftlog ( "SSID = " ) ;                              // Show SSID on display
     tftlog ( WiFi.SSID().c_str(), true ) ;
-    dbgprint ( "SSID = %s",                             // Format string with SSID connected to
+    ESP_LOGI ( TAG, "SSID = %s",                        // Format string with SSID connected to
                WiFi.SSID().c_str() ) ;
     ipaddress = WiFi.localIP().toString() ;             // Form IP address
   }
   pIP = ipaddress.c_str() ;                             // As c-string
-  dbgprint ( "IP = %s", pIP ) ;
+  ESP_LOGI ( TAG, "IP = %s", pIP ) ;
   tftlog ( "IP = " ) ;                                  // Show IP
   tftlog ( pIP, true ) ;
   #ifdef NEXTION
-    delay ( 2000 ) ;                                    // Show for some time
+    vTaskDelay ( 2000 / portTICK_PERIOD_MS ) ;          // Show for some time
     dsp_println ( "\f" ) ;                              // Select new page if NEXTION 
   #endif
   return ( localAP == false ) ;                         // Return result of connection
 }
 #endif
 
-
+#ifdef ENABLEOTA
 //**************************************************************************************************
 //                                           O T A S T A R T                                       *
 //**************************************************************************************************
@@ -1690,7 +1648,7 @@ void otastart()
 {
   const char* p = "OTA update Started" ;
 
-  dbgprint ( p ) ;                                 // Show event for debug
+  ESP_LOGI ( TAG, "%s", p ) ;                      // Show event for debug
   tftset ( 2, p ) ;                                // Set screen segment bottom part
   mp3client->abort() ;                             // Stop client
   timerAlarmDisable ( timer ) ;                    // Disable the timer
@@ -1707,42 +1665,10 @@ void otastart()
 //**************************************************************************************************
 void otaerror ( ota_error_t error)
 {
-  dbgprint ( "OTA error %d", error ) ;
+  ESP_LOGE ( TAG, "OTA error %d", error ) ;
   tftset ( 2, "OTA error!" ) ;                        // Set screen segment bottom part
 }
-
-
-//**************************************************************************************************
-//                                           O T A H A N D L E                                     *
-//**************************************************************************************************
-// Do OTA handling.                                                                                *
-// It seems that OTA handling often crashes the software.  Therefore it is made optionally.        *
-//**************************************************************************************************
-void otaHandle()
-{
-  if ( ota )                                       // OTA enabled?
-  {
-    ArduinoOTA.handle() ;                          // Check for OTA
-  }
-}
-
-
-//**************************************************************************************************
-//                                           O T A I N I T                                         *
-//**************************************************************************************************
-// Init OTA handling.                                                                              *
-// It seems that OTA handling often crashes the software.  Therefore it is mad optionally.         *
-//**************************************************************************************************
-void otaInit()
-{
-  if ( ota )
-  {
-    ArduinoOTA.setHostname ( NAME ) ;                    // Set the hostname
-    ArduinoOTA.onStart ( otastart ) ;
-    ArduinoOTA.onError ( otaerror ) ;
-    ArduinoOTA.begin() ;                                 // Allow update over the air
-  }
-}
+#endif                                                // ENABLEOTA
 
 
 //**************************************************************************************************
@@ -1752,7 +1678,7 @@ void otaInit()
 // The host will be returned.                                                                      *
 // We search for "preset_x" or "preset_xx" or "preset_xxx".                                        *
 //**************************************************************************************************
-void readhostfrompref ( int16_t preset, String* host, String* hsym )
+bool readhostfrompref ( int16_t preset, String* host, String* hsym )
 {
   char           tkey[12] ;                            // Key as an array of char
   int            inx ;                                 // Position of comment in preset
@@ -1769,7 +1695,7 @@ void readhostfrompref ( int16_t preset, String* host, String* hsym )
     {
       *host = String ( "" ) ;                          // Not found
       *hsym = *host ;                                  // Symbolic name also unknown
-      return ;
+      return false ;
     }
   }
   // Get the contents
@@ -1785,6 +1711,7 @@ void readhostfrompref ( int16_t preset, String* host, String* hsym )
     }
     chomp ( *hsym ) ;                                  // Remove garbage from description
   }
+  return true ;
 }
 
 
@@ -1802,11 +1729,11 @@ void readprogbuttons()
 
   for ( i = 0 ; ( pinnr = progpin[i].gpio ) >= 0 ; i++ )    // Scan for all programmable pins
   {
-    //dbgprint ( "Check programmable GPIO_%02d",pinnr ) ;
+    //ESP_LOGI ( TAG, "Check programmable GPIO_%02d",pinnr ) ;
     sprintf ( mykey, "gpio_%02d", pinnr ) ;                 // Form key in preferences
     if ( nvssearch ( mykey ) )
     {
-      //dbgprint ( "Pin in NVS" ) ;
+      //ESP_LOGI ( TAG, "Pin in NVS" ) ;
       val = nvsgetstr ( mykey ) ;                           // Get the contents
       if ( val.length() )                                   // Does it exists?
       {
@@ -1814,7 +1741,7 @@ void readprogbuttons()
         {
           progpin[i].avail = true ;                         // This one is active now
           progpin[i].command = val ;                        // Set command
-          dbgprint ( "gpio_%02d will execute %s",           // Show result
+          ESP_LOGI ( TAG, "gpio_%02d will execute %s",      // Show result
                      pinnr, val.c_str() ) ;
         }
       }
@@ -1834,14 +1761,14 @@ void readprogbuttons()
           touchpin[i].avail = true ;                        // This one is active now
           touchpin[i].command = val ;                       // Set command
           //pinMode ( touchpin[i].gpio,  INPUT ) ;          // Free floating input
-          dbgprint ( "touch_%02d will execute %s",          // Show result
+          ESP_LOGI ( TAG, "touch_%02d will execute %s",     // Show result
                      i, val.c_str() ) ;
-          dbgprint ( "Level is now %d",
+          ESP_LOGI ( TAG, "Level is now %d",
                      touchRead ( pinnr ) ) ;                // Sample the pin
         }
         else
         {
-          dbgprint ( "touch_%02d pin (GPIO%02d) is reserved for I/O!",
+          ESP_LOGE ( TAG, "touch_%02d pin (GPIO%02d) is reserved for I/O!",
                      i, pinnr ) ;
         }
       }
@@ -1867,9 +1794,9 @@ void reservepin ( int8_t rpinnr )
     {
       if ( progpin[i].reserved )                            // Already reserved?
       {
-        dbgprint ( "Pin %d is already reserved!", rpinnr ) ;
+        ESP_LOGE ( TAG, "Pin %d is already reserved!", rpinnr ) ;
       }
-      //dbgprint ( "GPIO%02d unavailabe for 'gpio_'-command",
+      //ESP_LOGE ( TAG, "GPIO%02d unavailabe for 'gpio_'-command",
       //           pin ) ;
       progpin[i].reserved = true ;                          // Yes, pin is reserved now
       break ;                                               // No need to continue
@@ -1882,7 +1809,7 @@ void reservepin ( int8_t rpinnr )
   {
     if ( pin == rpinnr )                                    // Entry found?
     {
-      //dbgprint ( "GPIO%02d unavailabe for touch command",
+      //ESP_LOGI ( TAG, "GPIO%02d unavailabe for touch command",
       //           pin ) ;
       touchpin[i].reserved = true ;                         // Yes, pin is reserved now
       break ;                                               // No need to continue
@@ -1902,47 +1829,57 @@ void readIOprefs()
   struct iosetting
   {
     const char* gname ;                                   // Name in preferences
-    int8_t*     gnr ;                                     // GPIO pin number
+    int8_t*     gnr ;                                     // Address of target GPIO pin number
     int8_t      pdefault ;                                // Default pin
   };
   struct iosetting klist[] = {                            // List of I/O related keys
-    { "pin_ir",        &ini_block.ir_pin,           -1 },
-    { "pin_enc_clk",   &ini_block.enc_clk_pin,      -1 }, // Rotary encoder CLK
-    { "pin_enc_dt",    &ini_block.enc_dt_pin,       -1 }, // Rotary encoder DT
-    { "pin_enc_up",    &ini_block.enc_up_pin,       -1 }, // ZIPPY B5 side switch up
-    { "pin_enc_dwn",   &ini_block.enc_dwn_pin,      -1 }, // ZIPPY B5 side switch down
-    { "pin_enc_sw",    &ini_block.enc_sw_pin,       -1 },
-    { "pin_tft_cs",    &ini_block.tft_cs_pin,       -1 }, // Display SPI version
-    { "pin_tft_dc",    &ini_block.tft_dc_pin,       -1 }, // Display SPI version
-    { "pin_tft_scl",   &ini_block.tft_scl_pin,      -1 }, // Display I2C version
-    { "pin_tft_sda",   &ini_block.tft_sda_pin,      -1 }, // Display I2C version
-    { "pin_tft_bl",    &ini_block.tft_bl_pin,       -1 }, // Display backlight
-    { "pin_tft_blx",   &ini_block.tft_blx_pin,      -1 }, // Display backlight (inversed logic)
-    { "pin_nxt_rx",    &ini_block.nxt_rx_pin,       -1 }, // NEXTION input pin
-    { "pin_nxt_tx",    &ini_block.nxt_tx_pin,       -1 }, // NEXTION output pin
-    { "pin_sd_cs",     &ini_block.sd_cs_pin,        -1 }, // SD card select
-    { "pin_sd_detect", &ini_block.sd_detect_pin,    -1 }, // SD card detect
-    { "pin_vs_cs",     &ini_block.vs_cs_pin,        -1 }, // VS1053 pins
-    { "pin_vs_dcs",    &ini_block.vs_dcs_pin,       -1 },
-    { "pin_vs_dreq",   &ini_block.vs_dreq_pin,      -1 },
-    { "pin_shutdown",  &ini_block.shutdown_pin,     -1 }, // Amplifier shut-down pin
-    { "pin_shutdownx", &ini_block.shutdownx_pin,    -1 }, // Amplifier shut-down pin (inversed logic)
-    { "pin_i2s_bck",   &ini_block.i2s_bck_pin,      -1 }, // I2S interface pins
-    { "pin_i2s_lck",   &ini_block.i2s_lck_pin,      -1 },
-    { "pin_i2s_din",   &ini_block.i2s_din_pin,      -1 },
-  #ifdef ETHERNET
-    { "pin_spi_sck",   &ini_block.spi_sck_pin,      -1 },
-    { "pin_spi_miso",  &ini_block.spi_miso_pin,     -1 },
-    { "pin_spi_mosi",  &ini_block.spi_mosi_pin,     -1 },
-    { "pin_eth_mdc",   &ini_block.eth_mdc_pin,      23 },
-    { "pin_eth_mdio",  &ini_block.eth_mdio_pin,     18 },
-    { "pin_eth_power", &ini_block.eth_power_pin,    16 },
-  #else
-    { "pin_spi_sck",   &ini_block.spi_sck_pin,      18 }, // Note: different for AI Audio kit (14)
-    { "pin_spi_miso",  &ini_block.spi_miso_pin,     19 }, // Note: different for AI Audio kit (2)
-    { "pin_spi_mosi",  &ini_block.spi_mosi_pin,     23 }, // Note: different for AI Audio kit (15)
-  #endif
-    { NULL,            NULL,                        0  }  // End of list
+      { "pin_ir",        &ini_block.ir_pin,           -1 },
+      { "pin_enc_clk",   &ini_block.enc_clk_pin,      -1 }, // Rotary encoder CLK
+      { "pin_enc_dt",    &ini_block.enc_dt_pin,       -1 }, // Rotary encoder DT
+      { "pin_enc_up",    &ini_block.enc_up_pin,       -1 }, // ZIPPY B5 side switch up
+      { "pin_enc_dwn",   &ini_block.enc_dwn_pin,      -1 }, // ZIPPY B5 side switch down
+      { "pin_enc_sw",    &ini_block.enc_sw_pin,       -1 },
+      { "pin_tft_cs",    &ini_block.tft_cs_pin,       -1 }, // Display SPI version
+      { "pin_tft_dc",    &ini_block.tft_dc_pin,       -1 }, // Display SPI version
+      { "pin_tft_scl",   &ini_block.tft_scl_pin,      -1 }, // Display I2C version
+      { "pin_tft_sda",   &ini_block.tft_sda_pin,      -1 }, // Display I2C version
+      { "pin_tft_bl",    &ini_block.tft_bl_pin,       -1 }, // Display backlight
+      { "pin_tft_blx",   &ini_block.tft_blx_pin,      -1 }, // Display backlight (inversed logic)
+      { "pin_nxt_rx",    &ini_block.nxt_rx_pin,       -1 }, // NEXTION input pin
+      { "pin_nxt_tx",    &ini_block.nxt_tx_pin,       -1 }, // NEXTION output pin
+      { "pin_sd_cs",     &ini_block.sd_cs_pin,        -1 }, // SD card select
+      { "pin_sd_detect", &ini_block.sd_detect_pin,    -1 }, // SD card detect
+    #if defined(DEC_VS1053) || defined(DEC_VS1003)
+      { "pin_vs_cs",     &ini_block.vs_cs_pin,        -1 }, // VS1053 pins
+      { "pin_vs_dcs",    &ini_block.vs_dcs_pin,       -1 },
+      { "pin_vs_dreq",   &ini_block.vs_dreq_pin,      -1 },
+    #endif
+      { "pin_shutdown",  &ini_block.shutdown_pin,     -1 }, // Amplifier shut-down pin
+      { "pin_shutdownx", &ini_block.shutdownx_pin,    -1 }, // Amplifier shut-down pin (inversed logic)
+    #ifdef DEC_HELIX
+     #ifndef DEC_HELIX_INT
+      #ifdef DEC_HELIX_SPDIF
+      { "pin_i2s_spdif", &ini_block.i2s_spdif_pin,    -1 },
+      #else
+      { "pin_i2s_bck",   &ini_block.i2s_bck_pin,      -1 }, // I2S interface pins
+      { "pin_i2s_lck",   &ini_block.i2s_lck_pin,      -1 },
+      { "pin_i2s_din",   &ini_block.i2s_din_pin,      -1 },
+      #endif
+     #endif
+    #endif
+    #ifdef ETHERNET
+      { "pin_spi_sck",   &ini_block.spi_sck_pin,      -1 },
+      { "pin_spi_miso",  &ini_block.spi_miso_pin,     -1 },
+      { "pin_spi_mosi",  &ini_block.spi_mosi_pin,     -1 },
+      { "pin_eth_mdc",   &ini_block.eth_mdc_pin,      23 },
+      { "pin_eth_mdio",  &ini_block.eth_mdio_pin,     18 },
+      { "pin_eth_power", &ini_block.eth_power_pin,    16 },
+    #else
+      { "pin_spi_sck",   &ini_block.spi_sck_pin,      SCK  }, // Note: different for AI Audio kit (14)
+      { "pin_spi_miso",  &ini_block.spi_miso_pin,     MISO }, // Note: different for AI Audio kit (2)
+      { "pin_spi_mosi",  &ini_block.spi_mosi_pin,     MOSI }, // Note: different for AI Audio kit (15)
+    #endif
+      { NULL,            NULL,                        0  }  // End of list
   } ;
   int         i ;                                         // Loop control
   int         count = 0 ;                                 // Number of keys found
@@ -1965,9 +1902,9 @@ void readIOprefs()
       }
     }
     *p = ival ;                                           // Set pinnumber in ini_block
-    if ( ival > 0 )                                       // Only show configured pins
+    if ( ival >= 0 )                                      // Only show configured pins
     {
-      dbgprint ( "%s set to %d",                          // Show result
+      ESP_LOGI ( TAG, "'%-13s' set to %d",      // Show result
                  klist[i].gname,
                  ival ) ;
     }
@@ -1995,7 +1932,7 @@ String readprefs ( bool output )
   for ( i = 0 ; i < MAXKEYS ; i++ )                         // Loop trough all available keys
   {
     key = nvskeys[i] ;                                      // Examine next key
-    //dbgprint ( "Key[%d] is %s", i, key ) ;
+    //ESP_LOGI ( TAG, "Key[%d] is %s", i, key ) ;
     if ( *key == '\0' ) break ;                             // Stop on end of list
     val = nvsgetstr ( key ) ;                               // Read value of this key
     cmd = String ( key ) +                                  // Yes, form command
@@ -2059,7 +1996,7 @@ bool mqttreconnect()
     return res ;                                          // and quit
   }
   mqttcount++ ;                                           // Count the retries
-  dbgprint ( "(Re)connecting number %d to MQTT %s",       // Show some debug info
+  ESP_LOGI ( TAG, "(Re)connecting number %d to MQTT %s",  // Show some debug info
              mqttcount,
              ini_block.mqttbroker.c_str() ) ;
   sprintf ( clientid, "%s-%04d",                          // Generate client ID
@@ -2076,13 +2013,13 @@ bool mqttreconnect()
     res = mqttclient.subscribe ( subtopic ) ;             // Subscribe to MQTT
     if ( !res )
     {
-      dbgprint ( "MQTT subscribe failed!" ) ;             // Failure
+      ESP_LOGE ( TAG, "MQTT subscribe failed!" ) ;        // Failure
     }
     mqttpub.trigger ( MQTT_IP ) ;                         // Publish own IP
   }
   else
   {
-    dbgprint ( "MQTT connection failed, rc=%d",
+    ESP_LOGE ( TAG, "MQTT connection failed, rc=%d",
                mqttclient.state() ) ;
 
   }
@@ -2109,9 +2046,9 @@ void onMqttMessage ( char* topic, byte* payload, unsigned int len )
     }
     strncpy ( cmd, (char*)payload, len ) ;            // Make copy of message
     cmd[len] = '\0' ;                                 // Take care of delimeter
-    dbgprint ( "MQTT message arrived [%s], lenght = %d, %s", topic, len, cmd ) ;
+    ESP_LOGI ( TAG, "MQTT message arrived [%s], lenght = %d, %s", topic, len, cmd ) ;
     reply = analyzeCmd ( cmd ) ;                      // Analyze command and handle it
-    dbgprint ( reply ) ;                              // Result for debugging
+    ESP_LOGI ( TAG, "%s", reply ) ;                   // Result for debugging
   }
 }
 
@@ -2139,7 +2076,7 @@ void scanserial()
       {
         strncpy ( cmd, serialcmd.c_str(), sizeof(cmd) ) ;
         reply = analyzeCmd ( cmd ) ;             // Analyze command and handle it
-        dbgprint ( reply ) ;                     // Result for debugging
+        log_printf ( "%s", reply ) ;             // Result for debugging
         serialcmd = "" ;                         // Prepare for new command
       }
     }
@@ -2184,12 +2121,12 @@ void scanserial2()
         if ( len )
         {
           strncpy ( cmd, serialcmd.c_str(), sizeof(cmd) ) ;
-          dbgprint ( "NEXTION command seen %02X %s",
+          ESP_LOGI ( TAG, "NEXTION command seen %02X %s",
                      cmd[0], cmd + 1 ) ;
           if ( cmd[0] == 0x70 )                    // Button pressed?
           { 
             reply = analyzeCmd ( cmd + 1 ) ;       // Analyze command and handle it
-            dbgprint ( reply ) ;                   // Result for debugging
+            ESP_LOGI ( TAG, "%s", reply ) ;        // Result for debugging
           }
           serialcmd = "" ;                         // Prepare for new command
         }
@@ -2242,10 +2179,10 @@ void  scandigital()
       progpin[i].cur = level ;                              // And the new level
       if ( !level )                                         // HIGH to LOW change?
       {
-        dbgprint ( "GPIO_%02d is now LOW, execute %s",
+        ESP_LOGI ( TAG, "GPIO_%02d is now LOW, execute %s",
                    pinnr, progpin[i].command.c_str() ) ;
         reply = analyzeCmd ( progpin[i].command.c_str() ) ; // Analyze command and handle it
-        dbgprint ( reply ) ;                                // Result for debugging
+        ESP_LOGI ( TAG, "%s", reply ) ;                     // Result for debugging
       }
     }
   }
@@ -2274,11 +2211,11 @@ void  scandigital()
       touchpin[i].cur = level ;                             // And the new level
       if ( !level )                                         // HIGH to LOW change?
       {
-        dbgprint ( "TOUCH_%02d is now %d ( < %d ), execute %s",
+        ESP_LOGI ( TAG, "TOUCH_%02d is now %d ( < %d ), execute %s",
                    pinnr, tlevel, THRESHOLD,
                    touchpin[i].command.c_str() ) ;
         reply = analyzeCmd ( touchpin[i].command.c_str() ); // Analyze command and handle it
-        dbgprint ( reply ) ;                                // Result for debugging
+        ESP_LOGI ( TAG, "%s", reply ) ;                     // Result for debugging
       }
     }
   }
@@ -2302,14 +2239,14 @@ void scanIR()
     if ( nvssearch ( mykey ) )
     {
       val = nvsgetstr ( mykey ) ;                           // Get the contents
-      dbgprint ( "IR code %04X received. Will execute %s",
+      ESP_LOGI ( TAG, "IR code %04X received. Will execute %s",
                  ir_value, val.c_str() ) ;
       reply = analyzeCmd ( val.c_str() ) ;                  // Analyze command and handle it
-      dbgprint ( reply ) ;                                  // Result for debugging
+      ESP_LOGI ( TAG, "%s", reply ) ;                       // Result for debugging
     }
     else
     {
-      dbgprint ( "IR code %04X received, but not found in preferences!  Timing %d/%d",
+      ESP_LOGI ( TAG, "IR code %04X received, but not found in preferences!  Timing %d/%d",
                  ir_value, ir_0, ir_1 ) ;
     }
     ir_value = 0 ;                                          // Reset IR code received
@@ -2321,12 +2258,9 @@ void scanIR()
 //**************************************************************************************************
 //                                           M K _ L S A N                                         *
 //**************************************************************************************************
-// Make al list of acceptable networks in preferences.                                             *
+// Make al list of all WiFi networks in preferences and FIXEDWIFI.                                 *
 // Will be called only once by setup().                                                            *
-// The result will be stored in wifilist.                                                          *
-// Not that the last found SSID and password are kept in common data.  If only one SSID is         *
-// defined, the connect is made without using wifiMulti.  In this case a connection will           *
-// be made even if de SSID is hidden.                                                              *
+// The networks will be added to wifiMulti.                                                        *
 //**************************************************************************************************
 void  mk_lsan()
 {
@@ -2337,7 +2271,7 @@ void  mk_lsan()
   int         inx ;                                      // Place of "/"
   WifiInfo_t  winfo ;                                    // Element to store in list
 
-  dbgprint ( "Create list with acceptable WiFi networks" ) ;
+  ESP_LOGI ( TAG, "Create list with acceptable WiFi networks" ) ;
   for ( i = -1 ; i < 100 ; i++ )                         // Examine FIXEDWIFI, wifi_00 .. wifi_99
   {
     buf = String ( "" ) ;                                // Clear buffer with ssid/passwd
@@ -2361,13 +2295,8 @@ void  mk_lsan()
     {
       lpw = buf.substring ( inx + 1 ) ;                  // Isolate password
       lssid = buf.substring ( 0, inx ) ;                 // Holds SSID now
-      winfo.ssid = strdup ( lssid.c_str() ) ;            // Set ssid of new element for wifilist
-      winfo.passphrase = strdup ( lpw.c_str() ) ;
-      wifilist.push_back ( winfo ) ;                     // Add to list
-      wifiMulti.addAP ( winfo.ssid,                      // Add to wifi acceptable network list
-                        winfo.passphrase ) ;
-      dbgprint ( "Added %s to list of networks",
-                  lssid.c_str() ) ;
+      wifiMulti.addAP ( lssid.c_str(),                   // Add to wifi acceptable network list
+                        lpw.c_str() ) ;
     }
   }
 }
@@ -2415,61 +2344,6 @@ void tftlog ( const char *str, bool newline )
 }
 
 
-//**************************************************************************************************
-//                                   F I N D N S I D                                               *
-//**************************************************************************************************
-// Find the namespace ID for the namespace passed as parameter.                                    *
-//**************************************************************************************************
-uint8_t FindNsID ( const char* ns )
-{
-  esp_err_t                 result = ESP_OK ;                 // Result of reading partition
-  uint32_t                  offset = 0 ;                      // Offset in nvs partition
-  uint8_t                   i ;                               // Index in Entry 0..125
-  uint8_t                   bm ;                              // Bitmap for an entry
-  uint8_t                   res = 0xFF ;                      // Function result
-
-  while ( offset < nvs->size )
-  {
-    result = esp_partition_read ( nvs, offset,                // Read 1 page in nvs partition
-                                  &nvsbuf,
-                                  sizeof(nvsbuf) ) ;
-    if ( result != ESP_OK )
-    {
-      dbgprint ( "Error reading NVS!" ) ;
-      break ;
-    }
-    i = 0 ;
-    while ( i < 126 )
-    {
-
-      bm = ( nvsbuf.Bitmap[i / 4] >> ( ( i % 4 ) * 2 ) ) ;    // Get bitmap for this entry,
-      bm &= 0x03 ;                                            // 2 bits for one entry
-      if ( ( bm == 2 ) &&
-           ( nvsbuf.Entry[i].Ns == 0 ) &&
-           ( strcmp ( ns, nvsbuf.Entry[i].Key ) == 0 ) )
-      {
-        res = nvsbuf.Entry[i].Data & 0xFF ;                   // Return the ID
-        offset = nvs->size ;                                  // Stop outer loop as well
-        break ;
-      }
-      else
-      {
-        if ( bm == 2 )
-        {
-          i += nvsbuf.Entry[i].Span ;                         // Next entry
-        }
-        else
-        {
-          i++ ;
-        }
-      }
-    }
-    offset += sizeof(nvs_page) ;                              // Prepare to read next page in nvs
-  }
-  return res ;
-}
-
-
 //**************************************************************************************************
 //                            B U B B L E S O R T K E Y S                                          *
 //**************************************************************************************************
@@ -2478,11 +2352,11 @@ uint8_t FindNsID ( const char* ns )
 void bubbleSortKeys ( uint16_t n )
 {
   uint16_t i, j ;                                             // Indexes in nvskeys
-  char     tmpstr[16] ;                                       // Temp. storage for a key
+  char     tmpstr[NVS_KEY_NAME_MAX_SIZE] ;                    // Temp. storage for a key
 
   for ( i = 0 ; i < n - 1 ; i++ )                             // Examine all keys
   {
-    for ( j = 0 ; j < n - i - 1 ; j++ )                       // Compare to following keys
+    for ( j = 0 ; j < n - i - 1 ; j++ )                       // Compare to next keys
     {
       if ( strcmp ( nvskeys[j], nvskeys[j + 1] ) > 0 )        // Next key out of order?
       {
@@ -2503,49 +2377,29 @@ void bubbleSortKeys ( uint16_t n )
 //**************************************************************************************************
 void fillkeylist()
 {
-  esp_err_t    result = ESP_OK ;                                // Result of reading partition
-  uint32_t     offset = 0 ;                                     // Offset in nvs partition
-  uint16_t     i ;                                              // Index in Entry 0..125.
-  uint8_t      bm ;                                             // Bitmap for an entry
-  uint16_t     nvsinx = 0 ;                                     // Index in nvskey table
+  nvs_iterator_t   it ;                                         // Iterator for NVS
+  nvs_entry_info_t info ;                                       // Info in entry
+  uint16_t         nvsinx = 0 ;                                 // Index in nvskey table
 
-  keynames.clear() ;                                            // Clear the list
-  while ( offset < nvs->size )
+  it = nvs_entry_find ( "nvs", NAME, NVS_TYPE_ANY ) ;           // Get first entry
+  while ( it )
   {
-    result = esp_partition_read ( nvs, offset,                  // Read 1 page in nvs partition
-                                  &nvsbuf,
-                                  sizeof(nvsbuf) ) ;
-    if ( result != ESP_OK )
+    nvs_entry_info ( it, &info ) ;                              // Get info on this entry
+    ESP_LOGI ( TAG, "%s::%s type=%d",
+               info.namespace_name, info.key, info.type ) ;
+    if ( info.type == NVS_TYPE_STR )                            // Only string are used
     {
-      dbgprint ( "Error reading NVS!" ) ;
-      break ;
-    }
-    i = 0 ;
-    while ( i < 126 )
-    {
-      bm = ( nvsbuf.Bitmap[i / 4] >> ( ( i % 4 ) * 2 ) ) ;      // Get bitmap for this entry,
-      bm &= 0x03 ;                                              // 2 bits for one entry
-      if ( bm == 2 )                                            // Entry is active?
+      strcpy ( nvskeys[nvsinx], info.key ) ;                    // Save key in table
+      if ( ++nvsinx == MAXKEYS )
       {
-        if ( nvsbuf.Entry[i].Ns == namespace_ID )               // Namespace right?
-        {
-          strcpy ( nvskeys[nvsinx], nvsbuf.Entry[i].Key ) ;     // Yes, save in table
-          if ( ++nvsinx == MAXKEYS )
-          {
-            nvsinx-- ;                                          // Prevent excessive index
-          }
-        }
-        i += nvsbuf.Entry[i].Span ;                             // Next entry
-      }
-      else
-      {
-        i++ ;
+        nvsinx-- ;                                              // Prevent excessive index
       }
     }
-    offset += sizeof(nvs_page) ;                                // Prepare to read next page in nvs
+    it = nvs_entry_next ( it ) ;
   }
+  nvs_release_iterator ( it ) ;                                 // Release resource
   nvskeys[nvsinx][0] = '\0' ;                                   // Empty key at the end
-  dbgprint ( "Read %d keys from NVS", nvsinx ) ;
+  ESP_LOGI ( TAG, "Read %d keys from NVS", nvsinx ) ;
   bubbleSortKeys ( nvsinx ) ;                                   // Sort the keys
 }
 
@@ -2555,17 +2409,20 @@ void fillkeylist()
 //**************************************************************************************************
 // Event callback on received data from MP3/AAC host.                                              *
 // It is assumed that the first data buffer contains the full header.                              *
+// Normally, the data length is 1436 bytes.                                                        *
 //**************************************************************************************************
 void handleData ( void* arg, AsyncClient* client, void *data, size_t len )
 {
   uint8_t* p = (uint8_t*)data ;                         // Treat as an array of bytes
 
+  // ESP_LOGI ( TAG, "Data received, %d bytes", len ) ;
   while ( len-- )
   {
     handlebyte_ch ( *p++ ) ;                            // Handle next byte
   }
 }
 
+
 //**************************************************************************************************
 //                                  O N T I M E O U T                                              *
 //**************************************************************************************************
@@ -2573,7 +2430,7 @@ void handleData ( void* arg, AsyncClient* client, void *data, size_t len )
 //**************************************************************************************************
 void onTimeout ( void* arg, AsyncClient* client, uint32_t t )
 {
-  dbgprint ( "MP3 client connect time-out!" ) ;
+  ESP_LOGE ( TAG, "MP3 client connect time-out!" ) ;
 }
 
 
@@ -2584,7 +2441,7 @@ void onTimeout ( void* arg, AsyncClient* client, uint32_t t )
 //**************************************************************************************************
 void onError ( void* arg, AsyncClient* client, err_t a )
 {
-  dbgprint ( "MP3 host error %s", client->errorToString ( a ) ) ;
+  ESP_LOGI ( TAG, "MP3 host error %s", client->errorToString ( a ) ) ;
 }
 
 
@@ -2595,7 +2452,7 @@ void onError ( void* arg, AsyncClient* client, err_t a )
 //**************************************************************************************************
 void onConnect ( void* arg, AsyncClient* client )
 {
-  dbgprint ( "Connected to host at %s on port %d",
+  ESP_LOGI ( TAG, "Connected to host at %s on port %d",
              client->remoteIP().toString().c_str(),
              client->remotePort() ) ;
 }
@@ -2608,7 +2465,7 @@ void onConnect ( void* arg, AsyncClient* client )
 //**************************************************************************************************
 void onDisConnect ( void* arg, AsyncClient* client )
 {
-  dbgprint ( "Host disconnected" ) ;
+  ESP_LOGI ( TAG, "Host disconnected" ) ;
 }
 
 
@@ -2619,44 +2476,56 @@ void onDisConnect ( void* arg, AsyncClient* client )
 //**************************************************************************************************
 void setup()
 {
-  int                        i ;                         // Loop control
-  int                        pinnr ;                     // Input pinnumber
+  int                        i ;                          // Loop control
+  int                        pinnr ;                      // Input pinnumber
   const char*                p ;
-  byte                       mac[6] ;                    // WiFi mac address
-  char                       tmpstr[20] ;                // For version and Mac address
-  esp_partition_iterator_t   pi ;                        // Iterator for find
-  const esp_partition_t*     ps ;                        // Pointer to partition struct
-
-  maintask = xTaskGetCurrentTaskHandle() ;               // My taskhandle
-  delay ( 3000 ) ;                                       // Wait for PlatformIO monitor to start
-  Serial.begin ( 115200 ) ;                              // For debug
-  Serial.println() ;
+  byte                       mac[6] ;                     // WiFi mac address
+  char                       tmpstr[20] ;                 // For version and Mac address
+  esp_partition_iterator_t   pi ;                         // Iterator for find
+  const esp_partition_t*     ps ;                         // Pointer to partition struct
+
+  maintask = xTaskGetCurrentTaskHandle() ;                // My taskhandle
+  outchunk.datatyp = QDATA ;                              // This chunk dedicated to QDATA
+  vTaskDelay ( 3000 / portTICK_PERIOD_MS ) ;              // Wait for PlatformIO monitor to start
+  Serial.begin ( 115200 ) ;                               // For debug
+  WRITE_PERI_REG ( RTC_CNTL_BROWN_OUT_REG, 0 ) ;          // Disable brownout detector
+  log_printf ( "\n" ) ;
   // Print some memory and sketch info
-  dbgprint ( "Starting ESP32-radio running on CPU %d at %d MHz.",
+  log_printf ( "Starting ESP32-radio running on CPU %d at %d MHz.\n",
              xPortGetCoreID(),
              ESP.getCpuFreqMHz() ) ;
-  dbgprint ( "Version %s.  Free memory %d",
+  ESP_LOGI ( TAG, "Version %s.  Free memory %d",
              VERSION,
-             heapspace ) ;                               // Normally about 100 kB
-  dbgprint ( "Display type is %s", DISPLAYTYPE ) ;       // Report display option
+             heapspace ) ;                                // Normally about 100 kB
+  ESP_LOGI ( TAG, "Display type is %s", DISPLAYTYPE ) ;   // Report display option
   
-  if ( !SPIFFS.begin ( FSIF ) )                          // Mount and test SPIFFS
+  if ( !SPIFFS.begin ( FSIF ) )                           // Mount and test SPIFFS
   {
-    dbgprint ( "SPIFFS Mount Error!" ) ;                 // A pity...
+    ESP_LOGE ( TAG, "SPIFFS Mount Error!" ) ;             // A pity...
   }
   else
   {
-    dbgprint ( "SPIFFS is okay, space %d, used %d",      // Show available SPIFFS space
+    ESP_LOGI ( TAG, "SPIFFS is okay, space %d, used %d",  // Show available SPIFFS space
                SPIFFS.totalBytes(),
                SPIFFS.usedBytes() ) ;
+    File index_html = SPIFFS.open ( "/index.html",        // Try to read from SPIFFS file
+                                    FILE_READ ) ;
+    if ( index_html )                                     // Open success?
+    {
+      index_html.close() ;                                // Yes, close file
+    }
+    else
+    {
+      ESP_LOGE ( TAG, "Web interface incomplete!" ) ;          // No, show warning, upload data to SPIFFS
+    }
   }
   pi = esp_partition_find ( ESP_PARTITION_TYPE_DATA,     // Get partition iterator for
                             ESP_PARTITION_SUBTYPE_ANY,   // All data partitions
                             NULL ) ;
   while ( pi )
   {
-    ps = esp_partition_get ( pi ) ;                      // Get partition struct
-    dbgprint ( "Found partition '%-8.8s' "               // Show partition
+    ps = esp_partition_get ( pi ) ;                       // Get partition struct
+    ESP_LOGI ( TAG, "Found partition '%-8s' "             // Show partition
                "at offset 0x%06X "
                "with size %8d",
                ps->label, ps->address, ps->size ) ;
@@ -2664,10 +2533,6 @@ void setup()
     {
       nvs = ps ;                                         // Yes, remember NVS partition
     }
-    else if ( strcmp ( ps->label, "spiffs" ) == 0 )      // Is this the SPIFFS partition?
-    {
-      spiffs = ps ;                                      // Yes, remember SPIFFS partition
-    }
     pi = esp_partition_next ( pi ) ;                     // Find next
   }
   #ifdef FIXEDWIFI                                       // Set fixedwifi if defined
@@ -2675,16 +2540,9 @@ void setup()
   #endif
   if ( nvs == NULL )
   {
-    dbgprint ( "Partition NVS not found!" ) ;            // Very unlikely...
-    while ( true ) ;                                     // Impossible to continue
-  }
-  if ( spiffs == NULL )
-  {
-    dbgprint ( "Partition spiffs not found!" ) ;         // Very unlikely...
+    ESP_LOGE ( TAG, "Partition NVS not found!" ) ;       // Very unlikely...
     while ( true ) ;                                     // Impossible to continue
   }
-  SPIsem = xSemaphoreCreateMutex(); ;                    // Semaphore for SPI bus
-  namespace_ID = FindNsID ( NAME ) ;                     // Find ID of our namespace in NVS
   fillkeylist() ;                                        // Fill keynames with all keys
   memset ( &ini_block, 0, sizeof(ini_block) ) ;          // Init ini_block
   ini_block.mqttport = 1883 ;                            // Default port for MQTT
@@ -2692,14 +2550,14 @@ void setup()
   ini_block.clk_server = "pool.ntp.org" ;                // Default server for NTP
   ini_block.clk_offset = 1 ;                             // Default Amsterdam time zone
   ini_block.clk_dst = 1 ;                                // DST is +1 hour
-  ini_block.bat0 = 0 ;                                   // Battery ADC levels not yet defined
-  ini_block.bat100 = 0 ;
+  ini_block.bat0 = 2600 ;                                // Battery ADC level for 0 percent
+  ini_block.bat100 = 2950 ;                              // Battery ADC level for 100 percent
   readIOprefs() ;                                        // Read pins used for SPI, TFT, VS1053, IR,
                                                          // Rotary encoder
   for ( i = 0 ; (pinnr = progpin[i].gpio) >= 0 ; i++ )   // Check programmable input pins
   {
     pinMode ( pinnr, INPUT_PULLUP ) ;                    // Input for control button
-    delay ( 10 ) ;
+    vTaskDelay ( 10 / portTICK_PERIOD_MS ) ;
     // Check if pull-up active
     if ( ( progpin[i].cur = digitalRead ( pinnr ) ) == HIGH )
     {
@@ -2709,7 +2567,7 @@ void setup()
     {
       p = "LOW, probably no PULL-UP" ;                   // No Pull-up
     }
-    dbgprint ( "GPIO%d is %s", pinnr, p ) ;
+    ESP_LOGI ( TAG, "GPIO%d is %s", pinnr, p ) ;
   }
   readprogbuttons() ;                                    // Program the free input pins
   if ( ini_block.spi_sck_pin >= 0 )
@@ -2720,20 +2578,20 @@ void setup()
   }
   if ( ini_block.ir_pin >= 0 )
   {
-    dbgprint ( "Enable pin %d for IR",
+    ESP_LOGI ( TAG, "Enable pin %d for IR",
                ini_block.ir_pin ) ;
     pinMode ( ini_block.ir_pin, INPUT ) ;                // Pin for IR receiver VS1838B
     attachInterrupt ( ini_block.ir_pin,                  // Interrupts will be handle by isr_IR
                       isr_IR, CHANGE ) ;
   }
-  dbgprint ( "Start %s display", DISPLAYTYPE ) ;
+  ESP_LOGI ( TAG, "Start %s display", DISPLAYTYPE ) ;
   dsp_ok = dsp_begin ( INIPARS ) ;                       // Init display
   if ( dsp_ok )                                          // Init okay?
   {
-    dsp_setRotation() ;                                  // Yes, use landscape format
     dsp_erase() ;                                        // Clear screen
+    dsp_setRotation() ;                                  // Usse landscape format
     dsp_setTextSize ( DEFTXTSIZ ) ;                      // Small character font
-    dsp_setTextColor ( GRAY ) ;                          // Info in grey
+    dsp_setTextColor ( GREY ) ;                          // Info in grey
     dsp_setCursor ( 0, 0 ) ;                             // Top of screen
     dsp_println ( "Starting......" ) ;
     strncpy ( tmpstr, VERSION, 16 ) ;                    // Limit version length
@@ -2741,6 +2599,10 @@ void setup()
     dsp_println ( "By Ed Smallenburg" ) ;
     dsp_update ( enc_menu_mode == VOLUME ) ;             // Show on physical screen if needed
   }
+  else
+  {
+    ESP_LOGE ( TAG, "Display not activated" ) ;          // Display init error
+  }
   if ( ini_block.tft_bl_pin >= 0 )                       // Backlight for TFT control?
   {
     pinMode ( ini_block.tft_bl_pin, OUTPUT ) ;           // Yes, enable output
@@ -2754,47 +2616,40 @@ void setup()
     mk_lsan() ;                                          // Make a list of acceptable networks
                                                          // in preferences.
     WiFi.disconnect() ;                                  // After restart router could still
-    delay ( 500 ) ;                                      // keep old connection
+    vTaskDelay ( 500 / portTICK_PERIOD_MS ) ;            //   keep old connection
     WiFi.mode ( WIFI_STA ) ;                             // This ESP is a station
-    delay ( 500 ) ;                                      // ??
+    // WiFi.setSleep (false ) ;                          // should prevent _poll(): pcb is NULL""error"
+    vTaskDelay ( 500 / portTICK_PERIOD_MS ) ;            // ??
     WiFi.persistent ( false ) ;                          // Do not save SSID and password
-    listNetworks() ;                                     // Find WiFi networks
   #endif
   readprefs ( false ) ;                                  // Read preferences
   radioqueue = xQueueCreate ( 10,                        // Create small queue for communication to radiofuncs
                              sizeof ( qdata_type ) ) ;
-  dataqueue = xQueueCreate ( QSIZ,                       // Create queue for communication
+  dataqueue = xQueueCreate  ( QSIZ,                      // Create queue for data communication
                              sizeof ( qdata_struct ) ) ;
-  #if defined(DEC_VS1053) || defined(DEC_VS1003)
-    VS1053_begin ( ini_block.vs_cs_pin,                  // Make instance of player and initialize
-                   ini_block.vs_dcs_pin,
-                   ini_block.vs_dreq_pin,
-                   ini_block.shutdown_pin,
-                   ini_block.shutdownx_pin ) ;
-  #endif
   p = "Connect to network" ;                             // Show progress
-  dbgprint ( p ) ;
+  ESP_LOGI ( TAG, "%s", p ) ;
   tftlog ( p, true ) ;                                   // On TFT too
   #ifdef ETHERNET
-    WiFi.onEvent ( EthEvent ) ;                             // Set actions on ETH events
+    WiFi.onEvent ( EthEvent ) ;                          // Set actions on ETH events
     NetworkFound = connectETH() ;                        // Connect to Ethernet
   #else
     NetworkFound = connectwifi() ;                       // Connect to WiFi network
   #endif
   tcpip_adapter_set_hostname ( TCPIP_ADAPTER_IF_STA,
                                NAME ) ;
-  dbgprint ( "Start web server" ) ;
+  ESP_LOGI ( TAG, "Start web server" ) ;
   cmdserver.on ( "/getprefs",  handle_getprefs ) ;       // Handle get preferences
   cmdserver.on ( "/saveprefs", handle_saveprefs ) ;      // Handle save preferences
   cmdserver.on ( "/getdefs",   handle_getdefs ) ;        // Handle get default config
   cmdserver.on ( "/settings",  handle_settings ) ;       // Handle strings like presets/volume,...
   cmdserver.on ( "/mp3list",   handle_mp3list ) ;        // Handle request for list of tracks
+  cmdserver.on ( "/reset",     handle_reset ) ;          // Handle reset command
   cmdserver.onNotFound ( handle_notfound ) ;             // For handling a simple page/file and parameters
   cmdserver.begin() ;                                    // Start http server
   if ( NetworkFound )                                    // OTA and MQTT only if Wifi network found
   {
-    dbgprint ( "Network found. Starting mp3 client,"
-               " mqtt and OTA" ) ;
+    ESP_LOGI ( TAG, "Network found. Starting clients" ) ;
     mp3client = new AsyncClient ;                        // Create client for Shoutcast connection
     mp3client->onData ( &handleData ) ;                  // Set callback on received mp3 data
     mp3client->onConnect ( &onConnect ) ;                // Set callback on connect
@@ -2803,7 +2658,12 @@ void setup()
     mp3client->onTimeout ( &onTimeout ) ;                // Set callback on time-out
     mqtt_on = ( ini_block.mqttbroker.length() > 0 ) &&   // Use MQTT if broker specified
               ( ini_block.mqttbroker != "none" ) ;
-    otaInit() ;                                          // Int OTA handling (if enabled)
+    #ifdef ENABLEOTA
+      ArduinoOTA.setHostname ( NAME ) ;                  // Set the hostname
+      ArduinoOTA.onStart ( otastart ) ;
+      ArduinoOTA.onError ( otaerror ) ;
+      ArduinoOTA.begin() ;                               // Allow update over the air
+    #endif
     if ( mqtt_on )                                       // Broker specified?
     {
       if ( ( ini_block.mqttprefix.length() == 0 ) ||     // No prefix?
@@ -2815,26 +2675,26 @@ void setup()
                   mac[1], mac[0] ) ;
         ini_block.mqttprefix = String ( tmpstr ) ;       // Save for further use
       }
-      dbgprint ( "MQTT uses prefix %s", ini_block.mqttprefix.c_str() ) ;
-      dbgprint ( "Init MQTT" ) ;
+      ESP_LOGI ( TAG, "MQTT uses prefix %s", ini_block.mqttprefix.c_str() ) ;
+      ESP_LOGI ( TAG, "Init MQTT" ) ;
       mqttclient.setServer(ini_block.mqttbroker.c_str(), // Specify the broker
                            ini_block.mqttport ) ;        // And the port
       mqttclient.setCallback ( onMqttMessage ) ;         // Set callback on receive
     }
     if ( MDNS.begin ( NAME ) )                           // Start MDNS transponder
     {
-      dbgprint ( "MDNS responder started" ) ;
+      ESP_LOGI ( TAG, "MDNS responder started" ) ;
     }
     else
     {
-      dbgprint ( "Error setting up MDNS responder!" ) ;
+      ESP_LOGE ( TAG, "Error setting up MDNS responder!" ) ;
     }
   }
   timer = timerBegin ( 0, 80, true ) ;                   // User 1st timer with prescaler 80
   timerAttachInterrupt ( timer, &timer100, false ) ;     // Call timer100() on timer alarm
   timerAlarmWrite ( timer, 100000, true ) ;              // Alarm every 100 msec
   timerAlarmEnable ( timer ) ;                           // Enable the timer
-  delay ( 1000 ) ;                                       // Show IP for a while
+  vTaskDelay ( 1000 / portTICK_PERIOD_MS ) ;             // Show IP for a while
   configTime ( ini_block.clk_offset * 3600,
                ini_block.clk_dst * 3600,
                ini_block.clk_server.c_str() ) ;          // GMT offset, daylight offset in seconds
@@ -2846,11 +2706,11 @@ void setup()
       attachInterrupt ( ini_block.enc_up_pin,  isr_enc_turn,   CHANGE ) ;
       attachInterrupt ( ini_block.enc_dwn_pin, isr_enc_turn,   CHANGE ) ;
       attachInterrupt ( ini_block.enc_sw_pin,  isr_enc_switch, CHANGE ) ;
-      dbgprint ( "ZIPPY side switch is enabled" ) ;
+      ESP_LOGI ( TAG, "ZIPPY side switch is enabled" ) ;
     }
     else
     {
-      dbgprint ( "ZIPPY side switch is disabled (%d/%d/%d)",
+      ESP_LOGI ( TAG, "ZIPPY side switch is disabled (%d/%d/%d)",
                 ini_block.enc_up_pin,
                 ini_block.enc_dwn_pin,
                 ini_block.enc_sw_pin ) ;
@@ -2861,30 +2721,38 @@ void setup()
       attachInterrupt ( ini_block.enc_clk_pin, isr_enc_turn,   CHANGE ) ;
       attachInterrupt ( ini_block.enc_dt_pin,  isr_enc_turn,   CHANGE ) ;
       attachInterrupt ( ini_block.enc_sw_pin,  isr_enc_switch, CHANGE ) ;
-      dbgprint ( "Rotary encoder is enabled" ) ;
+      ESP_LOGI ( TAG, "Rotary encoder is enabled" ) ;
     }
     else
     {
-      dbgprint ( "Rotary encoder is disabled (%d/%d/%d)",
+      ESP_LOGI ( TAG, "Rotary encoder is disabled (%d/%d/%d)",
                 ini_block.enc_clk_pin,
                 ini_block.enc_dt_pin,
                 ini_block.enc_sw_pin ) ;
     }
   #endif
-if ( NetworkFound )
+  if ( NetworkFound )
   {
     gettime() ;                                           // Sync time
   }
-  outchunk.datatyp = QDATA ;                              // This chunk dedicated to QDATA
   adc1_config_width ( ADC_WIDTH_12Bit ) ;
-  adc1_config_channel_atten ( ADC1_CHANNEL_0, ADC_ATTEN_0db ) ;
+  adc1_config_channel_atten ( ADC1_CHANNEL_0, ADC_ATTEN_DB_12 ) ;  // VP/GPIO36 (ESP32), GPIO1 (ESP32-S3)
+  xTaskCreatePinnedToCore (
+    playtask,                                             // Task to play data in dataqueue.
+    "Playtask",                                           // Name of task.
+    2100,                                                 // Stack size of task
+    NULL,                                                 // parameter of the task
+    2,                                                    // priority of the task
+    &xplaytask,                                           // Task handle to keep track of created task
+    0 ) ;                                                 // Run on CPU 0
+  vTaskDelay ( 100 / portTICK_PERIOD_MS ) ;               // Allow playtask to start
 #ifdef SDCARD
   sdqueue = xQueueCreate ( 10,                            // Create small queue for communication to sdfuncs
                            sizeof ( qdata_type ) ) ;
   xTaskCreatePinnedToCore (
     SDtask,                                               // Task to get filenames from SD card
     "SDtask",                                             // Name of task.
-    3500,                                                 // Stack size of task
+    4000,                                                 // Stack size of task
     NULL,                                                 // parameter of the task
     2,                                                    // priority of the task
     &xsdtask,                                             // Task handle to keep track of created task
@@ -2893,27 +2761,22 @@ if ( NetworkFound )
   singleclick = false ;                                   // Might be fantom click
   if ( dsp_ok )                                           // Is display okay?
   {
-    delay ( 2000 ) ;                                      // Yes, allow user to read display text
+    vTaskDelay ( 2000 / portTICK_PERIOD_MS ) ;            // Yes, allow user to read display text
     dsp_erase() ;                                         // Clear screen
   }
   tftset ( 0, NAME ) ;                                    // Set screen segment text top line
   presetinfo.station_state = ST_PRESET ;                  // Start in preset mode
-  nextPreset ( nvsgetstr ( "preset" ).toInt(), false  ) ; // Restore last preset
-  xTaskCreatePinnedToCore (
-    playtask,                                             // Task to play data in dataqueue.
-    "Playtask",                                           // Name of task.
-    2000,                                                 // Stack size of task
-    NULL,                                                 // parameter of the task
-    2,                                                    // priority of the task
-    &xplaytask,                                           // Task handle to keep track of created task
-    0 ) ;                                                 // Run on CPU 0
-  delay ( 100 ) ;                                         // Allow playtask to start
-  if ( NetworkFound )                                     // Start with preset if network available
+  if ( nextPreset ( nvsgetstr ( "preset" ).toInt(),       // Restore last preset
+       false  ) )
   {
-    myQueueSend ( radioqueue, &startcmd ) ;               // Start player in radio mode
+    if ( NetworkFound )                                     // Start with preset if network available
+    {
+      myQueueSend ( radioqueue, &startcmd ) ;               // Start player in radio mode
+    }
   }
 }
 
+
 //**************************************************************************************************
 //                                        W R I T E P R E F S                                      *
 //**************************************************************************************************
@@ -2930,7 +2793,7 @@ void writeprefs ( AsyncWebServerRequest *request )
   //timerAlarmDisable ( timer ) ;                 // Disable the timer
   nvsclear() ;                                    // Remove all preferences
   numargs = request->params() ;                   // Haal aantal parameters
-  dbgprint ( "writeprefs numargs is %d",
+  ESP_LOGI ( TAG, "writeprefs numargs is %d",
              numargs ) ;
   for ( i = 0 ; i < numargs ; i++ )               // Scan de parameters
   {
@@ -2947,7 +2810,7 @@ void writeprefs ( AsyncWebServerRequest *request )
     {
       continue ;
     }
-    dbgprint ( "Handle POST %s = %s",
+    ESP_LOGI ( TAG, "Handle POST %s = %s",
                key.c_str(), contents.c_str() ) ;  // Toon POST parameter
     nvssetstr ( key.c_str(), contents ) ;         // Save new pair
   }
@@ -2958,7 +2821,6 @@ void writeprefs ( AsyncWebServerRequest *request )
 
 
 #ifdef SDCARD
-#ifdef bla
 //**************************************************************************************************
 //                                        C B  _ M P 3 L I S T                                     *
 //**************************************************************************************************
@@ -2966,52 +2828,6 @@ void writeprefs ( AsyncWebServerRequest *request )
 // If no more data is available, this function will return 0.                                      *
 //**************************************************************************************************
 size_t cb_mp3list ( uint8_t *buffer, size_t maxLen, size_t index )
-{
-  static int         i ;                              // Index in track list
-  static const char* path ;                           // Pointer in file path
-  size_t             len = 0 ;                        // Number of bytes filled in buffer
-  char*              p = (char*)buffer ;              // Treat as pointer to aray of char
-
-  if ( index == 0 )                                   // First call for this page?
-  {
-    i = 0 ;                                           // Yes, set index (track number)
-    path = "" ;                                       // Force read of next path 
-  }
-  while ( maxLen > len )                              // Space for another char from path?
-  {
-    if ( *path )                                      // End of path?
-    {
-      *p++ = *path++ ;                                // No, add another character to send buffer
-    }
-    else
-    {
-      // End of path
-      if ( i )                                        // At least one path in output?
-      {
-        *p++ = '\n' ;                                 // Yes, add separator
-      }
-      if ( i >= SD_filecount )                        // Yes, beyond end of list?
-      {
-        //dbgprint ( "End of list" ) ;
-        break ;                                       // Yes, stop
-      }
-      path = getSDFileName ( i++ ) ;                  // Get next path from list
-    }
-    len++ ;                                           // Update total length
-  }
-  // We come here if output buffer is completely full or end of tracklist is reached
-  //dbgprint ( "i is %d/%d, len %d", i, SD_filecount, len ) ;
-  return len ;                                        // Return filled length of buffer
-}
-#endif
-//**************************************************************************************************
-//                                        C B  _ M P 3 L I S T                                     *
-//**************************************************************************************************
-// Callback function for handle_mp3list, will be called for every chunk to send to client.         *
-// If no more data is available, this function will return 0.                                      *
-// List is limited to 50 entries.                                                                  *
-//**************************************************************************************************
-size_t cb_mp3list ( uint8_t *buffer, size_t maxLen, size_t index )
 {
   static int         i ;                              // Index in track list
   static const char* path ;                           // Pointer in file path
@@ -3022,8 +2838,8 @@ size_t cb_mp3list ( uint8_t *buffer, size_t maxLen, size_t index )
   if ( index == 0 )                                   // First call for this page?
   {
     i = 0 ;                                           // Yes, set index (track number)
-    path = "" ;                                       // Force read of next path
-    eolSeen = false ;                                 // Not at end of list
+    path = getFirstSDFileName() ;                     // Force read of next path
+    eolSeen = ( path == nullptr ) ;                   // Any file?
   }
   while ( ( maxLen > len ) && ( ! eolSeen ) )         // Space for another char from path?
   {
@@ -3040,8 +2856,8 @@ size_t cb_mp3list ( uint8_t *buffer, size_t maxLen, size_t index )
         *p++ = '\n' ;                                 // Yes, add separator
         len++ ;                                       // Update total length
       }
-      path = getSDFileName ( +1 ) ;                   // Get next path from list
-      if ( ++i == 50 || *path == 0 )                  // No more files or enough files?
+      path = getSDFileName ( i++ ) ;                  // Get next path from list
+      if ( i >= SD_filecount )                        // No more files?
       {
         eolSeen = true ;                              // Yes, stop
         break ;
@@ -3075,10 +2891,11 @@ void handle_mp3list ( AsyncWebServerRequest *request )
 //**************************************************************************************************
 void handle_mp3list ( AsyncWebServerRequest *request )
 {
-  request->send ( 200, "text/plain", String ( "<empty>" ) ) ;
+  request->send ( 200, "text/plain", "<empty>" ) ;
 }
 #endif
 
+
 //**************************************************************************************************
 //                                    H A N D L E _ G E T P R E F S                                *
 //**************************************************************************************************
@@ -3104,7 +2921,7 @@ void handle_getprefs ( AsyncWebServerRequest *request )
 //**************************************************************************************************
 void handle_saveprefs ( AsyncWebServerRequest *request )
 {
-  String reply = "Config saved" ;                      // Default reply
+  const char* reply = "Config saved" ;                 // Default reply
 
   writeprefs ( request ) ;                             // Write to NVS
   request->send ( 200, "text/plain", reply ) ;         // Send the reply
@@ -3119,9 +2936,9 @@ void handle_saveprefs ( AsyncWebServerRequest *request )
 void handle_getdefs ( AsyncWebServerRequest *request )
 {
   String ct ;                                         // Content type
-  String path ;                                       // File with default settings
+  const char* path ;                                  // File with default settings
 
-  path = String ( "/defaultprefs.txt" ) ;             // Set file name
+  path = "/defaultprefs.txt" ;                        // Set file name
   if ( SPIFFS.exists ( path ) )                       // Does it exist in SPIFFS?
   {
     ct = getContentType ( path ) ;                    // Yes, get content type
@@ -3130,7 +2947,7 @@ void handle_getdefs ( AsyncWebServerRequest *request )
   else
   {
     request->send ( 200, "text/plain",                // No send empty preferences
-                    String ( "<empty>" ) ) ;
+                    "<empty>" ) ;
   }
 }
 
@@ -3158,7 +2975,7 @@ void handle_settings ( AsyncWebServerRequest *request )
         statstr = hsym ;                                 // Yes, use it
       }
       chomp ( statstr ) ;                                // Remove garbage from description
-      //dbgprint ( "statstr is %s", statstr.c_str() ) ;
+      //ESP_LOGI ( TAG, "statstr is %s", statstr.c_str() ) ;
       val += String ( "preset_" ) +
              String ( i ) +
              String ( "=" ) +
@@ -3200,6 +3017,18 @@ void handleSaveReq()
 }
 
 
+//**************************************************************************************************
+//                                    H A N D L E _ R E S E T                                      *
+//**************************************************************************************************
+// Called from config page to reset the radio.                                                     *
+//**************************************************************************************************
+void handle_reset ( AsyncWebServerRequest *request )
+{
+  request->send ( 200, "text/plain", "Command accepted"  ) ;         // Send the reply
+  resetreq = true ;                                                  // Set the reset request
+}
+
+
 //**************************************************************************************************
 //                                      H A N D L E I P P U B                                      *
 //**************************************************************************************************
@@ -3257,7 +3086,7 @@ void chk_enc()
     {
       enc_inactivity = 0 ;
       enc_menu_mode = VOLUME ;                                // Return to VOLUME mode
-      dbgprint ( "Encoder mode back to VOLUME" ) ;
+      ESP_LOGI ( TAG, "Encoder mode back to VOLUME" ) ;
     }
   }
   if ( singleclick || doubleclick ||                          // Any activity?
@@ -3272,29 +3101,29 @@ void chk_enc()
   }
   if ( tripleclick )                                          // First handle triple click
   {
-    dbgprint ( "Triple click" ) ;
+    ESP_LOGI ( TAG, "Triple click" ) ;
     tripleclick = false ;                                     // Reset flag
     #ifdef SDCARD
       if ( SD_filecount )                                     // Tracks on SD?
       {
         enc_menu_mode = TRACK ;                               // Swich to TRACK mode
-        dbgprint ( "Encoder mode set to TRACK" ) ;
+        ESP_LOGI ( TAG, "Encoder mode set to TRACK" ) ;
         tftset ( 3, "Turn to select track\n"                  // Show current option
                     "Press to confirm" ) ;
         getSDFileName ( +1 ) ;                                // Start with next file on SD
       }
       else
       {
-        dbgprint ( "No tracks on SD" ) ;
+        ESP_LOGI ( TAG, "No tracks on SD" ) ;
       }
     #endif
   }
   if ( doubleclick )                                          // Handle the doubleclick
   {
-    dbgprint ( "Double click") ;
+    ESP_LOGI ( TAG, "Double click") ;
     doubleclick = false ;
     enc_menu_mode = PRESET ;                                  // Swich to PRESET mode
-    dbgprint ( "Encoder mode set to PRESET" ) ;
+    ESP_LOGI ( TAG, "Encoder mode set to PRESET" ) ;
     tftset ( 3, "Turn to select station\n"                    // Show current option
                 "Press to confirm" ) ;
     enc_preset = presetinfo.preset ;                          // Start with current preset
@@ -3303,7 +3132,7 @@ void chk_enc()
   }
   if ( singleclick )
   {
-    dbgprint ( "Single click" ) ;
+    ESP_LOGI ( TAG, "Single click" ) ;
     singleclick = false ;
     switch ( enc_menu_mode )                                  // Which mode (VOLUME, PRESET)?
     {
@@ -3317,7 +3146,7 @@ void chk_enc()
           tftset ( 3, "Mute" ) ;
         }
         muteflag = !muteflag ;                                // Mute/unmute
-        dbgprint ( "Mute set to %d", muteflag ) ;
+        ESP_LOGI ( TAG, "Mute set to %d", muteflag ) ;
         break ;
       case PRESET :
         nextPreset ( enc_preset ) ;                           // Make a definite choice
@@ -3338,7 +3167,7 @@ void chk_enc()
   }
   if ( longclick )                                            // Check for long click
   {
-    dbgprint ( "Long click") ;
+    ESP_LOGI ( TAG, "Long click") ;
     myQueueSend ( sdqueue, &stopcmd ) ;                       // Stop player
     myQueueSend ( radioqueue, &stopcmd ) ;                    // Stop player
     //if ( datamode != STOPPED )
@@ -3360,24 +3189,26 @@ void chk_enc()
   {
     return ;                                                  // No, return
   }
-  //dbgprint ( "Rotation count %d", rotationcount ) ;
+  //ESP_LOGI ( TAG, "Rotation count %d", rotationcount ) ;
   switch ( enc_menu_mode )                                    // Which mode (VOLUME, PRESET, TRACK)?
   {
     case VOLUME :
-      rotationcount *= 4 ;                                    // Step by 4 percent
-      if ( ( ini_block.reqvol + rotationcount ) < 0 )         // Limit volume
+      if ( ! muteflag )                                       // Do not handle if muted
       {
-        ini_block.reqvol = 0 ;                                // Limit to normal values
-      }
-      else if ( ( ini_block.reqvol + rotationcount ) > 100 )
-      {
-        ini_block.reqvol = 100 ;                              // Limit to normal values
-      }
-      else
-      {
-        ini_block.reqvol += rotationcount ;
+        rotationcount *= 4 ;                                  // Step by 4 percent
+        if ( ( ini_block.reqvol + rotationcount ) < 0 )       // Limit volume
+        {
+          ini_block.reqvol = 0 ;                              // Limit to normal values
+        }
+        else if ( ( ini_block.reqvol + rotationcount ) > 100 )
+        {
+          ini_block.reqvol = 100 ;                            // Limit to normal values
+        }
+        else
+        {
+          ini_block.reqvol += rotationcount ;
+        }
       }
-      muteflag = false ;                                      // Mute off
       break ;
     case PRESET :
       if ( ( enc_preset + rotationcount ) < 0 )               // Negative not allowed
@@ -3394,7 +3225,7 @@ void chk_enc()
         enc_preset = 0 ;                                      // Yes, wrap
         readhostfrompref ( enc_preset, &tmp, &tmp2 ) ;        // Get host spec and possible comment
       }
-      dbgprint ( "Preset is %d", enc_preset ) ;
+      ESP_LOGI ( TAG, "Preset is %d", enc_preset ) ;
       // Show just comment if available.  Otherwise the preset itself.
       if ( tmp2 != "" )                                       // Symbolic name present?
       {
@@ -3407,8 +3238,8 @@ void chk_enc()
     case TRACK :
       if ( rotationcount > 0 )
       {
-        getSDFileName ( rotationcount ) ;                    // Select next file on SD
-        dbgprint ( "Select track %s",                        // Show for debug
+        getSDFileName ( SD_curindex + rotationcount ) ;      // Select next file on SD
+        ESP_LOGI ( TAG, "Select track %s",                   // Show for debug
                     getCurrentSDFileName() ) ;
         tftset ( 3, getCurrentShortSDFileName() ) ;          // Set screen segment bottom part
       }
@@ -3431,10 +3262,6 @@ void spfuncs()
   if ( spftrigger )                                             // Will be set every 100 msec
   {
     spftrigger = false ;                                        // Reset trigger
-    if ( dsp_usesSPI() )                                        // Does display uses SPI?
-    {
-      claimSPI ( "hspectft" ) ;                                 // Yes, claim SPI bus
-    }
     if ( dsp_ok )                                               // Posible to update TFT?
     {
       for ( uint16_t i = 0 ; i < TFTSECS ; i++ )                // Yes, handle all sections
@@ -3449,15 +3276,6 @@ void spfuncs()
       }
       dsp_update ( enc_menu_mode == VOLUME ) ;                  // Be sure to paint physical screen
     }
-    if ( dsp_usesSPI() )                                        // Does display uses SPI?
-    {
-      releaseSPI() ;                                            // Yes, release SPI bus
-    }
-    if ( time_req && NetworkFound )                             // Time to refresh time?
-    {
-      gettime() ;                                               // Yes, get the current time
-    }
-    claimSPI ( "hspec" ) ;                                      // Claim SPI bus
     if ( muteflag )                                             // Mute or not?
     {
       player_setVolume ( 0 ) ;                                  // Mute
@@ -3473,16 +3291,16 @@ void spfuncs()
     }
     if ( time_req )                                             // Time to refresh timetxt?
     {
-      time_req = false ;                                        // Yes, clear request
-      if ( NetworkFound  )                                      // Time available?
+      if ( NetworkFound )                                       // Yes, time available?
       {
-        displaytime ( timetxt ) ;                               // Write to TFT screen
+        gettime() ;                                             // Yes, get the current time
       }
+      time_req = false ;                                        // Yes, clear request
+      displaytime ( timetxt ) ;                                 // Write to TFT screen
       displayvolume ( player_getVolume() ) ;                    // Show volume on display
       displaybattery ( ini_block.bat0, ini_block.bat100,        // Show battery charge on display
                        adcval ) ;
     }
-    releaseSPI() ;                                              // Release SPI bus
     if ( mqtt_on )
     {
       if ( !mqttclient.connected() )                            // See if connected
@@ -3495,8 +3313,8 @@ void spfuncs()
       }
     }
     adcvalraw = adc1_get_raw ( ADC1_CHANNEL_0 ) ;
-    adcval = 15 * adcval +                                      // Read ADC and do some filtering
-             adcvalraw / 16 ;
+    adcval = ( 15 * adcval +                                    // Read ADC and do some filtering
+               adcvalraw ) / 16 ;
   }
 }
 
@@ -3515,7 +3333,7 @@ void radiofuncs()
 
   if ( xQueueReceive ( radioqueue, &radiocmd, 0 ) )               // New command in queue?
   {
-    dbgprint ( "Radiofuncs cmd is %d", radiocmd ) ;
+    ESP_LOGI ( TAG, "Radiofuncs cmd is %d", radiocmd ) ;
     switch ( radiocmd )                                           // Yes, examine command
     {
       case QSTARTSONG:                                            // Start a new station?
@@ -3524,8 +3342,7 @@ void radiofuncs()
           myQueueSend ( sdqueue, &stopcmd ) ;                     // Yes, send STOP to SD queue (First Out)
           sdfuncs() ;                                             // Allow sdfuncs to react
         }
-        connecttohost() ;                                         // Connect to stream host
-        connected = true ;                                        // Remember connection state
+        connected = connecttohost() ;                             // Connect to stream host
         mqttpub.trigger ( MQTT_PRESET ) ;                         // Request publishing to MQTT
         break ;
       case QSTOPSONG:                                             // Stop playing?
@@ -3550,16 +3367,28 @@ void loop()
 {
   if ( resetreq )                                   // Reset requested?
   {
-    delay ( 1000 ) ;                                // Yes, wait some time
+    vTaskDelay ( 1000 / portTICK_PERIOD_MS ) ;      // Yes, wait some time
     timerDetachInterrupt ( timer ) ;
     timerEnd ( timer ) ;
     ESP.restart() ;                                 // Reboot
   }
+  if ( sleepreq )                                   // Request for deep sleep?
+  {
+    if ( dsp_ok )                                   // TFT configured?
+    {
+      dsp_erase() ;                                 // Yes, clear screen
+      dsp_update ( true ) ;                         // To physical screen
+    }
+    esp_deep_sleep_start() ;                        // Yes, sleep until reset
+    // No return here...
+  }
   scanserial() ;                                    // Handle serial input
   scanserial2() ;                                   // Handle serial input from NEXTION (if active)
   scandigital() ;                                   // Scan digital inputs
   scanIR() ;                                        // See if IR input
-  otaHandle() ;                                     // Check for OTA
+  #ifdef ENABLEOTA
+    ArduinoOTA.handle() ;                           // Check for OTA
+  #endif
   if ( mqtt_on )                                    // Need to handle MQTT?
   {
     mqttclient.loop() ;                             // Handling of MQTT connection
@@ -3573,15 +3402,28 @@ void loop()
   sdfuncs() ;                                       // Do SD card related functions
   if ( testreq )
   {
+    const char* sformat = "Stack %-8s is %4d\n" ;
     testreq = false ;
     // heap_caps_print_heap_info ( MALLOC_CAP_8BIT ) ;
-    dbgprint ( "Stack maintask is %d", uxTaskGetStackHighWaterMark ( maintask   ) ) ;
-    dbgprint ( "Stack playtask is %d", uxTaskGetStackHighWaterMark ( xplaytask  ) ) ;
-    dbgprint ( "Stack SDtask   is %d", uxTaskGetStackHighWaterMark ( xsdtask    ) ) ;
-    dbgprint ( "ADC reading is %d, filtered %d", adcvalraw, adcval ) ;
-    dbgprint ( "%d IR interrupts seen", ir_intcount ) ;
-    dbgprint ( "SD detect is %d", digitalRead ( ini_block.sd_detect_pin ) ) ;
+    log_printf ( sformat, pcTaskGetTaskName ( maintask ),
+                 uxTaskGetStackHighWaterMark ( maintask ) ) ;
+    log_printf ( sformat, pcTaskGetTaskName ( xplaytask ),
+                 uxTaskGetStackHighWaterMark ( xplaytask ) ) ;
+    #ifdef SDCARD
+      log_printf ( sformat, pcTaskGetTaskName ( xsdtask ),
+                 uxTaskGetStackHighWaterMark ( xsdtask ) ) ;
+    #endif
+    log_printf ( "ADC reading is %d, filtered %d\n", adcvalraw, adcval ) ;
+    log_printf ( "%d IR interrupts seen\n", ir_intcount ) ;
+    if ( pin_exists ( ini_block.sd_detect_pin ) )
+    {
+      if ( digitalRead ( ini_block.sd_detect_pin ) == LOW )
+      {
+        log_printf ( "SD card detected\n" ) ;
+      }
+    }
   }
+  delay ( 10 ) ;
 }
 
 
@@ -3661,7 +3503,7 @@ void scan_content_length ( const char* metalinebf )
   if ( strstr ( metalinebf, "Content-Length" ) )        // Line contains content length
   {
     clength = atoi ( metalinebf + 15 ) ;                // Yes, set clength
-    dbgprint ( "Content-Length is %d", clength ) ;      // Show for debugging purposes
+    ESP_LOGI ( TAG, "Content-Length is %d", clength ) ; // Show for debugging purposes
   }
 }
 
@@ -3681,329 +3523,332 @@ void handlebyte_ch ( uint8_t b )
   static bool      redirection = false ;                // Redirection or not
 
   if ( chunked &&
-       ( datamode & ( DATA |                           // Test op DATA handling
+       ( datamode & ( DATA |                            // Test op DATA handling
                       METADATA |
                       PLAYLISTDATA ) ) )
   {
-    if ( chunkcount == 0 )                             // Expecting a new chunkcount?
+    if ( chunkcount == 0 )                              // Expecting a new chunkcount?
     {
-      if ( b == '\r' )                                 // Skip CR
+      if ( b == '\r' )                                  // Skip CR
       {
         return ;
       }
-      else if ( b == '\n' )                            // LF ?
+      else if ( b == '\n' )                             // LF ?
       {
-        chunkcount = chunksize ;                       // Yes, set new count
-        chunksize = 0 ;                                // For next decode
+        chunkcount = chunksize ;                        // Yes, set new count
+        chunksize = 0 ;                                 // For next decode
         return ;
       }
       // We have received a hexadecimal character.  Decode it and add to the result.
-      b = toupper ( b ) - '0' ;                        // Be sure we have uppercase
+      b = toupper ( b ) - '0' ;                         // Be sure we have uppercase
       if ( b > 9 )
       {
-        b = b - 7 ;                                    // Translate A..F to 10..15
+        b = b - 7 ;                                     // Translate A..F to 10..15
       }
       chunksize = ( chunksize << 4 ) + b ;
       return  ;
     }
-    chunkcount-- ;                                     // Update count to next chunksize block
+    chunkcount-- ;                                      // Update count to next chunksize block
   }
-  if ( datamode == DATA )                              // Handle next byte of MP3/AAC/Ogg data
+  if ( datamode == DATA )                               // Handle next byte of MP3/AAC/Ogg data
   {
     *outqp++ = b ;
-    if ( outqp == ( outchunk.buf + sizeof(outchunk.buf) ) ) // Buffer full?
+    if ( outqp == ( outchunk.buf + sizeof(outchunk.buf) ) )       // Buffer full?
     {
       // Send data to playtask queue.  If the buffer cannot be placed within 200 ticks,
       // the queue is full, while the sender tries to send more.  The chunk will be dis-
       // carded it that case.
-      xQueueSend ( dataqueue, &outchunk, 200 ) ;       // Send to queue
-      outqp = outchunk.buf ;                           // Item empty now
+      if ( xQueueSend ( dataqueue, &outchunk, 200 ) != pdTRUE )  // Send to queue
+      {
+        ESP_LOGE ( TAG, "MP3 packet dropped!" ) ;
+      }
+      outqp = outchunk.buf ;                            // Item empty now
     }
-    if ( metaint )                                     // No METADATA on Ogg streams or mp3 files
+    if ( metaint )                                      // No METADATA on Ogg streams or mp3 files
     {
-      if ( --datacount == 0 )                          // End of datablock?
+      if ( --datacount == 0 )                           // End of datablock?
       {
         setdatamode ( METADATA ) ;
-        metalinebfx = -1 ;                             // Expecting first metabyte (counter)
+        metalinebfx = -1 ;                              // Expecting first metabyte (counter)
       }
     }
     return ;
   }
-  if ( datamode == INIT )                              // Initialize for header receive
-  {
-    ctseen = false ;                                   // Contents type not seen yet
-    redirection = false ;                              // No redirection found yet
-    outqp = outchunk.buf ;                             // Item empty now
-    metaint = 0 ;                                      // No metaint found
-    LFcount = 0 ;                                      // For detection end of header
-    bitrate = 0 ;                                      // Bitrate still unknown
-    dbgprint ( "Switch to HEADER" ) ;
-    setdatamode ( HEADER ) ;                           // Handle header
-    totalcount = 0 ;                                   // Reset totalcount
-    metalinebfx = 0 ;                                  // No metadata yet
+  if ( datamode == INIT )                               // Initialize for header receive
+  {
+    ctseen = false ;                                    // Contents type not seen yet
+    redirection = false ;                               // No redirection found yet
+    outqp = outchunk.buf ;                              // Item empty now
+    metaint = 0 ;                                       // No metaint found
+    LFcount = 0 ;                                       // For detection end of header
+    bitrate = 0 ;                                       // Bitrate still unknown
+    ESP_LOGI ( TAG, "Switch to HEADER" ) ;
+    setdatamode ( HEADER ) ;                            // Handle header
+    totalcount = 0 ;                                    // Reset totalcount
+    metalinebfx = 0 ;                                   // No metadata yet
     metalinebf[0] = '\0' ;
   }
-  if ( datamode == HEADER )                            // Handle next byte of MP3 header
+  if ( datamode == HEADER )                             // Handle next byte of MP3 header
   {
-    if ( ( b > 0x7F ) ||                               // Ignore unprintable characters
-         ( b == '\r' ) ||                              // Ignore CR
-         ( b == '\0' ) )                               // Ignore NULL
+    if ( ( b > 0x7F ) ||                                // Ignore unprintable characters
+         ( b == '\r' ) ||                               // Ignore CR
+         ( b == '\0' ) )                                // Ignore NULL
     {
       // Yes, ignore
     }
-    else if ( b == '\n' )                              // Linefeed ?
+    else if ( b == '\n' )                               // Linefeed ?
     {
-      LFcount++ ;                                      // Count linefeeds
-      metalinebf[metalinebfx] = '\0' ;                 // Take care of delimiter
-      if ( chkhdrline ( metalinebf ) )                 // Reasonable input?
+      LFcount++ ;                                       // Count linefeeds
+      metalinebf[metalinebfx] = '\0' ;                  // Take care of delimiter
+      if ( chkhdrline ( metalinebf ) )                  // Reasonable input?
       {
-        dbgprint ( "Headerline: %s",                   // Show headerline
+        ESP_LOGI ( TAG, "Headerline: %s",               // Show headerline
                    metalinebf ) ;
-        String metaline = String ( metalinebf ) ;      // Convert to string
-        String lcml = metaline ;                       // Use lower case for compare
+        String metaline = String ( metalinebf ) ;       // Convert to string
+        String lcml = metaline ;                        // Use lower case for compare
         lcml.toLowerCase() ;
-        if ( lcml.startsWith ( "location: " ) )        // Redirection?
+        if ( lcml.startsWith ( "location: " ) )         // Redirection?
         {
-          metaline = metaline.substring ( 10 ) ;       // Yes, get new URL
-          int hp = metaline.indexOf ( "://" ) ;        // Redirection with "http(s)://" ?
+          metaline = metaline.substring ( 10 ) ;        // Yes, get new URL
+          int hp = metaline.indexOf ( "://" ) ;         // Redirection with "http(s)://" ?
           if ( hp > 0 )
           {
-            metaline = metaline.substring ( hp + 3 ) ; // Yes, get new URL
+            metaline = metaline.substring ( hp + 3 ) ;  // Yes, get new URL
           }
-          presetinfo.station_state = ST_REDIRECT ;     // Set host already filled
+          presetinfo.station_state = ST_REDIRECT ;      // Set host already filled
           presetinfo.host= metaline ;
-          redirection = true ;                         // Remember redirection
+          redirection = true ;                          // Remember redirection
         }
-        if ( lcml.startsWith ( "content-type" ) )      // Line with "Content-Type: xxxx/yyy"
+        if ( lcml.startsWith ( "content-type" ) )       // Line with "Content-Type: xxxx/yyy"
         {
-          ctseen = true ;                              // Yes, remember seeing this
-          audio_ct = metaline.substring ( 13 ) ;       // Set contentstype
+          ctseen = true ;                               // Yes, remember seeing this
+          audio_ct = metaline.substring ( 13 ) ;        // Set contentstype
           audio_ct.trim() ;
-          //dbgprint ( "%s seen", audio_ct.c_str() ) ; // Like "audio/mpeg"
+          //ESP_LOGI ( TAG, "%s seen", audio_ct.c_str() ) ;  // Like "audio/mpeg"
         }
         if ( lcml.startsWith ( "icy-br:" ) )
         {
-          bitrate = metaline.substring(7).toInt() ;    // Found bitrate tag, read the bitrate
-          if ( bitrate == 0 )                          // For Ogg br is like "Quality 2"
+          bitrate = metaline.substring(7).toInt() ;     // Found bitrate tag, read the bitrate
+          if ( bitrate == 0 )                           // For Ogg br is like "Quality 2"
           {
-            bitrate = 87 ;                             // Dummy bitrate
+            bitrate = 87 ;                              // Dummy bitrate
           }
         }
         else if ( lcml.startsWith ("icy-metaint:" ) )
         {
-          metaint = metaline.substring(12).toInt() ;   // Found metaint tag, read the value
+          metaint = metaline.substring(12).toInt() ;    // Found metaint tag, read the value
         }
         else if ( lcml.startsWith ( "icy-name:" ) )
         {
-          icyname = metaline.substring(9) ;            // Get station name
-          icyname = decode_spec_chars ( icyname ) ;    // Decode special characters in name
-          icyname.trim() ;                             // Remove leading and trailing spaces
-          if ( icyname.isEmpty() )                     // Empty name?
+          icyname = metaline.substring(9) ;             // Get station name
+          icyname = decode_spec_chars ( icyname ) ;     // Decode special characters in name
+          icyname.trim() ;                              // Remove leading and trailing spaces
+          if ( icyname.isEmpty() )                      // Empty name?
           {
-            icyname = presetinfo.hsym ;                // Yes, use symbolic name
+            icyname = presetinfo.hsym ;                 // Yes, use symbolic name
           }
-          tftset ( 2, icyname ) ;                      // Set screen segment bottom part
-          mqttpub.trigger ( MQTT_ICYNAME ) ;           // Request publishing to MQTT
+          tftset ( 2, icyname ) ;                       // Set screen segment bottom part
+          mqttpub.trigger ( MQTT_ICYNAME ) ;            // Request publishing to MQTT
         }
         else if ( lcml.startsWith ( "transfer-encoding:" ) )
         {
           // Station provides chunked transfer
           if ( lcml.endsWith ( "chunked" ) )
           {
-            chunked = true ;                           // Remember chunked transfer mode
-            chunkcount = 0 ;                           // Expect chunkcount in DATA
+            chunked = true ;                            // Remember chunked transfer mode
+            chunkcount = 0 ;                            // Expect chunkcount in DATA
           }
         }
       }
-      metalinebfx = 0 ;                                // Reset this line
-      if ( LFcount == 2 )                              // Double LF marks end of header?
+      metalinebfx = 0 ;                                 // Reset this line
+      if ( LFcount == 2 )                               // Double LF marks end of header?
       {
-        if ( redirection )                             // Redirection?
+        if ( redirection )                              // Redirection?
         {
-          dbgprint ( "Redirect" ) ;                    // Yes, show
-          setdatamode ( INIT ) ;                       // Mode to INIT again
-          myQueueSend ( radioqueue, &startcmd ) ;      // Restart with new found host
+          ESP_LOGI ( TAG, "Redirect" ) ;                // Yes, show
+          setdatamode ( INIT ) ;                        // Mode to INIT again
+          myQueueSend ( radioqueue, &startcmd ) ;       // Restart with new found host
         }
-        else if ( ctseen )                             // Content type seen?
+        else if ( ctseen )                              // Content type seen?
         {
-          dbgprint ( "Switch to DATA, bitrate is %d"   // Show bitrate
-                    ", metaint is %d",                 // and metaint
+          ESP_LOGI ( TAG, "Switch to DATA, bitrate is " // Show bitrate
+                    "%d kbps, metaint is %d",           // and metaint
                     bitrate, metaint ) ;
-          setdatamode ( DATA ) ;                       // Expecting data now
-          datacount = metaint ;                        // Number of bytes before first metadata
-          queueToPt ( QSTARTSONG ) ;                   // Queue a request to start song
+          setdatamode ( DATA ) ;                        // Expecting data now
+          datacount = metaint ;                         // Number of bytes before first metadata
+          queueToPt ( QSTARTSONG ) ;                    // Queue a request to start song
         }
       }
     }
     else
     {
-      metalinebf[metalinebfx++] = (char)b ;            // Normal character, put new char in metaline
-      if ( metalinebfx >= METASIZ )                    // Prevent overflow
+      metalinebf[metalinebfx++] = (char)b ;             // Normal character, put new char in metaline
+      if ( metalinebfx >= METASIZ )                     // Prevent overflow
       {
         metalinebfx-- ;
       }
-      LFcount = 0 ;                                    // Reset double CRLF detection
+      LFcount = 0 ;                                     // Reset double CRLF detection
     }
     return ;
   }
-  if ( datamode == METADATA )                          // Handle next byte of metadata
+  if ( datamode == METADATA )                           // Handle next byte of metadata
   {
-    if ( metalinebfx < 0 )                             // First byte of metadata?
+    if ( metalinebfx < 0 )                              // First byte of metadata?
     {
-      metalinebfx = 0 ;                                // Prepare to store first character
-      metacount = b * 16 + 1 ;                         // New count for metadata including length byte
+      metalinebfx = 0 ;                                 // Prepare to store first character
+      metacount = b * 16 + 1 ;                          // New count for metadata including length byte
     }
     else
     {
-      metalinebf[metalinebfx++] = (char)b ;            // Normal character, put new char in metaline
-      if ( metalinebfx >= METASIZ )                    // Prevent overflow
+      metalinebf[metalinebfx++] = (char)b ;             // Normal character, put new char in metaline
+      if ( metalinebfx >= METASIZ )                     // Prevent overflow
       {
         metalinebfx-- ;
       }
     }
     if ( --metacount == 0 )
     {
-      metalinebf[metalinebfx] = '\0' ;                 // Make sure line is limited
-      if ( strlen ( metalinebf ) )                     // Any info present?
+      metalinebf[metalinebfx] = '\0' ;                  // Make sure line is limited
+      if ( strlen ( metalinebf ) )                      // Any info present?
       {
         // metaline contains artist and song name.  For example:
         // "StreamTitle='Don McLean - American Pie';StreamUrl='';"
         // Sometimes it is just other info like:
         // "StreamTitle='60s 03 05 Magic60s';StreamUrl='';"
         // Isolate the StreamTitle, remove leading and trailing quotes if present.
-        if ( showstreamtitle ( metalinebf ) )          // Show artist and title if present in metadata
+        if ( showstreamtitle ( metalinebf ) )           // Show artist and title if present in metadata
         {
-          mqttpub.trigger ( MQTT_STREAMTITLE ) ;       // Title changed: Request publishing to MQTT
+          mqttpub.trigger ( MQTT_STREAMTITLE ) ;        // Title changed: Request publishing to MQTT
         }
       }
-      if ( metalinebfx  > ( METASIZ - 10 ) )           // Unlikely metaline length?
+      if ( metalinebfx  > ( METASIZ - 10 ) )            // Unlikely metaline length?
       {
-        dbgprint ( "Metadata block too long!" ) ;      // Probably no metadata
+        ESP_LOGE ( TAG, "Metadata block too long!" ) ;  // Probably no metadata
         // Skipping all Metadata from now on.
         metaint = 0 ;
       }
-      datacount = metaint ;                            // Reset data count
-      //bufcnt = 0 ;                                   // Reset buffer count
-      setdatamode ( DATA ) ;                           // Expecting data
+      datacount = metaint ;                             // Reset data count
+      //bufcnt = 0 ;                                    // Reset buffer count
+      setdatamode ( DATA ) ;                            // Expecting data
     }
   }
-  if ( datamode == PLAYLISTINIT )                      // Initialize for receive .m3u file
+  if ( datamode == PLAYLISTINIT )                       // Initialize for receive .m3u file
   {
     // We are going to use metadata to read the lines from the .m3u file
     // Sometimes this will only contain a single line
-    metalinebfx = 0 ;                                  // Prepare for new line
-    LFcount = 0 ;                                      // For detection end of header
-    setdatamode ( PLAYLISTHEADER ) ;                   // Handle playlist header
-    playlistcnt = 0 ;                                  // Reset for compare
-    totalcount = 0 ;                                   // Reset totalcount
-    clength = 0xFFFFFFFF ;                             // Content-length unknown
-    dbgprint ( "Read from playlist" ) ;
+    metalinebfx = 0 ;                                   // Prepare for new line
+    LFcount = 0 ;                                       // For detection end of header
+    setdatamode ( PLAYLISTHEADER ) ;                    // Handle playlist header
+    playlistcnt = 0 ;                                   // Reset for compare
+    totalcount = 0 ;                                    // Reset totalcount
+    clength = 0xFFFFFFFF ;                              // Content-length unknown
+    ESP_LOGI ( TAG, "Read from playlist" ) ;
   }
-  if ( datamode == PLAYLISTHEADER )                    // Read header
+  if ( datamode == PLAYLISTHEADER )                     // Read header
   {
-    if ( ( b > 0x7F ) ||                               // Ignore unprintable characters
-         ( b == '\r' ) ||                              // Ignore CR
-         ( b == '\0' ) )                               // Ignore NULL
+    if ( ( b > 0x7F ) ||                                // Ignore unprintable characters
+         ( b == '\r' ) ||                               // Ignore CR
+         ( b == '\0' ) )                                // Ignore NULL
     {
-      return ;                                         // Quick return
+      return ;                                          // Quick return
     }
-    else if ( b == '\n' )                              // Linefeed ?
+    else if ( b == '\n' )                               // Linefeed ?
     {
-      LFcount++ ;                                      // Count linefeeds
-      metalinebf[metalinebfx] = '\0' ;                 // Take care of delimeter
-      dbgprint ( "Playlistheader: %s",                 // Show playlistheader
+      LFcount++ ;                                       // Count linefeeds
+      metalinebf[metalinebfx] = '\0' ;                  // Take care of delimeter
+      ESP_LOGI ( TAG, "Playlistheader: %s",             // Show playlistheader
                  metalinebf ) ;
-      scan_content_length ( metalinebf ) ;             // Check if it is a content-length line
-      metalinebfx = 0 ;                                // Ready for next line
+      scan_content_length ( metalinebf ) ;              // Check if it is a content-length line
+      metalinebfx = 0 ;                                 // Ready for next line
       if ( LFcount == 2 )
       {
-        dbgprint ( "Switch to PLAYLISTDATA, "          // For debug
+        ESP_LOGI ( TAG, "Switch to PLAYLISTDATA, "      // For debug
                    "search for entry %d",
                    presetinfo.playlistnr ) ;
-        setdatamode ( PLAYLISTDATA ) ;                 // Expecting data now
-        mqttpub.trigger ( MQTT_PLAYLISTPOS ) ;         // Playlistposition to MQTT
+        setdatamode ( PLAYLISTDATA ) ;                  // Expecting data now
+        mqttpub.trigger ( MQTT_PLAYLISTPOS ) ;          // Playlistposition to MQTT
         return ;
       }
     }
     else
     {
-      metalinebf[metalinebfx++] = (char)b ;            // Normal character, put new char in metaline
-      if ( metalinebfx >= METASIZ )                    // Prevent overflow
+      metalinebf[metalinebfx++] = (char)b ;             // Normal character, put new char in metaline
+      if ( metalinebfx >= METASIZ )                     // Prevent overflow
       {
         metalinebfx-- ;
       }
-      LFcount = 0 ;                                    // Reset double CRLF detection
+      LFcount = 0 ;                                     // Reset double CRLF detection
     }
   }
-  if ( datamode == PLAYLISTDATA )                      // Read next byte of .m3u file data
+  if ( datamode == PLAYLISTDATA )                       // Read next byte of .m3u file data
   {
-    clength-- ;                                        // Decrease content length by 1
-    if ( ( b > 0x7F ) ||                               // Ignore unprintable characters
-         ( b == '\r' ) ||                              // Ignore CR
-         ( b == '\0' ) )                               // Ignore NULL
+    clength-- ;                                         // Decrease content length by 1
+    if ( ( b > 0x7F ) ||                                // Ignore unprintable characters
+         ( b == '\r' ) ||                               // Ignore CR
+         ( b == '\0' ) )                                // Ignore NULL
     {
       // Yes, ignore
     }
-    if ( b != '\n' )                                   // Linefeed?
+    if ( b != '\n' )                                    // Linefeed?
     { // No, normal character in playlistdata,
-      metalinebf[metalinebfx++] = (char)b ;            // add it to metaline
-      if ( metalinebfx >= METASIZ )                    // Prevent overflow
+      metalinebf[metalinebfx++] = (char)b ;             // add it to metaline
+      if ( metalinebfx >= METASIZ )                     // Prevent overflow
       {
         metalinebfx-- ;
       }
     }
-    if ( ( b == '\n' ) ||                              // linefeed?
-         ( clength == 0 ) )                            // Or end of playlist data contents
+    if ( ( b == '\n' ) ||                               // linefeed?
+         ( clength == 0 ) )                             // Or end of playlist data contents
     {
-      int inx ;                                        // Pointer in metaline
-      metalinebf[metalinebfx] = '\0' ;                 // Take care of delimeter
-      dbgprint ( "Playlistdata: %s",                   // Show playlist data
+      int inx ;                                         // Pointer in metaline
+      metalinebf[metalinebfx] = '\0' ;                  // Take care of delimeter
+      ESP_LOGI ( TAG, "Playlistdata: %s",               // Show playlist data
                  metalinebf ) ;
-      if ( strlen ( metalinebf ) < 5 )                 // Skip short lines
+      if ( strlen ( metalinebf ) < 5 )                  // Skip short lines
       {
-        metalinebfx = 0 ;                              // Flush line
+        metalinebfx = 0 ;                               // Flush line
         metalinebf[0] = '\0' ;
         return ;
       }
-      String metaline = String ( metalinebf ) ;        // Convert to string
-      if ( metaline.indexOf ( "#EXTINF:" ) >= 0 )      // Info?
+      String metaline = String ( metalinebf ) ;         // Convert to string
+      if ( metaline.indexOf ( "#EXTINF:" ) >= 0 )       // Info?
       {
-        if ( presetinfo.playlistnr == playlistcnt )    // Info for this entry?
+        if ( presetinfo.playlistnr == playlistcnt )     // Info for this entry?
         {
-          inx = metaline.indexOf ( "," ) ;             // Comma in this line?
+          inx = metaline.indexOf ( "," ) ;              // Comma in this line?
           if ( inx > 0 )
           {
             // Show artist and title if present in metadata
             if ( showstreamtitle ( metaline.substring ( inx + 1 ).c_str(), true ) )
             {
-              mqttpub.trigger ( MQTT_STREAMTITLE ) ;   // Title change: request publishing to MQTT
+              mqttpub.trigger ( MQTT_STREAMTITLE ) ;    // Title change: request publishing to MQTT
             }
           }
         }
       }
-      if ( metaline.startsWith ( "#" ) )               // Commentline?
+      if ( metaline.startsWith ( "#" ) )                // Commentline?
       {
-        metalinebfx = 0 ;                              // Yes, ignore
-        return ;                                       // Ignore commentlines
+        metalinebfx = 0 ;                               // Yes, ignore
+        return ;                                        // Ignore commentlines
       }
       // Now we have an URL for a .mp3 file or stream.
       presetinfo.highest_playlistnr = playlistcnt ;
-      dbgprint ( "Entry %d in playlist found: %s", playlistcnt, metalinebf ) ;
-      if ( presetinfo.playlistnr == playlistcnt )      // Is it the right one?
+      ESP_LOGI ( TAG, "Entry %d in playlist found: %s", playlistcnt, metalinebf ) ;
+      if ( presetinfo.playlistnr == playlistcnt )       // Is it the right one?
       {
-        inx = metaline.indexOf ( "://" ) ;             // Search for "http(s)://"
-        if ( inx >= 0 )                                // Does URL contain "http://"?
+        inx = metaline.indexOf ( "://" ) ;              // Search for "http(s)://"
+        if ( inx >= 0 )                                 // Does URL contain "http://"?
         {
-          metaline = metaline.substring ( inx + 3 ) ;  // Yes, remove it
+          metaline = metaline.substring ( inx + 3 ) ;   // Yes, remove it
         }
-        presetinfo.host = metaline ;                   // Set host
-        presetinfo.hsym = metaline ;                   // Do not know symbolic name
-        presetinfo.station_state = ST_PLAYLIST ;       // Set playlist mode
-        setdatamode ( INIT ) ;                         // Yes, mode to INIT again
-        myQueueSend ( radioqueue, &startcmd ) ;        // Restart with new found host
+        presetinfo.host = metaline ;                    // Set host
+        presetinfo.hsym = metaline ;                    // Do not know symbolic name
+        presetinfo.station_state = ST_PLAYLIST ;        // Set playlist mode
+        setdatamode ( INIT ) ;                          // Yes, mode to INIT again
+        myQueueSend ( radioqueue, &startcmd ) ;         // Restart with new found host
       }
-      metalinebfx = 0 ;                                // Prepare for next line
-      playlistcnt++ ;                                  // Next entry in playlist
+      metalinebfx = 0 ;                                 // Prepare for next line
+      playlistcnt++ ;                                   // Next entry in playlist
     }
   }
 }
@@ -4040,7 +3885,7 @@ void handle_notfound ( AsyncWebServerRequest *request )
       continue ;
     }
     cmd = key + String ( "=" ) + contents ;           // Format command to analyze
-    //dbgprint ( "Http command is %s", cmd.c_str() ) ;
+    //ESP_LOGI ( TAG, "Http command is %s", cmd.c_str() ) ;
     p = analyzeCmd ( cmd.c_str() ) ;                  // Analyze command
     sndstr += String ( p ) ;                          // Content of HTTP response follows the header
   }
@@ -4063,7 +3908,7 @@ void handle_notfound ( AsyncWebServerRequest *request )
   #endif
   if ( SPIFFS.exists ( path ) )                       // Does it exist in SPIFFS?
   {
-    ct = getContentType ( path ) ;                    // Get content type
+    ct = getContentType ( path.c_str() ) ;            // Get content type
     request->send ( SPIFFS, path, ct ) ;              // Send to client
   }
   else
@@ -4073,8 +3918,6 @@ void handle_notfound ( AsyncWebServerRequest *request )
 }
 
 
-
-
 //**************************************************************************************************
 //                                         C H O M P                                               *
 //**************************************************************************************************
@@ -4143,15 +3986,16 @@ const char* analyzeCmd ( const char* str )
 //   station    = <mp3 stream>              // Select new station (will not be saved)              *
 //   station    = <URL>.mp3                 // Play standalone .mp3 file (not saved)               *
 //   station    = <URL>.m3u                 // Select playlist (will not be saved)                 *
-//   stop                                   // Stop playing                                        *
 //   resume                                 // Resume playing                                      *
-//   mute                                   // Mute/unmute the music (toggle)                      *
+//   (un)mute                               // Mute/unmute the music                               *
+//   sleep                                  // Go into deep sleep mode                             *
 //   wifi_00    = mySSID/mypassword         // Set WiFi SSID and password *)                       *
 //   mqttbroker = mybroker.com              // Set MQTT broker to use *)                           *
 //   mqttprefix = XP93g                     // Set MQTT broker to use                              *
 //   mqttport   = 1883                      // Set MQTT port to use, default 1883 *)               *
 //   mqttuser   = myuser                    // Set MQTT user for authentication *)                 *
 //   mqttpasswd = mypassword                // Set MQTT password for authentication *)             *
+//   mqttrefresh                            // Refresh all MQTT items                              *
 //   clk_server = pool.ntp.org              // Time server to be used *)                           *
 //   clk_offset = <-11..+14>                // Offset with respect to UTC in hours *)              *
 //   clk_dst    = <1..2>                    // Offset during daylight saving time in hours *)      *
@@ -4159,7 +4003,6 @@ const char* analyzeCmd ( const char* str )
 //   status                                 // Show current URL to play                            *
 //   mp3list                                // Returns list with all MP3 files                     *
 //   test                                   // For test purposes                                   *
-//   debug      = 0 or 1                    // Switch debugging on or off                          *
 //   reset                                  // Restart the ESP32                                   *
 //   bat0       = 2318                      // ADC value for an empty battery                      *
 //   bat100     = 2916                      // ADC value for a fully charged battery               *
@@ -4200,10 +4043,6 @@ const char* analyzeCmd ( const char* par, const char* val )
   {
     value.remove ( 0, 7 ) ;                           // Yes, remove it
   }
-  if ( argument == "ota" )                            // Enable/disable OTA?
-  {
-    ota = ( ivalue != 0 ) ;                           // Yes, set switch acoordingly
-  }
   else if ( argument == "volume" )                    // Volume setting?
   {
     // Volume may be of the form "upvolume", "downvolume" or "volume" for relative or absolute setting
@@ -4228,9 +4067,9 @@ const char* analyzeCmd ( const char* par, const char* val )
     sprintf ( reply, "Volume is now %d",              // Reply new volume
               ini_block.reqvol ) ;
   }
-  else if ( argument == "mute" )                      // Mute/unmute request
+  else if ( argument.indexOf ( "mute" ) >= 0 )        // Mute/unmute request
   {
-    muteflag = !muteflag ;                            // Request volume to zero/normal
+    muteflag = ( argument == "mute" ) ;               // Request volume to zero/normal
   }
   else if ( argument.startsWith ( "ir_" ) )           // Ir setting?
   { // Do not handle here
@@ -4252,7 +4091,7 @@ const char* analyzeCmd ( const char* par, const char* val )
   {
     if ( relative )                                   // Yes. "uptrack" has numeric value
     {
-      getSDFileName ( ivalue ) ;                      // Select next file
+      getSDFileName ( SD_curindex + ivalue ) ;        // Select next file
     }
     else
     {
@@ -4263,7 +4102,7 @@ const char* analyzeCmd ( const char* par, const char* val )
   else if ( argument == "random" )                    // Random MP3 track request?
   {
     getSDFileName ( -1 ) ;                            // Yes, select new random track
-    dbgprint ( "Random file is %s",                   // Show filename
+    ESP_LOGI ( TAG, "Random file is %s",              // Show filename
                getCurrentSDFileName() ) ;
     myQueueSend ( sdqueue, &startcmd ) ;              // Signal SDfuncs()
   }
@@ -4280,6 +4119,10 @@ const char* analyzeCmd ( const char* par, const char* val )
               value.c_str() ) ;
     utf8ascii_ip ( reply ) ;                          // Remove possible strange characters
   }
+  else if ( argument == "sleep" )                     // Sleep request?
+  {
+    sleepreq = true ;                                 // Yes, set request flag
+  }
   else if ( argument == "status" )                    // Status request
   {
     if ( datamode == STOPPED )
@@ -4299,7 +4142,7 @@ const char* analyzeCmd ( const char* par, const char* val )
   else if ( argument == "test" )                      // Test command
   {
     sprintf ( reply, "Free memory is %d/%d, "         // Get some info to display
-              "chunks in queue %d, bitrate %d kbps",
+              "chunks in queue %d, bitrate %d kbps\n",
               heapspace,
               ESP.getFreeHeap(),
               uxQueueMessagesWaiting ( dataqueue ),
@@ -4356,14 +4199,10 @@ const char* analyzeCmd ( const char* par, const char* val )
     {
       ini_block.mqttpasswd = value.c_str() ;          // Yes, set broker password accordingly
     }
-  }
-  else if ( argument == "debug" )                     // Debug on/off request?
-  {
-    dbg_set ( ivalue != 0 ) ;                         // Yes, set flag accordingly
-  }
-  else if ( argument == "getnetworks" )               // List all WiFi networks?
-  {
-    sprintf ( reply, networks.c_str() ) ;             // Reply is SSIDs
+    else if ( argument.indexOf ( "refresh" ) > 0 )    // Refresh all items?
+    {
+      mqttpub.triggerall() ;                          // Yes, request to republish all items
+    }
   }
   else if ( argument.startsWith ( "clk_" ) )          // TOD parameter?
   {
@@ -4382,11 +4221,11 @@ const char* analyzeCmd ( const char* par, const char* val )
   }
   else if ( argument.startsWith ( "bat" ) )           // Battery ADC value?
   {
-    if ( argument.indexOf ( "100" ) == 3 )            // 100 percent value?
+    if ( argument.indexOf ( "100" ) )                 // 100 percent value?
     {
       ini_block.bat100 = ivalue ;                     // Yes, set it
     }
-    else if ( argument.indexOf ( "0" ) == 3 )         // 0 percent value?
+    else if ( argument.indexOf ( "0" ) )              // 0 percent value?
     {
       ini_block.bat0 = ivalue ;                       // Yes, set it
     }
@@ -4450,50 +4289,40 @@ void displayinfo ( uint16_t inx )
 //**************************************************************************************************
 void gettime()
 {
-  static int16_t delaycount = 0 ;                           // To reduce number of NTP requests
+  static int16_t delaycount = 0 ;                         // To reduce number of NTP requests
   static int16_t retrycount = 100 ;
 
-  if ( dsp_ok )                                             // TFT used?
+  if ( --delaycount <= 0 )                                // Sync every few hours
   {
-    if ( timeinfo.tm_year )                                 // Legal time found?
+    delaycount = 7200 ;                                   // Reset counter
+    if ( timeinfo.tm_year )                               // Legal time found?
     {
-      sprintf ( timetxt, "%02d:%02d:%02d",                  // Yes, format to a string
-                timeinfo.tm_hour,
-                timeinfo.tm_min,
-                timeinfo.tm_sec ) ;
+      ESP_LOGI ( TAG, "Sync TOD, old value is %s", timetxt ) ;
     }
-    if ( --delaycount <= 0 )                                // Sync every few hours
+    ESP_LOGI ( TAG, "Sync TOD" ) ;
+    if ( !getLocalTime ( &timeinfo ) )                    // Read from NTP server
     {
-      delaycount = 7200 ;                                   // Reset counter
-      if ( timeinfo.tm_year )                               // Legal time found?
-      {
-        dbgprint ( "Sync TOD, old value is %s", timetxt ) ;
-      }
-      dbgprint ( "Sync TOD" ) ;
-      if ( !getLocalTime ( &timeinfo ) )                    // Read from NTP server
-      {
-        dbgprint ( "Failed to obtain time!" ) ;             // Error
-        timeinfo.tm_year = 0 ;                              // Set current time to illegal
-        if ( retrycount )                                   // Give up syncing?
-        {
-          retrycount-- ;                                    // No try again
-          delaycount = 5 ;                                  // Retry after 5 seconds
-        }
-      }
-      else
+      ESP_LOGW ( TAG, "Failed to obtain time!" ) ;        // Error
+      timeinfo.tm_year = 0 ;                              // Set current time to illegal
+      if ( retrycount )                                   // Give up syncing?
       {
-        sprintf ( timetxt, "%02d:%02d:%02d",                // Format new time to a string
-                  timeinfo.tm_hour,
-                  timeinfo.tm_min,
-                  timeinfo.tm_sec ) ;
-        dbgprint ( "Sync TOD, new value is %s", timetxt ) ;
+        retrycount-- ;                                    // No try again
+        delaycount = 5 ;                                  // Retry after 5 seconds
       }
     }
+    else
+    {
+      ESP_LOGI ( TAG, "TOD synced" ) ;                    // Time has been synced
+    }
   }
+  sprintf ( timetxt, "%02d:%02d:%02d",                    // Format new time to a string
+            timeinfo.tm_hour,
+            timeinfo.tm_min,
+            timeinfo.tm_sec ) ;
 }
 
-
 #if defined(DEC_VS1053) || defined(DEC_VS1003)
+
 //**************************************************************************************************
 //                         P L A Y T A S K  ( V S 1 0 5 3 )                                        *
 //**************************************************************************************************
@@ -4502,42 +4331,63 @@ void gettime()
 //**************************************************************************************************
 void playtask ( void * parameter )
 {
+  // static bool once = true ;                                      // Show chunk once  #if defined(DEC_VS1053) || defined(DEC_VS1003)
+  bool VS_okay ;                                                    // VS isw okay or not
+
+  ESP_LOGI ( TAG, "Starting VS1053 playtask.." ) ;
+  VS_okay = VS1053_begin ( ini_block.vs_cs_pin,                     // Make instance of player and initialize
+                           ini_block.vs_dcs_pin,
+                           ini_block.vs_dreq_pin,
+                           ini_block.shutdown_pin,
+                           ini_block.shutdownx_pin ) ;
   while ( true )
   {
-    if ( xQueueReceive ( dataqueue, &inchunk, 5 ) )
+    if ( xQueueReceive ( dataqueue, &inchunk, 5 ) == pdTRUE )       // Command/data from queue?
     {
-      while ( !vs1053player->data_request() )                       // If FIFO is full..
+      if ( VS_okay )
       {
-        vTaskDelay ( 1 ) ;                                          // Yes, take a break
-      }
-      switch ( inchunk.datatyp )                                    // What kind of chunk?
-      {
-        case QDATA:
-          claimSPI ( "chunk" ) ;                                    // Claim SPI bus
-          vs1053player->playChunk ( inchunk.buf,                    // DATA, send to player
-                                    sizeof(inchunk.buf) ) ;
-          releaseSPI() ;                                            // Release SPI bus
-          totalcount += sizeof(inchunk.buf) ;                       // Count the bytes
-          break ;
-        case QSTARTSONG:
-          playingstat = 1 ;                                         // Status for MQTT
-          mqttpub.trigger ( MQTT_PLAYING ) ;                        // Request publishing to MQTT
-          claimSPI ( "startsong" ) ;                                // Claim SPI bus
-          vs1053player->startSong() ;                               // START, start player
-          releaseSPI() ;                                            // Release SPI bus
-          break ;
-        case QSTOPSONG:
-          playingstat = 0 ;                                         // Status for MQTT
-          mqttpub.trigger ( MQTT_PLAYING ) ;                        // Request publishing to MQTT
-          claimSPI ( "stopsong" ) ;                                 // Claim SPI bus
-          vs1053player->setVolume ( 0 ) ;                           // Mute
-          vs1053player->stopSong() ;                                // STOP, stop player
-          releaseSPI() ;                                            // Release SPI bus
-          while ( xQueueReceive ( dataqueue, &inchunk, 0 ) ) ;      // Flush rest of queue
-          vTaskDelay ( 500 / portTICK_PERIOD_MS ) ;                 // Pause for a short time
-          break ;
-        default:
-          break ;
+        switch ( inchunk.datatyp )                                    // What kind of command?
+        {
+          case QDATA:
+            while ( !vs1053player->data_request() )                   // If hardware FIFO is full..
+            {
+              vTaskDelay ( 1 ) ;                                      // Yes, take a break
+            }
+            // if ( once )                                            // Show this chunk?
+            // {
+            //   Serial.printf ( "First chunk to play (HEX):" ) ;     // Yes, show for testing purpose
+            //   for ( int i = 0 ; i < 32 ; i++ )
+            //   {
+            //     Serial.printf ( " %02X", inchunk.buf[i] ) ; 
+            //   }
+            //   Serial.printf ( "\n" ) ;
+            //   once = false ;                                       // Just show once
+            // }
+            vs1053player->playChunk ( inchunk.buf,                    // DATA, send to player
+                                      sizeof(inchunk.buf) ) ;
+            totalcount += sizeof(inchunk.buf) ;                       // Count the bytes
+            break ;
+          case QSTARTSONG:
+            ESP_LOGI ( TAG, "QSTARTSONG" ) ;
+            playingstat = 1 ;                                         // Status for MQTT
+            mqttpub.trigger ( MQTT_PLAYING ) ;                        // Request publishing to MQTT
+            vs1053player->setVolume ( ini_block.reqvol ) ;            // Unmute
+            vs1053player->startSong() ;                               // START, start player
+            // once = true ;
+            break ;
+          case QSTOPSONG:
+            ESP_LOGI ( TAG, "QSTOPSONG" ) ;
+            playingstat = 0 ;                                         // Status for MQTT
+            mqttpub.trigger ( MQTT_PLAYING ) ;                        // Request publishing to MQTT
+            vs1053player->setVolume ( 0 ) ;                           // Mute
+            vs1053player->stopSong() ;                                // STOP, stop player
+            break ;
+          case QSTOPTASK:
+            vTaskDelete ( NULL ) ;                                    // Stop task
+            break ;
+          default:
+            break ;
+        }
       }
     }
   }
@@ -4545,7 +4395,7 @@ void playtask ( void * parameter )
 }
 #endif
 
-#if defined(DEC_HELIX) || defined(DEC_HELIX_AI)
+#if defined(DEC_HELIX)
 //**************************************************************************************************
 //                               P L A Y T A S K ( I 2 S )                                         *
 //**************************************************************************************************
@@ -4562,28 +4412,40 @@ void playtask ( void * parameter )
 void playtask ( void * parameter )
 {
   esp_err_t        pinss_err = ESP_FAIL ;                            // Result of i2s_set_pin
-  i2s_port_t       i2s_num = I2S_NUM_0 ;                             // i2S port number
   i2s_config_t     i2s_config ;                                      // I2S configuration
+  bool             playing = false ;                                 // Are we playing or not?
 
   memset ( &i2s_config, 0, sizeof(i2s_config) ) ;                    // Clear config struct
   i2s_config.mode                   = (i2s_mode_t)(I2S_MODE_MASTER | // I2S mode (5)
                                           I2S_MODE_TX) ;
-  i2s_config.sample_rate            = 44100 ;
-  i2s_config.bits_per_sample        = I2S_BITS_PER_SAMPLE_16BIT ;    // (16)
-  i2s_config.channel_format         = I2S_CHANNEL_FMT_RIGHT_LEFT ;   // (0)
-  #if ESP_ARDUINO_VERSION_MAJOR >= 2                                 // New version?
-    i2s_config.communication_format = I2S_COMM_FORMAT_STAND_MSB ;    // Yes, use new definition
+  #ifdef DEC_HELIX_SPDIF
+    i2s_config.use_apll               = true ;
+    i2s_config.sample_rate            = 44100 * 2 ;                  // For spdif: biphase and 32 bits
+    i2s_config.bits_per_sample        = I2S_BITS_PER_SAMPLE_32BIT ;  // and 32 bits
+    #if ESP_ARDUINO_VERSION_MAJOR >= 2                               // New version?
+      i2s_config.communication_format = I2S_COMM_FORMAT_STAND_I2S ;  // Yes, use new definition
+    #else
+      i2s_config.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB) ;
+    #endif
   #else
-    i2s_config.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB) ;
+    i2s_config.sample_rate            = 44100 ;                      // 44100
+    i2s_config.bits_per_sample        = I2S_BITS_PER_SAMPLE_16BIT ;  // (16)
+    #if ESP_ARDUINO_VERSION_MAJOR >= 2                               // New version?
+      i2s_config.communication_format = I2S_COMM_FORMAT_STAND_MSB ;  // Yes, use new definition
+    #else
+      i2s_config.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB) ;
+    #endif
+    i2s_config.dma_buf_count        = 8 ;
+    i2s_config.dma_buf_len          = 256 ;
   #endif
+  //i2s_config.channel_format     = I2S_CHANNEL_FMT_RIGHT_LEFT ;   // = 0
   i2s_config.intr_alloc_flags     = ESP_INTR_FLAG_LEVEL1 ;         // High interrupt priority
-  i2s_config.dma_buf_count        = 16,
-  i2s_config.dma_buf_len          = 256,
-  //i2s_config.use_apll           = false ;
+  i2s_config.dma_buf_count        = 12 ;
+  i2s_config.dma_buf_len          = 256 ;
   i2s_config.tx_desc_auto_clear   = true ;                         // clear tx descriptor on underflow
-  i2s_config.fixed_mclk           = I2S_PIN_NO_CHANGE ;            // No pin for MCLK
-  //i2s_config.mclk_multiple      = (i2s_mclk_multiple_t)0 ;
-  //i2s_config.bits_per_chan      = (i2s_bits_per_chan_t)0 ;       // 0 = equal to bits per sample
+  //i2s_config.fixed_mclk         = 0 ;                            // No (pin for) MCLK
+  //i2s_config.mclk_multiple      = I2S_MCLK_MULTIPLE_DEFAULT ;    // = 0
+  //i2s_config.bits_per_chan      = I2S_BITS_PER_CHAN_DEFAULT ;    // = 0
   #ifdef DEC_HELIX_INT
     i2s_config.mode = (i2s_mode_t)(I2S_MODE_MASTER |               // Set I2S mode for internal DAC
                                    I2S_MODE_TX |                   // (4)
@@ -4592,51 +4454,55 @@ void playtask ( void * parameter )
       i2s_config.communication_format = I2S_COMM_FORMAT_I2S_MSB ;
     #endif
   #endif
-  dbgprint ( "Starting I2S playtask.." ) ;
+  ESP_LOGI ( TAG, "Starting I2S playtask.." ) ;
   #ifdef DEC_HELIX_AI                                              // For AI board?
     #define IIC_DATA 33                                            // Yes, use these I2C signals
     #define IIC_CLK  32
     if ( ! dac.begin ( IIC_DATA, IIC_CLK ) )                       // Initialize AI dac
     {
-      dbgprint ( "AI dac error!" ) ;
+      ESP_LOGE ( TAG, "AI dac error!" ) ;
     }
     pinMode ( GPIO_PA_EN, OUTPUT ) ;
     digitalWrite ( GPIO_PA_EN, HIGH ) ;
   #endif
   MP3Decoder_AllocateBuffers() ;                                    // Init HELIX buffers
   AACDecoder_AllocateBuffers() ;                                    // Init HELIX buffers
-  if ( i2s_driver_install ( i2s_num, &i2s_config, 0, NULL ) != ESP_OK )
+  if ( i2s_driver_install ( I2S_NUM_0, &i2s_config, 0, NULL ) != ESP_OK )
   {
-    dbgprint ( "I2S install error!" ) ;
+    ESP_LOGE ( TAG, "I2S install error!" ) ;
   }
   #ifdef DEC_HELIX_INT                                              // Use internal (8 bit) DAC?
-    dbgprint ( "Output to internal DAC" ) ;                         // Show output device
-    pinss_err = i2s_set_pin ( i2s_num, NULL ) ;                     // Yes, default pins for internal DAC
+    ESP_LOGI ( TAG, "Output to internal DAC" ) ;                    // Show output device
+    pinss_err = i2s_set_pin ( I2S_NUM_0, NULL ) ;                   // Yes, default pins for internal DAC
     i2s_set_dac_mode ( I2S_DAC_CHANNEL_BOTH_EN ) ;
   #else
-    i2s_pin_config_t pin_config ;                                   // I2s pin config
-    pin_config.bck_io_num    = ini_block.i2s_bck_pin ;              // This is BCK pin
-    pin_config.ws_io_num     = ini_block.i2s_lck_pin ;              // This is L(R)CK pin
-    pin_config.data_out_num  = ini_block.i2s_din_pin ;              // This is DATA output pin
-    pin_config.data_in_num   = I2S_PIN_NO_CHANGE ;                  // No input
+    i2s_pin_config_t pin_config ;
     #if ESP_ARDUINO_VERSION_MAJOR >= 2
-      pin_config.mck_io_num    = I2S_PIN_NO_CHANGE ;                // MCK not used
+      pin_config.mck_io_num   = I2S_PIN_NO_CHANGE ;                 // MCK not used
     #endif
-    dbgprint ( "Output to I2S, pins %d, %d and %d",                 // Show pins used for output device
-               pin_config.bck_io_num,                               // This is the BCK (bit clock) pin
-               pin_config.ws_io_num,                                // This is L(R)CK pin
-               pin_config.data_out_num ) ;                          // This is DATA output pin
-    if ( ( ini_block.i2s_bck_pin + 
-           ini_block.i2s_lck_pin +
-           ini_block.i2s_din_pin ) > 2 )                            // Check for legal pins
-    {
-      pinss_err = i2s_set_pin ( i2s_num, &pin_config ) ;            // Set I2S pins
-    }
+    pin_config.data_in_num    = I2S_PIN_NO_CHANGE ;
+    #ifdef DEC_HELIX_SPDIF
+      pin_config.bck_io_num   = I2S_PIN_NO_CHANGE ;
+      pin_config.ws_io_num    = I2S_PIN_NO_CHANGE ;
+      pin_config.data_out_num = ini_block.i2s_spdif_pin ;
+      pin_config.data_in_num  = I2S_PIN_NO_CHANGE ;
+      ESP_LOGI ( TAG, "Output to SPDIF, pin %d",                    // Show pin used for output device
+                 pin_config.data_out_num ) ;
+    #else
+      pin_config.bck_io_num   = ini_block.i2s_bck_pin ;             // This is BCK pin
+      pin_config.ws_io_num    = ini_block.i2s_lck_pin ;             // This is L(R)CK pin
+      pin_config.data_out_num = ini_block.i2s_din_pin ;             // This is DATA output pin
+      ESP_LOGI ( TAG, "Output to I2S, pins %d, %d and %d",          // Show pins used for output device
+                 pin_config.bck_io_num,                             // This is the BCK (bit clock) pin
+                 pin_config.ws_io_num,                              // This is L(R)CK pin
+                 pin_config.data_out_num ) ;                        // This is DATA output pin
+    #endif
+    pinss_err = i2s_set_pin ( I2S_NUM_0, &pin_config ) ;            // Set I2S pins
   #endif
-  i2s_zero_dma_buffer ( i2s_num ) ;                                 // Zero the buffer
+  i2s_zero_dma_buffer ( I2S_NUM_0 ) ;                               // Zero the buffer
   if ( pinss_err != ESP_OK )                                        // Check error condition
   {
-    dbgprint ( "I2S setpin error!" ) ;                              // Rport bad pis
+    ESP_LOGE ( TAG, "I2S setpin error!" ) ;                         // Rport bad pins
     while ( true)                                                   // Forever..
     {
       xQueueReceive ( dataqueue, &inchunk, 500 ) ;                  // Ignore all chunk from queue
@@ -4644,32 +4510,37 @@ void playtask ( void * parameter )
   }
   while ( true )
   {
-    if ( xQueueReceive ( dataqueue, &inchunk, 500 ) )               // Get next chunk from queue
+    if ( xQueueReceive ( dataqueue, &inchunk, 5 ) == pdTRUE )       // Command/data from queue?
     {
-      switch ( inchunk.datatyp )                                    // What kind of chunk?
+      switch ( inchunk.datatyp )                                    // Yes, what kind of command?
       {
         case QDATA:
-          playChunk ( i2s_num, inchunk.buf ) ;                      // Play this chunk
+          if ( playing )                                            // Are we playing?
+          {
+            playChunk ( inchunk.buf ) ;                             // Play this chunk
+          }
           totalcount += sizeof(inchunk.buf) ;                       // Count the bytes
           break ;
         case QSTARTSONG:
-          dbgprint ( "Playtask start song" ) ;
+          ESP_LOGI ( TAG, "Playtask start song" ) ;
+          playing = true ;                                          // Set local status to playing
           playingstat = 1 ;                                         // Status for MQTT
           mqttpub.trigger ( MQTT_PLAYING ) ;                        // Request publishing to MQTT
           helixInit ( ini_block.shutdown_pin,                       // Enable amplifier output
                       ini_block.shutdownx_pin ) ;                   // Init framebuffering
           break ;
         case QSTOPSONG:
-          dbgprint ( "Playtask stop song" ) ;
+          ESP_LOGI ( TAG, "Playtask stop song" ) ;
+          playing = false ;                                         // Reset local play status
           playingstat = 0 ;                                         // Status for MQTT
-          i2s_stop ( i2s_num ) ;                                    // Stop DAC
+          i2s_stop ( I2S_NUM_0 ) ;                                  // Stop DAC
           mqttpub.trigger ( MQTT_PLAYING ) ;                        // Request publishing to MQTT
-          while ( xQueueReceive ( dataqueue, &inchunk, 0 ) ) ;      // Flush rest of queue
-          vTaskDelay ( 500 / portTICK_PERIOD_MS ) ;                 // Pause for a short time
+          //vTaskDelay ( 500 / portTICK_PERIOD_MS ) ;               // Pause for a short time
           break ;
         case QSTOPTASK:
-          dbgprint ( "Stop Playtask" ) ;
-          i2s_stop ( i2s_num ) ;                                    // Stop DAC
+          ESP_LOGI ( TAG, "Stop Playtask" ) ;
+          playing = false ;                                         // Reset local play status
+          i2s_stop ( I2S_NUM_0 ) ;                                  // Stop DAC
           vTaskDelete ( NULL ) ;                                    // Stop task
           break ;
         default:
@@ -4684,50 +4555,48 @@ void playtask ( void * parameter )
 //**************************************************************************************************
 //                                     S D F U N C S                                               *
 //**************************************************************************************************
-// Handles data and directory scan of SD card.                                                     *
+// Handles data of SD card and commands in the sdqueue.                                            *
 // Commands are received in the input queue.                                                       *
 //**************************************************************************************************
 void sdfuncs()
 {
 #ifdef SDCARD
-  qdata_type          sdcmd ;                                       // Command from sdqueue
-  static bool         openfile = false ;                            // Open input file available
-  static bool         autoplay = true ;                             // Play next after end
+  qdata_type          sdcmd ;                                     // Command from sdqueue
+  static bool         openfile = false ;                          // Open input file available
+  static bool         autoplay = true ;                           // Play next after end
+  size_t              n ;                                         // Number of bytes read from SD
 
   if ( openfile )
   {
-    if ( mp3filelength )                                            // Read until eof
+    while ( ( mp3filelength > 0 ) &&                              // Read until eof or dataqueue full
+            ( uxQueueSpacesAvailable ( dataqueue ) > 0 ) )
     {
-      if ( uxQueueSpacesAvailable ( dataqueue ) )                   // Space in queue?
+      n = mp3file.read ( outchunk.buf, sizeof(outchunk.buf) ) ;   // Read a block of data
+      if ( n < sizeof(outchunk.buf) )                             // Incomplete chunk?
       {
-        size_t n = read_SDCARD ( outchunk.buf,
-                                 sizeof(outchunk.buf) ) ;
-        if ( n < sizeof(outchunk.buf) )                             // Incomplete chunk?
-        {
-          memset ( outchunk.buf + n, 0,                             // Yes, clear rest
-                   sizeof(outchunk.buf) - n ) ;
-        }
-        xQueueSend ( dataqueue, &outchunk, 0 ) ;                    // Send to queue
-        mp3filelength -= n ;                                        // Compute rest in file
+        memset ( outchunk.buf + n, 0,                             // Yes, clear rest
+                 sizeof(outchunk.buf) - n ) ;
       }
-    }
-    else
-    {
-      close_SDCARD() ;                                            // Close file
-      openfile = false ;
-      queueToPt ( QSTOPSONG ) ;                                   // Tell playtask to stop song
-      if ( autoplay )                                             // Continue with next track?
+      xQueueSend ( dataqueue, &outchunk, 0 ) ;                    // Send to queue
+      mp3filelength -= n ;                                        // Compute rest in file
+      if ( mp3filelength == 0 )                                   // End of file?
       {
-        dbgprint ( "Autoplay next track" ) ;
-        getNextSDFileName() ;                                     // Select next track
-        myQueueSend ( sdqueue, &startcmd ) ;                      // Start message to myself
-        return ;
+        vTaskDelay ( 500 / portTICK_PERIOD_MS ) ;                 // Give some time to finish song
+        myQueueSend ( sdqueue, &stopcmd ) ;                       // Stop message to myself
+        ESP_LOGI ( TAG, "EOF" ) ;
+        queueToPt ( QSTOPSONG ) ;                                 // Tell playtask to stop song
+        if ( autoplay )                                           // Continue with next track?
+        {
+          ESP_LOGI ( TAG, "Autoplay next track" ) ;
+          getNextSDFileName() ;                                   // Select next track
+          myQueueSend ( sdqueue, &startcmd ) ;                    // Start message to myself
+        }
       }
     }
   }
-  if ( xQueueReceive ( sdqueue, &sdcmd, 0 ) )                     // New command in queue?
+  if ( xQueueReceive ( sdqueue, &sdcmd, 0 ) == pdTRUE )           // New command in queue?
   {
-    dbgprint ( "SDfuncs cmd is %d", sdcmd ) ;
+    ESP_LOGI ( TAG, "SDfuncs cmd is %d", sdcmd ) ;
     switch ( sdcmd )                                              // Yes, examine command
     {
       case QSTARTSONG:                                            // Start a new song?
@@ -4736,24 +4605,26 @@ void sdfuncs()
           close_SDCARD() ;                                        // Clode file
         }
         queueToPt ( QSTOPSONG ) ;                                 // Tell playtask to stop song
-        if ( ( openfile = connecttofile_SD() ) )                  // Yes, connect to file
+        if ( ( openfile = connecttofile_SD() ) )                  // Yes, connect to file, set mp3filelength
         {
-          dbgprint ( "File opened, track = %s",
+          ESP_LOGI ( TAG, "File opened, track = %s",
                      getCurrentSDFileName() ) ;
+          ESP_LOGI ( TAG, "File length is %d", mp3filelength ) ;
           audio_ct = String ( "audio/mpeg" ) ;                    // Force mp3 mode
           myQueueSend ( radioqueue, &stopcmd ) ;                  // Stop playing icecast station
-          radiofuncs() ;                                          // Allow radiouncs to react
+          radiofuncs() ;                                          // Allow radiofuncs to react
           queueToPt ( QSTARTSONG ) ;                              // Tell playtask
           autoplay = true ;                                       // Set autoplay mode
         }
         else
         {
-          dbgprint ( "Error opening file" ) ;
+          ESP_LOGI ( TAG, "Error opening file" ) ;
         }
         break ;
       case QSTOPSONG:                                             // Stop the song?
         if ( openfile )                                           // Still playing?
         {
+          close_SDCARD() ;                                        // Clode file
           mp3filelength = 0 ;                                     // Yes, force end of file
           autoplay = false ;                                      // Stop autoplay
         }
diff --git a/src/utils.cpp b/src/utils.cpp
index 7435f6c..a5cf44a 100644
--- a/src/utils.cpp
+++ b/src/utils.cpp
@@ -3,56 +3,8 @@
 //
 #include "Arduino.h"
 #include "utils.h"
-#include <stdarg.h>
-#include <stdio.h>
-
-SemaphoreHandle_t dbgsem = NULL ;
-bool              dbgsw = 1 ;                          // Debug on by default
-
-
-//**************************************************************************************************
-//                                          D B G _ SET                                            *
-//**************************************************************************************************
-// Turn on/off debuglines.                                                                         *
-//**************************************************************************************************
-void dbg_set ( bool onoff )
-{
-  dbgsw = onoff ;
-}
-
-
-//**************************************************************************************************
-//                                          D B G P R I N T                                        *
-//**************************************************************************************************
-// Send a line of info to serial output.  Works like vsprintf(), but checks the DEBUG flag.        *
-// Print only if DEBUG flag is true.                                                               *
-//**************************************************************************************************
-void dbgprint ( const char* format, ... )
-{
-  static char sbuf[DEBUG_BUFFER_SIZE] ;                // For debug lines
-  va_list varArgs ;                                    // For variable number of params
-
-  if ( ! dbgsem )                                      // Semaphore already initialized?
-  {
-    dbgsem = xSemaphoreCreateMutex() ;                 // Create semaphore
-  }
-  if ( xSemaphoreTake ( dbgsem, 20 ) != pdTRUE  )      // Claim resource
-  {
-    return ;                                           // Not available
-  }
-  va_start ( varArgs, format ) ;                       // Prepare parameters
-  vsnprintf ( sbuf, sizeof(sbuf), format, varArgs ) ;  // Format the message
-  va_end ( varArgs ) ;                                 // End of using parameters
-  if ( dbgsw )                                         // DEBUG on?
-  {
-    //Serial.print ( "D: " ) ;                           // Yes, print prefix and info
-    Serial.printf ( "D: %d/%d - ",
-      heap_caps_get_largest_free_block ( MALLOC_CAP_8BIT ),
-      ESP.getFreeHeap() ) ;
-    Serial.println ( sbuf ) ;
-  }
-  xSemaphoreGive ( dbgsem ) ;                          // Release resource
-}
+//#include <stdarg.h>
+//#include <stdio.h>
 
 
 //**************************************************************************************************
@@ -87,19 +39,19 @@ const char* getEncryptionType ( wifi_auth_mode_t thisType )
 //                                     G E T C O N T E N T T Y P E                                 *
 //**************************************************************************************************
 // Returns the contenttype of a file to send to a client.                                          *
+// Note that the strstr function searches for the firsty occurence.  So the function will fail for *
+// filenames like "abc.html.ico".                                                                  *
 //**************************************************************************************************
-String getContentType ( String filename )
+String getContentType ( const char* filename )
 {
-  if      ( filename.endsWith ( ".html" ) ) return "text/html" ;
-  else if ( filename.endsWith ( ".png"  ) ) return "image/png" ;
-  else if ( filename.endsWith ( ".gif"  ) ) return "image/gif" ;
-  else if ( filename.endsWith ( ".jpg"  ) ) return "image/jpeg" ;
-  else if ( filename.endsWith ( ".ico"  ) ) return "image/x-icon" ;
-  else if ( filename.endsWith ( ".css"  ) ) return "text/css" ;
-  else if ( filename.endsWith ( ".zip"  ) ) return "application/x-zip" ;
-  else if ( filename.endsWith ( ".gz"   ) ) return "application/x-gzip" ;
-  else if ( filename.endsWith ( ".mp3"  ) ) return "audio/mpeg" ;
-  else if ( filename.endsWith ( ".pw"   ) ) return "" ;              // Passwords are secret
+  if ( strstr ( filename, ".html" ) ) return "text/html" ;
+  if ( strstr ( filename, ".png"  ) ) return "image/png" ;
+  if ( strstr ( filename, ".gif"  ) ) return "image/gif" ;
+  if ( strstr ( filename, ".jpg"  ) ) return "image/jpeg" ;
+  if ( strstr ( filename, ".ico"  ) ) return "image/x-icon" ;
+  if ( strstr ( filename, ".css"  ) ) return "text/css" ;
+  if ( strstr ( filename, ".mp3"  ) ) return "audio/mpeg" ;
+  if ( strstr ( filename, ".js"   ) ) return "text/javascript" ;
   return "text/plain" ;
 }
 
@@ -196,4 +148,18 @@ String utf8ascii ( const char* s )
 }
 
 
+//**************************************************************************************************
+//                                    P I N _ E X I S T S                                          *
+//**************************************************************************************************
+// Checks if GPIO pin exists.                                                                      *
+//**************************************************************************************************
+bool pin_exists ( uint8_t pin )
+{
+  #ifdef CONFIG_IDF_TARGET_ESP32
+    return ( pin <= 39 ) ;
+  #endif
+  #ifdef CONFIG_IDF_TARGET_ESP32S3
+    return ( pin <= 48 ) ;
+  #endif
+}
 
diff --git a/src/utils.h b/src/utils.h
index 9fc62bb..68a9d36 100644
--- a/src/utils.h
+++ b/src/utils.h
@@ -5,15 +5,11 @@
 #define UTILS_H
 #include <esp_wifi_types.h>
 
-#define DEBUG_BUFFER_SIZE 200                                      // Debug buffer size
-
-void        dbg_set ( bool onoff ) ;                               // Turn on/off debuglines
-void        dbgprint ( const char* format, ... ) ;                 // Print a formatted debug line
 char        utf8ascii ( char ascii ) ;                             // Convert UTF to Ascii
 void        utf8ascii_ip ( char* s ) ;                             // Convert UTF to Ascii in place
 String      utf8ascii ( const char* s ) ;                          // Convert UTF to Ascii as String
 const char* getEncryptionType ( wifi_auth_mode_t thisType ) ;      // Get encryption type voor WiFi networks
-String      getContentType ( String filename ) ;
-
+String      getContentType ( const char* ) ;
+bool        pin_exists ( uint8_t pin ) ;                           // Check GPIO pin number
 
 #endif
diff --git a/tools/Esp32_radio_init.ino b/tools/Esp32_radio_init.ino
index ba1f06b..837e6a5 100644
--- a/tools/Esp32_radio_init.ino
+++ b/tools/Esp32_radio_init.ino
@@ -1,97 +1,97 @@
-//********************************************************************************************
-// Initialize the preferences op ESP32-radio.  They can be edited later by the webinterface. *
-//********************************************************************************************
-// 27-04-2017, ES: First set-up, derived from preferences example sketch.                    *
-// 11-02-2019, ES: names of I/O pins changed.                                                *
-//********************************************************************************************
-
-#include <Preferences.h>
-
-// Note: Namespace name is limited to 15 chars.  Same name must be used in ESP32-radio.
-#define NAME "ESP32Radio"
-// Adjust size of buffer to the longest expected string for nvsgetstr
-#define NVSBUFSIZE 150
-
-Preferences preferences ;         // Instance of Preferences
-
-
-//******************************************************************************************
-//                              S E T U P                                                  *
-//******************************************************************************************
-void setup()
-{
-  String       str ;
-  
-  Serial.begin ( 115200 ) ;
-  Serial.println() ;
-  preferences.begin ( NAME, false ) ;                 // Open for read/write
-  preferences.clear() ;                               // Remove all preferences under opened namespace
-  // Store the preferences for ESP32-radio
-  preferences.putString ( "gpio_00",  "uppreset = 1" ) ;
-  preferences.putString ( "gpio_12",  "upvolume = 2" ) ;
-  preferences.putString ( "gpio_13",  "downvolume = 2" ) ;
-
-  preferences.putString ( "mqttbroker",   "none" ) ;
-  preferences.putString ( "mqttport",     "1883" ) ;
-  preferences.putString ( "mqttuser",     "none" ) ;
-  preferences.putString ( "mqttpasswd",   "none" ) ;
-  preferences.putString ( "mqttprefix",   "none" ) ;
-  //
-  preferences.putString ( "wifi_00",     "NETGEAR-11/xxxxxx" ) ;
-  preferences.putString ( "wifi_01",     "SSID2/YYYYYY" ) ;
-  //
-  preferences.putString ( "volume",      "72" ) ;
-  preferences.putString ( "toneha",      "0" ) ;
-  preferences.putString ( "tonehf",      "0" ) ;
-  preferences.putString ( "tonela",      "0" ) ;
-  preferences.putString ( "tonelf",      "0" ) ;
-  //
-  preferences.putString ( "preset",      "6" ) ;
-  preferences.putString ( "preset_00",   "109.206.96.34:8100                       #  0 - NAXI LOVE RADIO, Belgrade, Serbia" ) ;
-  preferences.putString ( "preset_01",   "airspectrum.cdnstream1.com:8114/1648_128 #  1 - Easy Hits Florida 128k" ) ;
-  preferences.putString ( "preset_02",   "us2.internet-radio.com:8050              #  2 - CLASSIC ROCK MIA WWW.SHERADIO.COM" ) ;
-  preferences.putString ( "preset_03",   "airspectrum.cdnstream1.com:8000/1261_192 #  3 - Magic Oldies Florida" ) ;
-  preferences.putString ( "preset_04",   "airspectrum.cdnstream1.com:8008/1604_128 #  4 - Magic 60s Florida 60s Classic Rock" ) ;
-  preferences.putString ( "preset_05",   "us1.internet-radio.com:8105              #  5 - Classic Rock Florida - SHE Radio" ) ;
-  preferences.putString ( "preset_06",   "icecast.omroep.nl:80/radio1-bb-mp3       #  6 - Radio 1, NL" ) ;
-  preferences.putString ( "preset_07",   "205.164.62.15:10032                      #  7 - 1.FM - GAIA, 64k" ) ;
-  preferences.putString ( "preset_08",   "skonto.ls.lv:8002/mp3                    #  8 - Skonto 128k" ) ;
-  preferences.putString ( "preset_09",   "94.23.66.155:8106                        #  9 - *ILR CHILL and GROOVE" ) ;
-  preferences.putString ( "preset_10",   "ihr/IHR_IEDM                             # 10 - iHeartRadio IHR_IEDM" ) ;
-  preferences.putString ( "preset_11",   "ihr/IHR_TRAN                             # 11 - iHeartRadio IHR_TRAN" ) ;
-  //
-  preferences.putString ( "clk_server",  "pool.ntp.org" ) ;        // Setting for Time Of Day clock on TFT
-  preferences.putString ( "clk_offset",  "1" ) ;
-  preferences.putString ( "clk_dst",     "1" ) ;
-  //
-  preferences.putString ( "pin_ir",      "35                                     # GPIO Pin number for IR receiver VS1838B" ) ;
-  preferences.putString ( "ir_40BF",     "upvolume = 2" ) ;
-  preferences.putString ( "ir_C03F",     "downvolume = 2" ) ;
-  //
-  preferences.putString ( "pin_vs_cs",   "5                                      # GPIO Pin number for VS1053 CS" ) ;
-  preferences.putString ( "pin_vs_dcs",  "16                                     # GPIO Pin number for VS1053 DCS" ) ;
-  preferences.putString ( "pin_vs_dreq", "4                                      # GPIO Pin number for VS1053 DREQ" ) ;
-  //
-  preferences.putString ( "pin_enc_clk", "25                                     # GPIO Pin number for rotary encoder CLK" ) ;
-  preferences.putString ( "pin_enc_dt",  "26                                     # GPIO Pin number for rotary encoder DT" ) ;
-  preferences.putString ( "pin_enc_sw",  "27                                     # GPIO Pin number for rotary encoder SW" ) ;
-  //
-  preferences.putString ( "pin_tft_cs",  "15                                     # GPIO Pin number for TFT CS" ) ;
-  preferences.putString ( "pin_tft_dc",  "2                                      # GPIO Pin number for TFT DC" ) ;
-  //
-  preferences.putString ( "pin_sd_cs",   "21                                     # GPIO Pin number for SD card CS" ) ;
-
-  preferences.end() ;
-  delay ( 1000 ) ;
-}
-
-
-//******************************************************************************************
-//                              L O O P                                                    *
-//******************************************************************************************
-void loop()
-{
-  Serial.println ( "ESP32_radio_init completed..." ) ;
-  delay ( 10000 ) ;
-}
+//********************************************************************************************
+// Initialize the preferences op ESP32-radio.  They can be edited later by the webinterface. *
+//********************************************************************************************
+// 27-04-2017, ES: First set-up, derived from preferences example sketch.                    *
+// 11-02-2019, ES: names of I/O pins changed.                                                *
+//********************************************************************************************
+
+#include <Preferences.h>
+
+// Note: Namespace name is limited to 15 chars.  Same name must be used in ESP32-radio.
+#define NAME "ESP32-Radio"
+// Adjust size of buffer to the longest expected string for nvsgetstr
+#define NVSBUFSIZE 150
+
+Preferences preferences ;         // Instance of Preferences
+
+
+//******************************************************************************************
+//                              S E T U P                                                  *
+//******************************************************************************************
+void setup()
+{
+  String       str ;
+  
+  Serial.begin ( 115200 ) ;
+  Serial.println() ;
+  preferences.begin ( NAME, false ) ;                 // Open for read/write
+  preferences.clear() ;                               // Remove all preferences under opened namespace
+  // Store the preferences for ESP32-radio
+  preferences.putString ( "gpio_00",  "uppreset = 1" ) ;
+  preferences.putString ( "gpio_12",  "upvolume = 2" ) ;
+  preferences.putString ( "gpio_13",  "downvolume = 2" ) ;
+
+  preferences.putString ( "mqttbroker",   "none" ) ;
+  preferences.putString ( "mqttport",     "1883" ) ;
+  preferences.putString ( "mqttuser",     "none" ) ;
+  preferences.putString ( "mqttpasswd",   "none" ) ;
+  preferences.putString ( "mqttprefix",   "none" ) ;
+  //
+  preferences.putString ( "wifi_00",     "NETGEAR-11/xxxxxx" ) ;
+  preferences.putString ( "wifi_01",     "SSID2/YYYYYY" ) ;
+  //
+  preferences.putString ( "volume",      "72" ) ;
+  preferences.putString ( "toneha",      "0" ) ;
+  preferences.putString ( "tonehf",      "0" ) ;
+  preferences.putString ( "tonela",      "0" ) ;
+  preferences.putString ( "tonelf",      "0" ) ;
+  //
+  preferences.putString ( "preset",      "6" ) ;
+  preferences.putString ( "preset_00",   "109.206.96.34:8100                       #  0 - NAXI LOVE RADIO, Belgrade, Serbia" ) ;
+  preferences.putString ( "preset_01",   "airspectrum.cdnstream1.com:8114/1648_128 #  1 - Easy Hits Florida 128k" ) ;
+  preferences.putString ( "preset_02",   "us2.internet-radio.com:8050              #  2 - CLASSIC ROCK MIA WWW.SHERADIO.COM" ) ;
+  preferences.putString ( "preset_03",   "airspectrum.cdnstream1.com:8000/1261_192 #  3 - Magic Oldies Florida" ) ;
+  preferences.putString ( "preset_04",   "airspectrum.cdnstream1.com:8008/1604_128 #  4 - Magic 60s Florida 60s Classic Rock" ) ;
+  preferences.putString ( "preset_05",   "us1.internet-radio.com:8105              #  5 - Classic Rock Florida - SHE Radio" ) ;
+  preferences.putString ( "preset_06",   "icecast.omroep.nl:80/radio1-bb-mp3       #  6 - Radio 1, NL" ) ;
+  preferences.putString ( "preset_07",   "205.164.62.15:10032                      #  7 - 1.FM - GAIA, 64k" ) ;
+  preferences.putString ( "preset_08",   "skonto.ls.lv:8002/mp3                    #  8 - Skonto 128k" ) ;
+  preferences.putString ( "preset_09",   "94.23.66.155:8106                        #  9 - *ILR CHILL and GROOVE" ) ;
+  preferences.putString ( "preset_10",   "ihr/IHR_IEDM                             # 10 - iHeartRadio IHR_IEDM" ) ;
+  preferences.putString ( "preset_11",   "ihr/IHR_TRAN                             # 11 - iHeartRadio IHR_TRAN" ) ;
+  //
+  preferences.putString ( "clk_server",  "pool.ntp.org" ) ;        // Setting for Time Of Day clock on TFT
+  preferences.putString ( "clk_offset",  "1" ) ;
+  preferences.putString ( "clk_dst",     "1" ) ;
+  //
+  preferences.putString ( "pin_ir",      "35                                     # GPIO Pin number for IR receiver VS1838B" ) ;
+  preferences.putString ( "ir_40BF",     "upvolume = 2" ) ;
+  preferences.putString ( "ir_C03F",     "downvolume = 2" ) ;
+  //
+  preferences.putString ( "pin_vs_cs",   "5                                      # GPIO Pin number for VS1053 CS" ) ;
+  preferences.putString ( "pin_vs_dcs",  "16                                     # GPIO Pin number for VS1053 DCS" ) ;
+  preferences.putString ( "pin_vs_dreq", "4                                      # GPIO Pin number for VS1053 DREQ" ) ;
+  //
+  preferences.putString ( "pin_enc_clk", "25                                     # GPIO Pin number for rotary encoder CLK" ) ;
+  preferences.putString ( "pin_enc_dt",  "26                                     # GPIO Pin number for rotary encoder DT" ) ;
+  preferences.putString ( "pin_enc_sw",  "27                                     # GPIO Pin number for rotary encoder SW" ) ;
+  //
+  preferences.putString ( "pin_tft_cs",  "15                                     # GPIO Pin number for TFT CS" ) ;
+  preferences.putString ( "pin_tft_dc",  "2                                      # GPIO Pin number for TFT DC" ) ;
+  //
+  preferences.putString ( "pin_sd_cs",   "21                                     # GPIO Pin number for SD card CS" ) ;
+
+  preferences.end() ;
+  delay ( 1000 ) ;
+}
+
+
+//******************************************************************************************
+//                              L O O P                                                    *
+//******************************************************************************************
+void loop()
+{
+  Serial.println ( "ESP32_radio_init completed..." ) ;
+  delay ( 10000 ) ;
+}