commit cab552d78cac570703d7f8f5548f9a4924817d7c
Author: Xavier <magnum88@libertysurf.fr>
Date:   Wed Aug 24 08:28:06 2022 +0200

    first commit

diff --git a/Display.pdf b/Display.pdf
new file mode 100755
index 0000000..b9083bc
Binary files /dev/null and b/Display.pdf differ
diff --git a/README.md b/README.md
new file mode 100755
index 0000000..1e1f4cf
--- /dev/null
+++ b/README.md
@@ -0,0 +1,91 @@
+  RadioSonde Version 0.8.5
+============================
+<img src="http://xavier.debert.free.fr/RS/TTGO.jpg" width="50%"><img src="http://xavier.debert.free.fr/RS/TTGO2.jpg" width="50%">
+<img src="http://xavier.debert.free.fr/RS/TTGO3.jpg" width="50%"><img src="http://xavier.debert.free.fr/RS/TTGO4.jpg" width="50%"><img src="http://xavier.debert.free.fr/RS/TTGO5.jpg" width="50%">
+<img src="http://xavier.debert.free.fr/RS/Web4.png" width="20%"><img src="http://xavier.debert.free.fr/RS/Web.png" width="20%">
+<img src="http://xavier.debert.free.fr/RS/Web3.png" width="20%"><img src="http://xavier.debert.free.fr/RS/Web2.png" width="20%">
+<img src="http://xavier.debert.free.fr/RS/Web5.png" width="20%">
+
+
+Projet basé sur le travail de DL9RDZ
+====================================
+
+Pour TTGO LORA 32 esp32 pico D4
+Décodage de RadioSonde RS41 and DFM06/09 et M10
+
+Attention à la version de votre TTGO!
+vous devez modifier dans config.txt, le port de l'écran OLED 
+-  TTGO v1:  SDA=4  SCL=15, RST=16 
+-  TTGO v2:  SDA=21 SCL=22, RST=16
+
+## Version en production 0.8.5 et devel 0.8.7
+
+## 0.8.0 
+travail de refonte et réécriture du code
+## 0.8.1 
+modification de la partie Web
+## 0.8.5 
+Evolution majeur du système 
+affichage du pourcentage de la batterie en mode scanning
+création d'une fenetre Batterie, Boussole
+suppresion lib et code TFT
+création Azimute, elevation correction de Bugs majeur , mineur
+Ajout fonction Smetre, Buzzer, QTH,  Gps on off ...
+mise à jour OTA
+trop de modification pour toutes les expliciter!
+
+
+## Les Boutons optionnel à ajouter(souder)
+sur les GPIO 1002 et 1004 
+attention:
+
++5V--[ SW ]---GPIO----[  R1  ]---/   R1=10 ou 12KOhms
+
+- appuie court	        <1.5 seconds
+- appuie double court   0.5 seconds
+- appuie moyen          2-4 seconds
+- appuie long           >5 seconds
+
+## Wifi configuration
+
+Au démarrage, si aucune connexion possible au wifi paramètré, il monte un Wifi AP
+le SSID et mot de passe par défaut est: Radiosonde
+en mode AP, il doit être en 192.168.4.1,
+mais vous avez aussi la possibilité de mettre http://radiosonde.local dans n'importe quel Wifi 
+connecté.
+
+
+
+## Mode Scanne
+
+Le fichier qrg.txt contient la liste par défaut des cannaux.
+pour y configurer les noms, fréquences et mode [M=M10, 6=DFM06, 9=DFM09 et 4=RS41]
+
+
+## Mode Réception
+
+En réception, une seul fréquence  est décodé, les infos de la sonde (ID, GPS, RSSI, ...)
+seront affichées dans plusieur fenetre à choisir ( 0 à 6) à configurer dans la page Web
+rubrique config.
+In receiving mode, a single frequency will be decoded, and sonde info (ID, GPS
+coordinates, RSSI) will be displayed. The bar above the IP address indicates,
+for the last 18 frames, if reception was successfull (|) or failed (.) 
+A DOUBLE press will switch to scanning mode.
+A SHORT press will switch to the next channel in channels.txt
+
+## Mode Analyseur
+
+Le mode analyseur de spectre (400..406 MHz) est affiché (chaque ligne == 50 kHz)
+Pour les cartes TTGO sans bouton configurable, il y a un nouveau paramètre dans config.txt:
+- spectrum=10       // 0=off / 1-99 nombre de seconds pour afficher l'analyseur
+- timer=1           // 0=off / 1= afficher le compte à rebours du spectre dans l'affichage du spectre
+- marker=1          // 0=off / 1= afficher la fréquence dans l'affichage du spectre
+
+## Setup
+
+voir Setup.md pour l'installation!
+
+73
+Xavier
+
+
diff --git a/RadioSonde_FSK/RadioSonde_FSK.ino b/RadioSonde_FSK/RadioSonde_FSK.ino
new file mode 100755
index 0000000..0bc9f5e
--- /dev/null
+++ b/RadioSonde_FSK/RadioSonde_FSK.ino
@@ -0,0 +1,2412 @@
+#include <axp20x.h>
+
+#include <WiFi.h>
+#include <WiFiUdp.h>
+#include <ESPAsyncWebServer.h>
+
+#include <SPIFFS.h>
+//#include <U8x8lib.h>
+//#include <U8g2lib.h>
+#include <SPI.h>
+#include <Update.h>
+#include <ESPmDNS.h>
+#include <MicroNMEA.h>
+#include <Ticker.h>
+
+#include <SX1278FSK.h>
+#include <Sonde.h>
+#include <Display.h>
+#include <Scanner.h>
+#include <aprs.h>
+#include "version.h"
+#include "geteph.h"
+#include "rs92gps.h"
+
+
+int e;
+enum MainState { ST_DECODER, ST_SPECTRUM, ST_WIFISCAN, ST_UPDATE, ST_TOUCHCALIB };
+static MainState mainState = ST_WIFISCAN; // ST_WIFISCAN;
+
+AsyncWebServer server(80);
+AsyncWebSocket ws("/ws");
+
+AXP20X_Class axp;
+#define PMU_IRQ             35
+SemaphoreHandle_t axpSemaphore;
+bool pmu_irq = false;
+
+String updateHost = "xavier.debert.free.fr";
+int updatePort = 80;
+String updateBinM = "/RS/radiosonde/update.ino.bin";
+String updateBinD = "/RS/radiosondedevel/update.ino.bin";
+String *updateBin = &updateBinM;
+
+#define LOCALUDPPORT 9002
+
+boolean connected = false;
+WiFiUDP udp;
+WiFiClient client;
+
+// KISS over TCP für communicating with APRSdroid
+WiFiServer tncserver(14580);
+WiFiClient tncclient;
+
+boolean forceReloadScreenConfig = false;
+
+enum KeyPress { KP_NONE = 0, KP_SHORT, KP_DOUBLE, KP_MID, KP_LONG };
+
+// "doublepress" is now also used to eliminate key glitch on TTGO T-Beam startup (SENSOR_VN/GPIO39)
+struct Button {
+  uint8_t pin;
+  uint32_t numberKeyPresses;
+  KeyPress pressed;
+  unsigned long keydownTime;
+  int8_t doublepress;
+  bool isTouched;
+};
+Button button1 = {0, 0, KP_NONE, 0, -1, false};
+Button button2 = {0, 0, KP_NONE, 0, -1, false};
+
+static int lastDisplay = 1;
+static int currentDisplay = 1;
+
+// timestamp when spectrum display was activated
+static unsigned long specTimer;
+
+// Read line from file, independent of line termination (LF or CR LF)
+String readLine(Stream &stream) {
+  String s = stream.readStringUntil('\n');
+  int len = s.length();
+  if (len == 0) return s;
+  if (s.charAt(len - 1) == '\r') s.remove(len - 1);
+  return s;
+}
+
+// Read line from file, without using dynamic memory allocation (String class)
+// returns length line.
+int readLine(Stream &stream, char *buffer, int maxlen) {
+  int n = stream.readBytesUntil('\n', buffer, maxlen);
+  buffer[n] = 0;
+  if(n <= 0) return 0;
+  if(buffer[n-1]=='\r') { buffer[n-1]=0; n--; }
+  return n;
+}
+
+// Replaces placeholder with LED state value
+String processor(const String& var) {
+  Serial.println(var);
+  if (var == "VERSION_NAME") {
+    return String(version_name);
+  }
+  if (var == "VERSION_ID") {
+    return String(version_id);
+  }
+  if (var == "AUTODETECT_INFO") {
+    char tmpstr[128];
+    const char *fpstr;
+    int i = 0;
+    while (fingerprintValue[i] != sonde.fingerprint && fingerprintValue[i] != -1) i++;
+    if (fingerprintValue[i] == -1) {
+      fpstr = "Unknown board";
+    } else {
+      fpstr = fingerprintText[i];
+    }
+    snprintf(tmpstr, 128, "Fingerprint %d (%s)", sonde.fingerprint, fpstr);
+    return String(tmpstr);
+  }
+  return String();
+}
+
+const String sondeTypeSelect(int activeType) {
+  String sts = "";
+  for (int i = 0; i < NSondeTypes; i++) {
+    sts += "<option value=\"";
+    sts += sondeTypeStr[i];
+    sts += "\"";
+    if (activeType == i) {
+      sts += " selected";
+    }
+    sts += ">";
+    sts += sondeTypeStr[i];
+    sts += "</option>";
+  }
+  return sts;
+}
+
+
+//trying to work around
+//"assertion "heap != NULL && "free() target pointer is outside heap areas"" failed:"
+// which happens if request->send is called in createQRGForm!?!??
+char message[10240 * 4]; //needs to be large enough for all forms (not checked in code)
+// QRG form is currently about 24kb with 100 entries
+
+///////////////////////// Functions for Reading / Writing QRG list from/to qrg.txt
+
+void setupChannelList() {
+  File file = SPIFFS.open("/qrg.txt", "r");
+  if (!file) {
+    Serial.println("There was an error opening the file '/qrg.txt' for reading");
+    return;
+  }
+  int i = 0;
+  char launchsite[17] = "                ";
+  sonde.clearSonde();
+  Serial.println("Reading channel config:");
+  while (file.available()) {
+    String line = readLine(file);   //file.readStringUntil('\n');
+    String sitename;
+    if (!file.available()) break;
+    if (line[0] == '#') continue;
+    char *space = strchr(line.c_str(), ' ');
+    if (!space) continue;
+    *space = 0;
+    float freq = atof(line.c_str());
+    SondeType type;
+    if (space[1] == '4') {
+      type = STYPE_RS41;
+    } else if (space[1] == 'R') {
+      type = STYPE_RS92;
+    }
+    else if (space[1] == '9') {
+      type = STYPE_DFM09;
+    }
+    else if (space[1] == '6') {
+      type = STYPE_DFM06;
+    }
+    else if (space[1] == 'M') {
+      type = STYPE_M10;
+    }
+    else continue;
+    int active = space[3] == '+' ? 1 : 0;
+    if (space[4] == ' ') {
+      memset(launchsite, ' ', 16);
+      int str_len = strlen(space + 5);
+      strncpy(launchsite, space + 5, str_len > 16 ? 16 : str_len);
+      if (sonde.config.debug == 1) {
+        Serial.printf("Add %f - sondetype: %d (on/off: %d) - site #%d - name: %s\n ", freq, type, active, i, launchsite);
+      }
+    }
+    sonde.addSonde(freq, type, active, launchsite);
+    i++;
+  }
+  file.close();
+}
+
+const char *createQRGForm() {
+  char *ptr = message;
+  strcpy(ptr, "<html><head><link rel=\"stylesheet\" type=\"text/css\" href=\"style.css\"></head><body><form action=\"qrg.html\" method=\"post\"><table><tr><th>ID</th><th>Active</th><th>Freq</th><th>Launchsite</th><th>Mode</th></tr>");
+  for (int i = 0; i < sonde.config.maxsonde; i++) {
+    String s = sondeTypeSelect(i >= sonde.nSonde ? 2 : sonde.sondeList[i].type);
+    String site = sonde.sondeList[i].launchsite;
+    sprintf(ptr + strlen(ptr), "<tr><td>%d</td><td><input name=\"A%d\" type=\"checkbox\" %s/></td>"
+            "<td><input name=\"F%d\" type=\"text\" value=\"%3.3f\"></td>"
+            "<td><input name=\"S%d\" type=\"text\" value=\"%s\"></td>"
+            "<td><select name=\"T%d\">%s</select></td>",
+            i + 1,
+            i + 1, (i < sonde.nSonde && sonde.sondeList[i].active) ? "checked" : "",
+            i + 1, i >= sonde.nSonde ? 400.000 : sonde.sondeList[i].freq,
+            i + 1, i >= sonde.nSonde ? "                " : sonde.sondeList[i].launchsite,
+            i + 1, s.c_str());
+  }
+  strcat(ptr, "</table><input type=\"submit\" value=\"Update\"/></form></body></html>");
+  Serial.printf("QRG form: size=%d bytes\n",strlen(message));
+  return message;
+}
+
+const char *handleQRGPost(AsyncWebServerRequest *request) {
+  char label[10];
+  // parameters: a_i, f_1, t_i  (active/frequency/type)
+#if 1
+  File file = SPIFFS.open("/qrg.txt", "w");
+  if (!file) {
+    Serial.println("Error while opening '/qrg.txt' for writing");
+    return "Error while opening '/qrg.txt' for writing";
+  }
+#endif
+  Serial.println("Handling post request");
+#if 0
+  int params = request->params();
+  for (int i = 0; i < params; i++) {
+    String pname = request->getParam(i)->name();
+    Serial.println(pname.c_str());
+  }
+#endif
+  for (int i = 1; i <= sonde.config.maxsonde; i++) {
+    snprintf(label, 10, "A%d", i);
+    AsyncWebParameter *active = request->getParam(label, true);
+    snprintf(label, 10, "F%d", i);
+    AsyncWebParameter *freq = request->getParam(label, true);
+    snprintf(label, 10, "S%d", i);
+    AsyncWebParameter *launchsite = request->getParam(label, true);
+    if (!freq) continue;
+    snprintf(label, 10, "T%d", i);
+    AsyncWebParameter *type = request->getParam(label, true);
+    if (!type) continue;
+    String fstring = freq->value();
+    String tstring = type->value();
+    String sstring = launchsite->value();
+    const char *fstr = fstring.c_str();
+    const char *tstr = tstring.c_str();
+    const char *sstr = sstring.c_str();
+    Serial.printf("Processing a=%s, f=%s, t=%s, site=%s\n", active ? "YES" : "NO", fstr, tstr, sstr);
+    char typech = (tstr[2] == '4' ? '4' : tstr[2] == '9' ? 'R' : tstr[0] == 'M' ? 'M' : tstr[3]); // a bit ugly
+    file.printf("%3.3f %c %c %s\n", atof(fstr), typech, active ? '+' : '-', sstr);
+  }
+  file.close();
+
+  Serial.println("Channel setup finished");
+  Serial.println();
+  delay(500);
+  setupChannelList();
+  return "";
+}
+
+
+/////////////////// Functions for reading/writing Wifi networks from networks.txt
+
+#define MAX_WIFI 10
+int nNetworks;
+struct {
+  String id;
+  String pw;
+} networks[MAX_WIFI];
+
+// FIXME: For now, we don't uspport wifi networks that contain newline or null characters
+// ... would require a more sophisicated file format (currently one line SSID; one line Password
+void setupWifiList() {
+  File file = SPIFFS.open("/networks.txt", "r");
+  if (!file) {
+    Serial.println("There was an error opening the file '/networks.txt' for reading");
+    networks[0].id = "Radiosonde";
+    networks[0].pw = "Radiosonde";
+    return;
+  }
+  int i = 0;
+
+  while (file.available()) {
+    String line = readLine(file);  //file.readStringUntil('\n');
+    if (!file.available()) break;
+    networks[i].id = line;
+    networks[i].pw = readLine(file); // file.readStringUntil('\n');
+    i++;
+  }
+  nNetworks = i;
+  Serial.print(i); Serial.println(" networks in networks.txt\n");
+  for (int j = 0; j < i; j++) {
+    Serial.print(networks[j].id);
+    Serial.print(": ");
+    Serial.println(networks[j].pw);
+  }
+}
+
+
+const char *createWIFIForm() {
+  char *ptr = message;
+  char tmp[4];
+  strcpy(ptr, "<html><head><link rel=\"stylesheet\" type=\"text/css\" href=\"style.css\"></head><body><form action=\"wifi.html\" method=\"post\"><table><tr><th>Nr</th><th>SSID</th><th>Password</th></tr>");
+  for (int i = 0; i < MAX_WIFI; i++) {
+    sprintf(tmp, "%d", i);
+    sprintf(ptr + strlen(ptr), "<tr><td>%s</td><td><input name=\"S%d\" type=\"text\" value=\"%s\"/></td>"
+            "<td><input name=\"P%d\" type=\"text\" value=\"%s\"/></td>",
+            i == 0 ? "<b>AP</b>" : tmp,
+            i + 1, i < nNetworks ? networks[i].id.c_str() : "",
+            i + 1, i < nNetworks ? networks[i].pw.c_str() : "");
+  }
+  strcat(ptr, "</table><input type=\"submit\" value=\"Update\"></input></form></body></html>");
+  Serial.printf("WIFI form: size=%d bytes\n",strlen(message));
+  return message;
+}
+
+const char *handleWIFIPost(AsyncWebServerRequest *request) {
+  char label[10];
+  // parameters: a_i, f_1, t_i  (active/frequency/type)
+#if 1
+  File f = SPIFFS.open("/networks.txt", "w");
+  if (!f) {
+    Serial.println("Error while opening '/networks.txt' for writing");
+    return "Error while opening '/networks.txt' for writing";
+  }
+#endif
+  Serial.println("Handling post request");
+#if 0
+  int params = request->params();
+  for (int i = 0; i < params; i++) {
+    String param = request->getParam(i)->name();
+    Serial.println(param.c_str());
+  }
+#endif
+  for (int i = 1; i <= MAX_WIFI; i++) {
+    snprintf(label, 10, "S%d", i);
+    AsyncWebParameter *ssid = request->getParam(label, true);
+    if (!ssid) continue;
+    snprintf(label, 10, "P%d", i);
+    AsyncWebParameter *pw = request->getParam(label, true);
+    if (!pw) continue;
+    String sstring = ssid->value();
+    String pstring = pw->value();
+    const char *sstr = sstring.c_str();
+    const char *pstr = pstring.c_str();
+    if (strlen(sstr) == 0) continue;
+    Serial.printf("Processing S=%s, P=%s\n", sstr, pstr);
+    f.printf("%s\n%s\n", sstr, pstr);
+  }
+  f.close();
+  setupWifiList();
+  return "";
+}
+
+// Show current status
+void addSondeStatus(char *ptr, int i)
+{
+  struct tm ts;
+  SondeInfo *s = &sonde.sondeList[i];
+  strcat(ptr, "<table>");
+  sprintf(ptr + strlen(ptr), "<tr><td id=\"sfreq\">%3.3f MHz, Type: %s</td><tr><td>ID: %s", s->freq, sondeTypeStr[s->type],
+          s->validID ? s->id : "<?""?>");
+  if (s->validID && (s->type == STYPE_DFM06 || s->type == STYPE_DFM09 || s->type == STYPE_M10)) {
+    sprintf(ptr + strlen(ptr), " (ser: %s)", s->ser);
+  }
+  sprintf(ptr + strlen(ptr), "</td></tr><tr><td>QTH: %.6f,%.6f h=%.0fm</td></tr>\n", s->lat, s->lon, s->alt);
+  const time_t t = s->time;
+  ts = *gmtime(&t);
+  sprintf(ptr + strlen(ptr), "<tr><td>Frame# %d, Sats=%d, %04d-%02d-%02d %02d:%02d:%02d</td></tr>",
+          s->frame, s->sats, ts.tm_year + 1900, ts.tm_mon + 1, ts.tm_mday, ts.tm_hour, ts.tm_min, ts.tm_sec + s->sec);
+  if (s->type == STYPE_RS41) {
+    sprintf(ptr + strlen(ptr), "<tr><td>Burst-KT=%d Launch-KT=%d Countdown=%d (vor %ds)</td></tr>\n",
+            s->burstKT, s->launchKT, s->countKT, ((uint16_t)s->frame - s->crefKT));
+  }
+  sprintf(ptr + strlen(ptr), "<tr><td><a target=\"_empty\" href=\"geo:%.6f,%.6f\">GEO-App</a> - ", s->lat, s->lon);
+  sprintf(ptr + strlen(ptr), "<a target=\"_empty\" href=\"https://tracker.sondehub.org/?sondehub=1#!mt=osm&mz=8&qm=6_hours&mc=%.6f,%.6f&q=RS_%s\">Sondehub</a> - ", s->lat, s->lon, s->id);
+  sprintf(ptr + strlen(ptr), "<a target=\"_empty\" href=\"https://www.openstreetmap.org/?mlat=%.6f&mlon=%.6f&zoom=14\">OSM</a></td></tr>", s->lat, s->lon);
+  strcat(ptr, "</table><p/>\n");
+}
+
+const char *createStatusForm() {
+  char *ptr = message;
+  strcpy(ptr, "<html><head><link rel=\"stylesheet\" type=\"text/css\" href=\"style.css\"><meta http-equiv=\"refresh\" content=\"5\"></head><body>");
+
+  for (int i = 0; i < sonde.nSonde; i++) {
+    int snum = (i + sonde.currentSonde) % sonde.nSonde;
+    if (sonde.sondeList[snum].active) {
+      addSondeStatus(ptr, snum);
+    }
+  }
+  strcat(ptr, "</body></html>");
+  Serial.printf("Status form: size=%d bytes\n",strlen(message));
+  return message;
+}
+
+///////////////////// Config form
+
+
+void setupConfigData() {
+  File file = SPIFFS.open("/config.txt", "r");
+  if (!file) {
+    Serial.println("There was an error opening the file '/config.txt' for reading");
+    return;
+  }
+  while (file.available()) {
+    String line = readLine(file);  //file.readStringUntil('\n');
+    sonde.setConfig(line.c_str());
+  }
+}
+
+
+struct st_configitems {
+  const char *name;
+  const char *label;
+  int type;  // 0: numeric; i>0 string of length i; -1: separator; -2: type selector
+  void *data;
+};
+
+struct st_configitems config_list[] = {
+
+  /* General config settings */
+  {"", "Software configuration", -5, NULL},
+  {"wifi", "Wifi mode (0/1/2/3)", 0, &sonde.config.wifi},
+  {"debug", "Debug mode (0/1)", 0, &sonde.config.debug},
+  {"maxsonde", "Maxsonde", 0, &sonde.config.maxsonde},
+  {"display", "Display screens (scan,default,...)", -6, sonde.config.display},
+  /* Spectrum display settings */
+  {"spectrum", "Show spectrum (-1=no, 0=forever, >0=seconds)", 0, &sonde.config.spectrum},
+  {"startfreq", "Startfreq (MHz)", 0, &sonde.config.startfreq},
+  {"channelbw", "Bandwidth (kHz)", 0, &sonde.config.channelbw},
+  {"marker", "Spectrum MHz marker", 0, &sonde.config.marker},
+  {"noisefloor", "Sepctrum noisefloor", 0, &sonde.config.noisefloor},
+  /* decoder settings */
+  {"", "Receiver configuration", -5, NULL},
+  {"showafc", "Show AFC value", 0, &sonde.config.showafc},
+  {"freqofs", "RX frequency offset (Hz)", 0, &sonde.config.freqofs},
+  {"rs41.agcbw", "RS41 AGC bandwidth", 0, &sonde.config.rs41.agcbw},
+  {"rs41.rxbw", "RS41 RX bandwidth", 0, &sonde.config.rs41.rxbw},
+  {"rs92.rxbw", "RS92 RX (and AGC) bandwidth", 0, &sonde.config.rs92.rxbw},
+  {"rs92.alt2d", "RS92 2D fix default altitude", 0, &sonde.config.rs92.alt2d},
+  {"dfm.agcbw", "DFM6/9 AGC bandwidth", 0, &sonde.config.dfm.agcbw},
+  {"dfm.rxbw", "DFM6/9 RX bandwidth", 0, &sonde.config.dfm.rxbw},
+  {"", "Data feed configuration", -5, NULL},
+  /* APRS settings */
+  {"call", "Call", 8, sonde.config.call},
+  {"passcode", "Passcode", 8, sonde.config.passcode},
+  /* KISS tnc settings */
+  {"kisstnc.active", "KISS TNC (port 14590) (needs reboot)", 0, &sonde.config.kisstnc.active},
+  {"kisstnc.idformat", "KISS TNC ID Format", -2, &sonde.config.kisstnc.idformat},
+  /* AXUDP settings */
+  {"axudp.active", "AXUDP active", -3, &sonde.config.udpfeed.active},
+  {"axudp.host", "AXUDP Host", 63, sonde.config.udpfeed.host},
+  {"axudp.port", "AXUDP Port", 0, &sonde.config.udpfeed.port},
+  {"axudp.idformat", "DFM ID Format", -2, &sonde.config.udpfeed.idformat},
+  {"axudp.highrate", "Rate limit", 0, &sonde.config.udpfeed.highrate},
+  /* APRS TCP settings, current not used */
+  {"tcp.active", "APRS TCP active", -3, &sonde.config.tcpfeed.active},
+  {"tcp.host", "ARPS TCP Host", 63, sonde.config.tcpfeed.host},
+  {"tcp.port", "APRS TCP Port", 0, &sonde.config.tcpfeed.port},
+  {"tcp.idformat", "DFM ID Format", -2, &sonde.config.tcpfeed.idformat},
+  {"tcp.highrate", "Rate limit", 0, &sonde.config.tcpfeed.highrate},
+  /* Hardware dependeing settings */
+  {"", "Hardware configuration (requires reboot)", -5, NULL},
+  {"disptype", "Display type (0=OLED/SSD1306, 1=TFT/ILI9225, 2=OLED/SH1106)", 0, &sonde.config.disptype},
+  {"norx_timeout", "No-RX-Timeout in seconds (-1=disabled)", 0, &sonde.config.norx_timeout},
+  {"oled_sda", "OLED SDA SDA", 0, &sonde.config.oled_sda},
+  {"oled_scl", "OLED SCL CLK", 0, &sonde.config.oled_scl},
+  {"oled_rst", "OLED RST (needs reboot)", 0, &sonde.config.oled_rst},
+  {"oled_orient", "Oled orientation default 1, OLED flip: 3", 0, &sonde.config.oled_orient},
+  {"button_pin", "Button input port", -4, &sonde.config.button_pin},
+  {"button2_pin", "Button 2 input port", -4, &sonde.config.button2_pin},
+  {"button2_axp", "Use AXP192 PWR as Button 2", 0, &sonde.config.button2_axp},
+  {"touch_thresh", "Touch button threshold<br>(0 for calib mode)", 0, &sonde.config.touch_thresh},
+  {"power_pout", "Power control port", 0, &sonde.config.power_pout},
+  {"led_pout", "LED output port", 0, &sonde.config.led_pout},
+  {"gpsOn", "GPS Active (0=disabled / 1=enabled)", 0, &sonde.config.gpsOn}, 
+  {"gps_rxd", "GPS RXD pin (-1 to disable)", 0, &sonde.config.gps_rxd},
+  {"gps_txd", "GPS TXD pin (not really needed)", 0, &sonde.config.gps_txd},
+  {"gps_lon", "QTH longitude for no GPS", 8, sonde.config.gps_lon}, 
+  {"gps_lat", "QTH latitude for no GPS", 8, sonde.config.gps_lat},
+  {"gps_alt", "QTH Altidute for no GPS", 0, &sonde.config.gps_alt},
+  {"mdnsname", "mDNS name", 14, &sonde.config.mdnsname},
+  {"vbatmax", "VBat Max", 5, sonde.config.vbatmax},
+  {"vbatmin", "VBat Min", 5, sonde.config.vbatmin},
+  {"sdOn", "SDCard (0=Disabled, 1 Enable)", 0, &sonde.config.sdOn},
+  {"buzzerOn", "Buzzer (0=Disabled, 1 Enable)", 0, &sonde.config.buzzerOn},
+  {"buzzerPort", "Buzzer Port (12)", 0, &sonde.config.buzzerPort},
+  {"buzzerFreq", "Buzzer Frequency (700)", 0, &sonde.config.buzzerFreq},
+  {"dbsmetre", "dB = 0 / Smetre =1)", 0, &sonde.config.dbsmetre}, 
+};
+const static int N_CONFIG = (sizeof(config_list) / sizeof(struct st_configitems));
+
+void addConfigStringEntry(char *ptr, int idx, const char *label, int len, char *field) {
+  sprintf(ptr + strlen(ptr), "<tr><td>%s</td><td><input name=\"CFG%d\" type=\"text\" value=\"%s\"/></td></tr>\n",
+          label, idx, field);
+}
+void addConfigNumEntry(char *ptr, int idx, const char *label, int *value) {
+  sprintf(ptr + strlen(ptr), "<tr><td>%s</td><td><input name=\"CFG%d\" type=\"text\" value=\"%d\"/></td></tr>\n",
+          label, idx, *value);
+}
+void addConfigButtonEntry(char *ptr, int idx, const char *label, int *value) {
+  int v = *value, ck = 0;
+  if (v == 255) v = -1;
+  if (v != -1) {
+    if (v & 128) ck = 1;
+    v = v & 127;
+  }
+
+  sprintf(ptr + strlen(ptr), "<tr><td>%s</td><td><input name=\"CFG%d\" type=\"text\" size=\"3\" value=\"%d\"/>",
+          label, idx, v);
+  sprintf(ptr + strlen(ptr), "<input type=\"checkbox\" name=\"TO%d\"%s> Touch </td></tr>\n", idx, ck ? " checked" : "");
+}
+void addConfigTypeEntry(char *ptr, int idx, const char *label, int *value) {
+  // TODO
+}
+void addConfigOnOffEntry(char *ptr, int idx, const char *label, int *value) {
+  // TODO
+}
+void addConfigSeparatorEntry(char *ptr) {
+  strcat(ptr, "<tr><td colspan=\"2\" class=\"divider\"><hr /></td></tr>\n");
+}
+void addConfigHeading(char *ptr, const char *label) {
+  strcat(ptr, "<tr><th colspan=\"2\">");
+  strcat(ptr, label);
+  strcat(ptr, "</th></tr>\n");
+}
+void addConfigInt8List(char *ptr, int idx, const char *label, int8_t *list) {
+  sprintf(ptr + strlen(ptr), "<tr><td>%s", label);
+  for (int i = 0; i < disp.nLayouts; i++) {
+    sprintf(ptr + strlen(ptr), "<br>%d=%s", i, disp.layouts[i].label);
+  }
+  sprintf(ptr + strlen(ptr), "</td><td><input name=\"CFG%d\" type=\"text\" value=\"", idx);
+  if (*list == -1) {
+    strcat(ptr, "0");
+  }
+  else {
+    sprintf(ptr + strlen(ptr), "%d", list[0]);
+    list++;
+  }
+  while (*list != -1) {
+    sprintf(ptr + strlen(ptr), ",%d", *list);
+    list++;
+  }
+  strcat(ptr, "\"/></td></tr>\n");
+}
+
+const char *createConfigForm() {
+  char *ptr = message;
+  strcpy(ptr, "<html><head><link rel=\"stylesheet\" type=\"text/css\" href=\"style.css\"></head><body><form action=\"config.html\" method=\"post\"><table><tr><th>Option</th><th>Value</th></tr>");
+  for (int i = 0; i < N_CONFIG; i++) {
+    switch (config_list[i].type) {
+      case -5: // Heading
+        addConfigHeading(ptr, config_list[i].label);
+        break;
+      case -6: // List of int8 values
+        addConfigInt8List(ptr, i, config_list[i].label, (int8_t *)config_list[i].data);
+        break;
+      case -3: // in/offt
+        addConfigOnOffEntry(ptr, i, config_list[i].label, (int *)config_list[i].data);
+        break;
+      case -2: // DFM format
+        addConfigTypeEntry(ptr, i, config_list[i].label, (int *)config_list[i].data);
+        break;
+      case -1:
+        addConfigSeparatorEntry(ptr);
+        break;
+      case 0:
+        addConfigNumEntry(ptr, i, config_list[i].label, (int *)config_list[i].data);
+        break;
+      case -4:
+        addConfigButtonEntry(ptr, i, config_list[i].label, (int *)config_list[i].data);
+        break;
+      default:
+        addConfigStringEntry(ptr, i, config_list[i].label, config_list[i].type, (char *)config_list[i].data);
+        break;
+    }
+  }
+  strcat(ptr, "</table><input type=\"submit\" value=\"Update\"></input></form></body></html>");
+  Serial.printf("Config form: size=%d bytes\n",strlen(message));
+  return message;
+}
+
+
+const char *handleConfigPost(AsyncWebServerRequest *request) {
+  // parameters: a_i, f_1, t_i  (active/frequency/type)
+  Serial.println("Handling post request");
+#if 1
+  File f = SPIFFS.open("/config.txt", "w");
+  if (!f) {
+    Serial.println("Error while opening '/config.txt' for writing");
+    return "Error while opening '/config.txt' for writing";
+  }
+#endif
+  Serial.println("File open for writing.");
+#if 1
+  int params = request->params();
+  for (int i = 0; i < params; i++) {
+    String param = request->getParam(i)->name();
+    Serial.println(param.c_str());
+  }
+#endif
+  for (int i = 0; i < params; i++) {
+    String strlabel = request->getParam(i)->name();
+    const char *label = strlabel.c_str();
+    if (strncmp(label, "CFG", 3) != 0) continue;
+    int idx = atoi(label + 3);
+    Serial.printf("idx is %d\n", idx);
+    if (config_list[idx].type == -1) continue; // skip separator entries, should not happen
+    AsyncWebParameter *value = request->getParam(label, true);
+    if (!value) continue;
+    String strvalue = value->value();
+    if (config_list[idx].type == -4) {  // input button port with "touch" checkbox
+      char tmp[10];
+      snprintf(tmp, 10, "TO%d", idx);
+      AsyncWebParameter *touch = request->getParam(tmp, true);
+      if (touch) {
+        int i = atoi(strvalue.c_str());
+        if (i != -1 && i != 255) i += 128;
+        strvalue = String(i);
+      }
+    }
+    Serial.printf("Processing  %s=%s\n", config_list[idx].name, strvalue.c_str());
+    int wlen = f.printf("%s=%s\n", config_list[idx].name, strvalue.c_str());
+    Serial.printf("Written bytes: %d\n", wlen);
+  }
+  Serial.printf("Flushing file\n");
+  f.flush();
+  Serial.printf("Closing file\n");
+  f.close();
+  Serial.printf("Re-reading file file\n");
+  setupConfigData();
+  return "";
+}
+
+const char *ctrlid[] = {"rx", "scan", "spec", "wifi", "rx2", "scan2", "spec2", "wifi2"};
+
+const char *ctrllabel[] = {"Receiver (short keypress)", "Scanner (double keypress)", "Spectrum (medium keypress)", "WiFi (long keypress)",
+                           "Button 2 (short keypress)", "Button 2 (double keypress)", "Button 2 (medium keypress)", "Button 2 (long keypress)"
+                          };
+
+const char *createControlForm() {
+  char *ptr = message;
+  strcpy(ptr, "<html><head><link rel=\"stylesheet\" type=\"text/css\" href=\"style.css\"></head><body><form action=\"control.html\" method=\"post\">");
+  for (int i = 0; i < 8; i++) {
+    strcat(ptr, "<input type=\"submit\" name=\"");
+    strcat(ptr, ctrlid[i]);
+    strcat(ptr, "\" value=\"");
+    strcat(ptr, ctrllabel[i]);
+    strcat(ptr, "\"></input><br><br>");
+  }
+  strcat(ptr, "</form></body></html>");
+  Serial.printf("Control form: size=%d bytes\n",strlen(message));
+  return message;
+}
+
+
+const char *handleControlPost(AsyncWebServerRequest *request) {
+  Serial.println("Handling post request");
+  int params = request->params();
+  for (int i = 0; i < params; i++) {
+    String param = request->getParam(i)->name();
+    Serial.println(param.c_str());
+    if (param.equals("rx")) {
+      Serial.println("equals rx");
+      button1.pressed = KP_SHORT;
+    }
+    else if (param.equals("scan")) {
+      Serial.println("equals scan");
+      button1.pressed = KP_DOUBLE;
+    }
+    else if (param.equals("spec")) {
+      Serial.println("equals spec");
+      button1.pressed = KP_MID;
+    }
+    else if (param.equals("wifi")) {
+      Serial.println("equals wifi");
+      button1.pressed = KP_LONG;
+    }
+    else if (param.equals("rx2")) {
+      Serial.println("equals rx2");
+      button2.pressed = KP_SHORT;
+    }
+    else if (param.equals("scan2")) {
+      Serial.println("equals scan2");
+      button2.pressed = KP_DOUBLE;
+    }
+    else if (param.equals("spec2")) {
+      Serial.println("equals spec2");
+      button2.pressed = KP_MID;
+    }
+    else if (param.equals("wifi2")) {
+      Serial.println("equals wifi2");
+      button2.pressed = KP_LONG;
+    }
+  }
+  return "";
+}
+
+// bad idea. prone to buffer overflow. use at your own risk...
+const char *createEditForm(String filename) {
+  char *ptr = message;
+  File file = SPIFFS.open("/" + filename, "r");
+  if (!file) {
+    Serial.println("There was an error opening the file '/config.txt' for reading");
+    return "<html><head><title>File not found</title></head><body>File not found</body></html>";
+  }
+
+  strcpy(ptr, "<html><head><title>Editor ");
+  strcat(ptr, filename.c_str());
+  strcat(ptr, "</title></head><body><form action=\"edit.html?file=");
+  strcat(ptr, filename.c_str());
+  strcat(ptr, "\" method=\"post\" enctype=\"multipart/form-data\">");
+  strcat(ptr, "<textarea name=\"text\" cols=\"80\" rows=\"40\">");
+  while (file.available()) {
+    String line = readLine(file);  //file.readStringUntil('\n');
+    strcat(ptr, line.c_str()); strcat(ptr, "\n");
+  }
+  strcat(ptr, "</textarea><input type=\"submit\" value=\"Save\"></input></form></body></html>");
+  Serial.printf("Edit form: size=%d bytes\n",strlen(message));
+  return message;
+}
+
+
+const char *handleEditPost(AsyncWebServerRequest *request) {
+  Serial.println("Handling post request");
+    int params = request->params();
+    Serial.printf("Post:, %d params\n", params);
+    for(int i = 0; i < params; i++) {
+      AsyncWebParameter* p = request->getParam(i);
+      String name = p->name();
+      String value = p->value();
+      if(name.c_str()==NULL) { name=String("NULL"); }
+      if(value.c_str()==NULL) { value=String("NULL"); }
+      if(p->isFile()){
+        Serial.printf("_FILE[%s]: %s, size: %u\n", name.c_str(), value.c_str(), p->size());
+      } else if(p->isPost()){
+        Serial.printf("_POST[%s]: %s\n", name.c_str(), value.c_str());
+      } else {
+        Serial.printf("_GET[%s]: %s\n", name.c_str(), value.c_str());
+      }
+    }
+
+  AsyncWebParameter *filep = request->getParam("file");
+  if (!filep) return NULL;
+  String filename = filep->value();
+  Serial.printf("Writing file <%s>\n",filename.c_str());
+  AsyncWebParameter *textp = request->getParam("text", true);
+  if (!textp) return NULL;
+  Serial.printf("Parameter size is %d\n", textp->size());
+  Serial.printf("Multipart: %d  contentlen=%d  \n",
+    request->multipart(), request->contentLength());
+  String content = textp->value();
+  if(content.length()==0) {
+    Serial.println("File is empty. Not written.");
+    return NULL;
+  }
+  File file = SPIFFS.open("/" + filename, "w");
+  if (!file) {
+    Serial.println("There was an error opening the file '/" + filename + "'for writing");
+    return "";
+  }
+  Serial.printf("File is open for writing, content is %d bytes\n", content.length());
+  int len = file.print(content);
+  file.close();
+  Serial.printf("Written: %d bytes\n", len);
+  if (strcmp(filename.c_str(), "screens.txt") == 0) {
+    // screens update => reload
+    forceReloadScreenConfig = true;
+  }
+  return "";
+}
+
+const char *createUpdateForm(boolean run) {
+  char *ptr = message;
+  strcpy(ptr, "<html><head><link rel=\"stylesheet\" type=\"text/css\" href=\"style.css\"></head><body><form action=\"update.html\" method=\"post\">");
+  if (run) {
+    strcat(ptr, "<p>Doing update, wait until reboot</p>");
+  } else {
+    strcat(ptr, "<input type=\"submit\" name=\"master\" value=\"Stable-Update\"></input><br><input type=\"submit\" name=\"devel\" value=\"Beta-Update\">");
+  }
+  strcat(ptr, "</form></body></html>");
+  Serial.printf("Update form: size=%d bytes\n",strlen(message));
+  return message;
+}
+
+const char *handleUpdatePost(AsyncWebServerRequest *request) {
+  Serial.println("Handling post request");
+  int params = request->params();
+  for (int i = 0; i < params; i++) {
+    String param = request->getParam(i)->name();
+    Serial.println(param.c_str());
+    if (param.equals("devel")) {
+      Serial.println("equals devel");
+      updateBin = &updateBinD;
+    }
+    else if (param.equals("master")) {
+      Serial.println("equals master");
+      updateBin = &updateBinM;
+    }
+  }
+  Serial.println("Updating: " + *updateBin);
+  enterMode(ST_UPDATE);
+  return "";
+}
+
+
+const char *sendGPX(AsyncWebServerRequest * request) {
+  Serial.println("\n\n\n********GPX request\n\n");
+  String url = request->url();
+  int index = atoi(url.c_str() + 1);
+  char *ptr = message;
+  if (index < 0 || index >= MAXSONDE) {
+    return "ERROR";
+  }
+  SondeInfo *si = &sonde.sondeList[index];
+  strcpy(si->id, "test");
+  si->lat = 48; si->lon = 11; si->alt = 500;
+  snprintf(ptr, 10240, "<?xml version='1.0' encoding='UTF-8'?>\n"
+           "<gpx version=\"1.1\" creator=\"http://radiosonde.local\" xmlns=\"http://www.topografix.com/GPX/1/1\" "
+           "xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" "
+           "xsi:schemaLocation=\"http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd\">\n"
+           "<metadata>"
+           "<name>Sonde #%d (%s)</name>\n"
+           "<author>rdzTTGOsonde</author>\n"
+           "</metadata>\n"
+           "<wpt lat=\"%f\" lon=\"%f\">\n  <ele>%f</ele>\n  <name>%s</name>\n  <sym>Radio Beacon</sym><type>Sonde</type>\n"
+           "</wpt></gpx>\n", index, si->id, si->lat, si->lon, si->alt, si->id);
+  Serial.println(message);
+  return message;
+}
+
+void onWsEvent(AsyncWebSocket * server, AsyncWebSocketClient * client, AwsEventType type, void * arg, uint8_t *data, size_t len) {
+  if (type == WS_EVT_CONNECT) {
+    Serial.println("Websocket client connection received");
+    client->text("Hello from ESP32 Server");
+  } else if (type == WS_EVT_DISCONNECT) {
+    Serial.println("Client disconnected");
+  }
+}
+#if 0
+void onWebSocketEvent(uint8_t clientNum, WStype_t type, uint8_t *payload, size_t length) {
+  switch (type) {
+    case WStype_DISCONNECTED:
+      Serial.printf("[%u] WS client disconnected\n", clientNum);
+      break;
+    case WStype_CONNECTED:
+      {
+        IPAddress ip = webSocket.remoteIP(clientNum);
+        Serial.printf("[%u] WS client connection from %s\n", clientNum, ip.toString().c_str());
+      }
+      break;
+    case WStype_TEXT:
+      //
+      {
+        char msg[80];
+        Serial.printf("[%u] WS client sent me some text: %s\n", clientNum, payload);
+        snprintf(msg, 80, "You sent me: %s\n", payload);
+        webSocket.sendTXT(clientNum, msg);
+      }
+      break;
+    default:
+      break;
+  }
+}
+#endif
+
+
+const char* PARAM_MESSAGE = "message";
+void SetupAsyncServer() {
+  Serial.println("SetupAsyncServer()\n");
+  server.reset();
+  // Route for root / web page
+  server.on("/", HTTP_GET, [](AsyncWebServerRequest * request) {
+    request->send(SPIFFS, "/index.html", String(), false, processor);
+  });
+
+  server.on("/index.html", HTTP_GET, [](AsyncWebServerRequest * request) {
+    request->send(SPIFFS, "/index.html", String(), false, processor);
+  });
+
+  server.on("/test.html", HTTP_GET, [](AsyncWebServerRequest * request) {
+    request->send(SPIFFS, "/test.html", String(), false, processor);
+  });
+
+  server.on("/qrg.html", HTTP_GET,  [](AsyncWebServerRequest * request) {
+    request->send(200, "text/html", createQRGForm());
+  });
+  server.on("/qrg.html", HTTP_POST, [](AsyncWebServerRequest * request) {
+    handleQRGPost(request);
+    request->send(200, "text/html", createQRGForm());
+  });
+
+  server.on("/wifi.html", HTTP_GET,  [](AsyncWebServerRequest * request) {
+    request->send(200, "text/html", createWIFIForm());
+  });
+  server.on("/wifi.html", HTTP_POST, [](AsyncWebServerRequest * request) {
+    handleWIFIPost(request);
+    request->send(200, "text/html", createWIFIForm());
+  });
+
+  server.on("/config.html", HTTP_GET,  [](AsyncWebServerRequest * request) {
+    request->send(200, "text/html", createConfigForm());
+  });
+  server.on("/config.html", HTTP_POST, [](AsyncWebServerRequest * request) {
+    handleConfigPost(request);
+    request->send(200, "text/html", createConfigForm());
+  });
+
+  server.on("/status.html", HTTP_GET,  [](AsyncWebServerRequest * request) {
+    request->send(200, "text/html", createStatusForm());
+  });
+  server.on("/update.html", HTTP_GET,  [](AsyncWebServerRequest * request) {
+    request->send(200, "text/html", createUpdateForm(0));
+  });
+  server.on("/update.html", HTTP_POST, [](AsyncWebServerRequest * request) {
+    handleUpdatePost(request);
+    request->send(200, "text/html", createUpdateForm(1));
+  });
+
+  server.on("/control.html", HTTP_GET,  [](AsyncWebServerRequest * request) {
+    request->send(200, "text/html", createControlForm());
+  });
+  server.on("/control.html", HTTP_POST, [](AsyncWebServerRequest * request) {
+    handleControlPost(request);
+    request->send(200, "text/html", createControlForm());
+  });
+
+  server.on("/edit.html", HTTP_GET,  [](AsyncWebServerRequest * request) {
+    request->send(200, "text/html", createEditForm(request->getParam(0)->value()));
+  });
+  server.on("/edit.html", HTTP_POST, [](AsyncWebServerRequest * request) {
+    const char *ret = handleEditPost(request);
+    if(ret==NULL)
+       request->send(200, "text/html", "<html><head>ERROR</head><body><p>Something went wrong. Uploaded file is empty.</p></body></hhtml>");
+    else
+       request->send(200, "text/html", createEditForm(request->getParam(0)->value()));
+  },
+  NULL,
+  [](AsyncWebServerRequest * request, uint8_t *data, size_t len, size_t index, size_t total) {
+      Serial.printf("post data: index=%d len=%d total=%d\n", index, len, total);
+  });
+
+  // Route to load style.css file
+  server.on("/style.css", HTTP_GET, [](AsyncWebServerRequest * request) {
+    request->send(SPIFFS, "/style.css", "text/css");
+  });
+
+  // Route to set GPIO to HIGH
+  server.on("/test.php", HTTP_POST, [](AsyncWebServerRequest * request) {
+    request->send(SPIFFS, "/index.html", String(), false, processor);
+  });
+
+  server.onNotFound([](AsyncWebServerRequest * request) {
+    if (request->method() == HTTP_OPTIONS) {
+      request->send(200);
+    } else {
+      String url = request->url();
+      if (url.endsWith(".gpx"))
+        request->send(200, "application/gpx+xml", sendGPX(request));
+      else {
+        request->send(SPIFFS, url, "text/html");
+        Serial.printf("URL is %s\n", url.c_str());
+        //request->send(404);
+      }
+    }
+  });
+
+  // Set up web socket
+  ws.onEvent(onWsEvent);
+  server.addHandler(&ws);
+
+  // Start server
+  server.begin();
+}
+
+int fetchWifiIndex(const char *id) {
+  for (int i = 0; i < nNetworks; i++) {
+    if (strcmp(id, networks[i].id.c_str()) == 0) {
+      Serial.printf("Match for %s at %d\n", id, i);
+      return i;
+    }
+    Serial.printf("No match: '%s' vs '%s'\n", id, networks[i].id.c_str());
+    const char *cfgid = networks[i].id.c_str();
+    int len = strlen(cfgid);
+    if (strlen(id) > len) len = strlen(id);
+    Serial.print("SSID: ");
+    for (int i = 0; i < len; i++) {
+      Serial.printf("%02x ", id[i]);
+    } Serial.println("");
+    Serial.print("Conf: ");
+    for (int i = 0; i < len; i++) {
+      Serial.printf("%02x ", cfgid[i]);
+    } Serial.println("");
+  }
+  return -1;
+}
+
+const char *fetchWifiSSID(int i) {
+  return networks[i].id.c_str();
+}
+const char *fetchWifiPw(int i) {
+  return networks[i].pw.c_str();
+}
+
+const char *fetchWifiPw(const char *id) {
+  for (int i = 0; i < nNetworks; i++) {
+    //Serial.print("Comparing '");
+    //Serial.print(id);
+    //Serial.print("' and '");
+    //Serial.print(networks[i].id.c_str());
+    //Serial.println("'");
+    if (strcmp(id, networks[i].id.c_str()) == 0) return networks[i].pw.c_str();
+  }
+  return NULL;
+}
+
+// It is not safe to call millis() in ISR!!!
+// millis() does a division int64_t by 1000 for which gcc creates a library call
+// on a 32bit system, and the called function has no IRAM_ATTR
+// so doing it manually...
+// Code adapted for 64 bits from https://www.hackersdelight.org/divcMore.pdf
+int64_t IRAM_ATTR divs10(int64_t n) {
+  int64_t q, r;
+  n = n + (n >> 63 & 9);
+  q = (n >> 1) + (n >> 2);
+  q = q + (q >> 4);
+  q = q + (q >> 8);
+  q = q + (q >> 16);
+  q = q + (q >> 32);
+  q = q >> 3;
+  r = n - q * 10;
+  return q + ((r + 6) >> 4);
+  // return q + (r > 9);
+}
+
+int64_t IRAM_ATTR divs1000(int64_t n) {
+  return divs10(divs10(divs10(n)));
+}
+
+unsigned long IRAM_ATTR my_millis()
+{
+  return divs1000(esp_timer_get_time());
+}
+
+void checkTouchStatus();
+void touchISR();
+void touchISR2();
+
+// ISR won't work for SPI transfer, so forget about the following approach
+///// Also initialized timers for sx1278 handling with interruts
+///// fastest mode currentily is 4800 bit/s, i.e. 600 bytes/sec
+///// 64 byte FIFO will last for at most about 106 ms.
+///// lets use a timer every 20ms to handle sx1278 FIFO input, that should be fine.
+// Instead create a tast...
+
+Ticker ticker;
+Ticker ledFlasher;
+
+#define IS_TOUCH(x) (((x)!=255)&&((x)!=-1)&&((x)&128))
+void initTouch() {
+  // also used for LED
+  ticker.attach_ms(300, checkTouchStatus);
+
+  if ( !(IS_TOUCH(sonde.config.button_pin) || IS_TOUCH(sonde.config.button2_pin)) ) return; // no touch buttons configured
+  /*
+   *  ** no. readTouch is not safe to use in ISR!
+      so now using Ticker
+    hw_timer_t *timer = timerBegin(0, 80, true);
+    timerAttachInterrupt(timer, checkTouchStatus, true);
+    timerAlarmWrite(timer, 300000, true);
+    timerAlarmEnable(timer);
+  */
+  if ( IS_TOUCH(sonde.config.button_pin) ) {
+    touchAttachInterrupt(sonde.config.button_pin & 0x7f, touchISR, sonde.config.touch_thresh);
+    Serial.printf("Initializing touch 1 on pin %d\n", sonde.config.button_pin & 0x7f);
+  }
+  if ( IS_TOUCH(sonde.config.button2_pin) ) {
+    touchAttachInterrupt(sonde.config.button2_pin & 0x7f, touchISR2, sonde.config.touch_thresh);
+    Serial.printf("Initializing touch 2 on pin %d\n", sonde.config.button2_pin & 0x7f);
+  }
+}
+
+char buffer[85];
+MicroNMEA nmea(buffer, sizeof(buffer));
+
+int lastCourse = 0;
+void unkHandler(const MicroNMEA& nmea) {
+  if (strcmp(nmea.getMessageID(), "VTG") == 0) {
+    const char *s = nmea.getSentence();
+    while (*s && *s != ',') s++;
+    if (*s == ',') s++; else return;
+    if (*s == ',') return; /// no new course data
+    lastCourse = nmea.parseFloat(s, 0, NULL);
+    Serial.printf("Course update: %d\n", lastCourse);
+  }
+}
+void gpsTask(void *parameter) {
+  nmea.setUnknownSentenceHandler(unkHandler);
+
+  while (1) {
+    while (Serial2.available()) {
+      char c = Serial2.read();
+      //Serial.print(c);
+      if (nmea.process(c)) {
+        //Serial.println(nmea.getSentence());
+        long lat = nmea.getLatitude();
+        long lon = nmea.getLongitude();
+        long alt = -1;
+        bool b = nmea.getAltitude(alt);
+        bool valid = nmea.isValid();
+        int course = nmea.getCourse() / 1000;
+        uint8_t hdop = nmea.getHDOP();
+        //Serial.printf("\nDecode: valid: %d  N %ld  E %ld  alt %ld (%d)  course:%d dop:%d", valid ? 1 : 0, lat, lon, alt, b, c, hdop);
+      }
+    }
+    delay(50);
+  }
+}
+
+void initGPS() {
+  if (sonde.config.gps_rxd < 0) return; // GPS disabled
+  Serial2.begin(9600, SERIAL_8N1, sonde.config.gps_rxd, sonde.config.gps_txd);
+
+  xTaskCreate( gpsTask, "gpsTask",
+               5000, /* stack size */
+               NULL, /* paramter */
+               1, /* priority */
+               NULL);  /* task handle*/
+}
+
+
+void sx1278Task(void *parameter) {
+  /* new strategy:
+      background tasks handles all interactions with sx1278.
+      implementation is decoder specific.
+      This task is a simple infinit loop that
+       (a) initially and after frequency or mode change calls <decoder>.setup()
+       (b) then repeatedly calls <decoder>.receive() which should
+           (1) update data in the Sonde structure (additional updates may be done later in main loop/waitRXcomplete)
+           (2) set output flag receiveResult (success/error/timeout and keybord events)
+
+  */
+  while (1) {
+    if (rxtask.activate >= 128) {
+      // activating sx1278 background task...
+      Serial.printf("rx task: activate=%d  mainstate=%d\n", rxtask.activate, rxtask.mainState);
+      rxtask.mainState = ST_DECODER;
+      rxtask.currentSonde = rxtask.activate & 0x7F;
+      Serial.println("rx task: calling sonde.setup()");
+      sonde.setup();
+    } else if (rxtask.activate != -1) {
+      Serial.printf("rx task: activate=%d  mainstate=%d\n", rxtask.activate, rxtask.mainState);
+      rxtask.mainState = rxtask.activate;
+    }
+    rxtask.activate = -1;
+    /* only if mainState is ST_DECODER */
+    if (rxtask.mainState != ST_DECODER) {
+      delay(100);
+      continue;
+    }
+    sonde.receive();
+    delay(20);
+  }
+}
+
+
+void IRAM_ATTR touchISR() {
+  if (!button1.isTouched) {
+    unsigned long now = my_millis();
+    if (now - button1.keydownTime < 500) button1.doublepress = 1;
+    else button1.doublepress = 0;
+    button1.keydownTime = now;
+    button1.isTouched = true;
+  }
+}
+
+void IRAM_ATTR touchISR2() {
+  if (!button2.isTouched) {
+    unsigned long now = my_millis();
+    if (now - button2.keydownTime < 500) button2.doublepress = 1;
+    else button2.doublepress = 0;
+    button2.keydownTime = now;
+    button2.isTouched = true;
+  }
+}
+
+// touchRead in ISR is also a bad idea. Now moved to Ticker task
+void checkTouchButton(Button & button) {
+  if (button.isTouched) {
+    int tmp = touchRead(button.pin & 0x7f);
+    Serial.printf("touch read %d: value is %d\n", button.pin & 0x7f, tmp);
+    if (tmp > sonde.config.touch_thresh + 5) {
+      button.isTouched = false;
+      unsigned long elapsed = my_millis() - button.keydownTime;
+      if (elapsed > 1500) {
+        if (elapsed < 4000) {
+          button.pressed = KP_MID;
+        }
+        else {
+          button.pressed = KP_LONG;
+        }
+      } else if (button.doublepress) {
+        button.pressed = KP_DOUBLE;
+      } else {
+        button.pressed = KP_SHORT;
+      }
+    }
+  }
+}
+
+void ledOffCallback() {
+  digitalWrite(sonde.config.led_pout, LOW);
+}
+void flashLed(int ms) {
+  if (sonde.config.led_pout >= 0) {
+    digitalWrite(sonde.config.led_pout, HIGH);
+    ledFlasher.once_ms(ms, ledOffCallback);
+  }
+}
+
+void buzzerLed(int temps) {
+  Serial.printf("\nBuzzer On\n");
+  ledcWriteTone(0, sonde.config.buzzerFreq);
+  delay(temps);
+  ledcWrite(0, 180);
+  delay(temps);
+}
+
+int doTouch = 0;
+void checkTouchStatus() {
+  checkTouchButton(button1);
+  checkTouchButton(button2);
+}
+
+unsigned long bdd1, bdd2;
+void IRAM_ATTR buttonISR() {
+  if (digitalRead(button1.pin) == 0) { // Button down
+    unsigned long now = my_millis();
+    if (now - button1.keydownTime < 500) {
+      // Double press
+      if (now - button1.keydownTime > 100)
+        button1.doublepress = 1;
+      bdd1 = now; bdd2 = button1.keydownTime;
+    } else {
+      button1.doublepress = 0;
+    }
+    button1.numberKeyPresses += 1;
+    button1.keydownTime = now;
+  } else { //Button up
+    unsigned long now = my_millis();
+    if (button1.doublepress == -1) return;   // key was never pressed before, ignore button up
+    unsigned int elapsed = now - button1.keydownTime;
+    if (elapsed > 1500) {
+      if (elapsed < 4000) {
+        button1.pressed = KP_MID;
+      }
+      else {
+        button1.pressed = KP_LONG;
+      }
+    } else {
+      if (button1.doublepress) button1.pressed = KP_DOUBLE;
+      else button1.pressed = KP_SHORT;
+    }
+    button1.numberKeyPresses += 1;
+    button1.keydownTime = now;
+  }
+}
+
+void IRAM_ATTR button2ISR() {
+  if (digitalRead(button2.pin) == 0) { // Button down
+    unsigned long now = my_millis();
+    if (now - button2.keydownTime < 500) {
+      // Double press
+      if (now - button2.keydownTime > 100)
+        button2.doublepress = 1;
+      //bdd1 = now; bdd2 = button1.keydownTime;
+    } else {
+      button2.doublepress = 0;
+    }
+    button2.numberKeyPresses += 1;
+    button2.keydownTime = now;
+  } else { //Button up
+    unsigned long now = my_millis();
+    if (button2.doublepress == -1) return;   // key was never pressed before, ignore button up
+    unsigned int elapsed = now - button2.keydownTime;
+    if (elapsed > 1500) {
+      if (elapsed < 4000) {
+        button2.pressed = KP_MID;
+      }
+      else {
+        button2.pressed = KP_LONG;
+      }
+    } else {
+      if (button2.doublepress) button2.pressed = KP_DOUBLE;
+      else button2.pressed = KP_SHORT;
+    }
+    button2.numberKeyPresses += 1;
+    button2.keydownTime = now;
+  }
+}
+
+int getKeyPress() {
+  KeyPress p = button1.pressed;
+  button1.pressed = KP_NONE;
+  int x = digitalRead(button1.pin);
+  //Serial.printf("Debug: bdd1=%ld, bdd2=%ld\b", bdd1, bdd2);
+  //Serial.printf("button1 press (dbl:%d) (now:%d): %d at %ld (%d)\n", button1.doublepress, x, p, button1.keydownTime, button1.numberKeyPresses);
+  return p;
+}
+
+int getKey2Press() {
+  if (sonde.config.button2_axp) {
+    // Use AXP power button as second button
+    if (pmu_irq) {
+      Serial.println("PMU_IRQ is set\n");
+      xSemaphoreTake( axpSemaphore, portMAX_DELAY );
+      axp.readIRQ();
+      if (axp.isPEKShortPressIRQ()) {
+        button2.pressed = KP_SHORT;
+        button2.keydownTime = my_millis();
+      }
+      if (axp.isPEKLongtPressIRQ()) {
+        button2.pressed = KP_MID;
+        button2.keydownTime = my_millis();
+      }
+      pmu_irq = false;
+      axp.clearIRQ();
+      xSemaphoreGive( axpSemaphore );
+    }
+  }
+  KeyPress p = button2.pressed;
+  button2.pressed = KP_NONE;
+  //Serial.printf("button2 press: %d at %ld (%d)\n", p, button2.keydownTime, button2.numberKeyPresses);
+  return p;
+}
+
+int getKeyPressEvent() {
+  int p = getKeyPress();
+  if (p == KP_NONE) {
+    p = getKey2Press();
+    if (p == KP_NONE)
+      return EVT_NONE;
+    Serial.printf("Key 2 was pressed [%d]\n", p + 4);
+    return p + 4;
+  }
+  Serial.printf("Key 1 was pressed [%d]\n", p);
+  return p;  /* map KP_x to EVT_KEY1_x / EVT_KEY2_x*/
+}
+
+#define SSD1306_ADDRESS 0x3c
+bool ssd1306_found = false;
+bool axp192_found = false;
+
+int scanI2Cdevice(void)
+{
+  byte err, addr;
+  int nDevices = 0;
+  for (addr = 1; addr < 127; addr++) {
+    Wire.beginTransmission(addr);
+    err = Wire.endTransmission();
+    if (err == 0) {
+      Serial.print("I2C device found at address 0x");
+      if (addr < 16)
+        Serial.print("0");
+      Serial.print(addr, HEX);
+      Serial.println(" !");
+      nDevices++;
+
+      if (addr == SSD1306_ADDRESS) {
+        ssd1306_found = true;
+        Serial.println("ssd1306 display found");
+      }
+      if (addr == AXP192_SLAVE_ADDRESS) {
+        axp192_found = true;
+        Serial.println("axp192 PMU found");
+      }
+    } else if (err == 4) {
+      Serial.print("Unknow error at address 0x");
+      if (addr < 16)
+        Serial.print("0");
+      Serial.println(addr, HEX);
+    }
+  }
+  if (nDevices == 0)
+    Serial.println("No I2C devices found\n");
+  else
+    Serial.println("done\n");
+  return nDevices;
+}
+
+extern int initlevels[40];
+
+void setup()
+{
+  char buf[12];
+  // Open serial communications and wait for port to open:
+  Serial.begin(115200);
+  for (int i = 0; i < 39; i++) {
+    int v = gpio_get_level((gpio_num_t)i);
+    Serial.printf("%d:%d ", i, v);
+  }
+  Serial.println("");
+  axpSemaphore = xSemaphoreCreateBinary();
+  xSemaphoreGive(axpSemaphore);
+
+#if 0
+  delay(2000);
+  // temporary test
+  volatile uint32_t *ioport = portOutputRegister(digitalPinToPort(4));
+  uint32_t portmask = digitalPinToBitMask(4);
+  int t = millis();
+  for (int i = 0; i < 10000000; i++) {
+    digitalWrite(4, LOW);
+    digitalWrite(4, HIGH);
+  }
+  int res = millis() - t;
+  Serial.printf("Duration w/ digitalWriteo: %d\n", res);
+
+  t = millis();
+  for (int i = 0; i < 10000000; i++) {
+    *ioport |=  portmask;
+    *ioport &= ~portmask;
+  }
+  res = millis() - t;
+  Serial.printf("Duration w/ fast io: %d\n", res);
+#endif
+  for (int i = 0; i < 39; i++) {
+    Serial.printf("%d:%d ", i, initlevels[i]);
+  }
+  Serial.println(" (before setup)");
+  sonde.defaultConfig();  // including autoconfiguration
+  aprs_gencrctab();
+
+  Serial.println("Initializing SPIFFS");
+  // Initialize SPIFFS
+  if (!SPIFFS.begin(true)) {
+    Serial.println("An Error has occurred while mounting SPIFFS");
+    return;
+  }
+
+  Serial.println("Reading initial configuration");
+  setupConfigData();    // configuration must be read first due to OLED ports!!!
+
+  if ((sonde.fingerprint & 16) == 16) { // NOT TTGO v1 (fingerprint 64) or Heltec v1/v2 board (fingerprint 4)
+    // FOr T-Beam 1.0
+    for (int i = 0; i < 10; i++) { // try multiple times
+      Wire.begin(21, 22);
+      // Make sure the whole thing powers up!?!?!?!?!?
+      U8X8 *u8x8 = new U8X8_SSD1306_128X64_NONAME_HW_I2C(0, 22, 21);
+      u8x8->initDisplay();
+      delay(500);
+
+      scanI2Cdevice();
+      if (!axp.begin(Wire, AXP192_SLAVE_ADDRESS)) {
+        Serial.println("AXP192 Begin PASS");
+      } else {
+        Serial.println("AXP192 Begin FAIL");
+      }
+      
+      axp.setPowerOutPut(AXP192_LDO2, AXP202_ON);
+      axp.setPowerOutPut(AXP192_LDO3, AXP202_ON);
+      axp.setPowerOutPut(AXP192_DCDC2, AXP202_ON);
+      axp.setPowerOutPut(AXP192_EXTEN, AXP202_ON);
+      axp.setPowerOutPut(AXP192_DCDC1, AXP202_ON);
+      axp.setDCDC1Voltage(3300);
+
+      axp.adc1Enable(AXP202_VBUS_VOL_ADC1, 1);
+      axp.adc1Enable(AXP202_VBUS_CUR_ADC1, 1);
+      pinMode(PMU_IRQ, INPUT_PULLUP);
+      attachInterrupt(PMU_IRQ, [] {
+        pmu_irq = true;
+      }, FALLING);
+      axp.adc1Enable(AXP202_BATT_CUR_ADC1, 1);
+      //axp.enableIRQ(AXP202_VBUS_REMOVED_IRQ | AXP202_VBUS_CONNECT_IRQ | AXP202_BATT_REMOVED_IRQ | AXP202_BATT_CONNECT_IRQ, 1);
+      axp.enableIRQ( AXP202_PEK_LONGPRESS_IRQ | AXP202_PEK_SHORTPRESS_IRQ, 1 );
+      axp.clearIRQ();
+      int ndevices = scanI2Cdevice();
+      if (sonde.fingerprint != 17 || ndevices > 0) break; // only retry for fingerprint 17 (startup problems of new t-beam with oled)
+      delay(500);
+    }
+  }
+  if (sonde.config.power_pout >= 0) { // for a heltec v2, pull GPIO21 low for display power
+    pinMode(sonde.config.power_pout & 127, OUTPUT);
+    digitalWrite(sonde.config.power_pout & 127, sonde.config.power_pout & 128 ? 1 : 0);
+  }
+
+  if (sonde.config.led_pout >= 0) {
+    pinMode(sonde.config.led_pout, OUTPUT);
+    flashLed(1000); // testing
+  }
+
+  button1.pin = sonde.config.button_pin;
+  button2.pin = sonde.config.button2_pin;
+  if (button1.pin != 0xff) {
+    if ( (button1.pin & 0x80) == 0 && button1.pin < 34 ) {
+      Serial.println("Button 1 configured as input with pullup");
+      pinMode(button1.pin, INPUT_PULLUP);
+    } else
+      pinMode(button1.pin, INPUT);  // configure as input if not disabled
+  }
+  if (button2.pin != 0xff) {
+    if ( (button2.pin & 0x80) == 0 && button2.pin < 34 ) {
+      Serial.println("Button 2 configured as input with pullup");
+      pinMode(button2.pin, INPUT_PULLUP);
+    } else
+      pinMode(button2.pin, INPUT);  // configure as input if not disabled
+  }
+  // Handle button press
+  if ( (button1.pin & 0x80) == 0) {
+    attachInterrupt( button1.pin, buttonISR, CHANGE);
+    Serial.printf("button1.pin is %d, attaching interrupt\n", button1.pin);
+  }
+  // Handle button press
+  if ( (button2.pin & 0x80) == 0) {
+    attachInterrupt( button2.pin, button2ISR, CHANGE);
+    Serial.printf("button2.pin is %d, attaching interrupt\n", button2.pin);
+  }
+  initTouch();
+
+  disp.init();
+  delay(100);
+  Serial.println("Showing welcome display");
+  disp.rdis->welcome();
+  delay(3000);
+  Serial.println("Clearing display");
+  sonde.clearDisplay();
+
+  setupWifiList();
+  Serial.printf("before disp.initFromFile... layouts is %p", disp.layouts);
+
+  disp.initFromFile();
+  Serial.printf("disp.initFromFile... layouts is %p", disp.layouts);
+
+
+  // == show initial values from config.txt ========================= //
+  if (sonde.config.debug == 1) {
+    disp.rdis->setFont(FONT_SMALL);
+    disp.rdis->drawString(0, 0, "Config:");
+
+    delay(500);
+    itoa(sonde.config.oled_sda, buf, 10);
+    disp.rdis->drawString(0, 1, " SDA:");
+    disp.rdis->drawString(6, 1, buf);
+
+    delay(500);
+    itoa(sonde.config.oled_scl, buf, 10);
+    disp.rdis->drawString(0, 2, " SCL:");
+    disp.rdis->drawString(6, 2, buf);
+
+    delay(500);
+    itoa(sonde.config.oled_rst, buf, 10);
+    disp.rdis->drawString(0, 3, " RST:");
+    disp.rdis->drawString(6, 3, buf);
+
+    delay(1000);
+    itoa(sonde.config.led_pout, buf, 10);
+    disp.rdis->drawString(0, 4, " LED:");
+    disp.rdis->drawString(6, 4, buf);
+
+    delay(500);
+    itoa(sonde.config.spectrum, buf, 10);
+    disp.rdis->drawString(0, 5, " SPEC:");
+    disp.rdis->drawString(6, 5, buf);
+
+    delay(500);
+    itoa(sonde.config.maxsonde, buf, 10);
+    disp.rdis->drawString(0, 6, " MAX:");
+    disp.rdis->drawString(6, 6, buf);
+
+    delay(5000);
+    sonde.clearDisplay();
+  }
+  // == show initial values from config.txt ========================= //
+
+#if 0
+  // == check the radio chip by setting default frequency =========== //
+  if (rs41.setFrequency(402700000) == 0) {
+    Serial.println(F("Setting freq: SUCCESS "));
+  } else {
+    Serial.println(F("Setting freq: ERROR "));
+  }
+  float f = sx1278.getFrequency();
+  Serial.print("Frequency set to ");
+  Serial.println(f);
+  // == check the radio chip by setting default frequency =========== //
+#endif
+
+  //sx1278.setLNAGain(-48);
+  sx1278.setLNAGain(0);
+
+  int gain = sx1278.getLNAGain();
+  Serial.print("RX LNA Gain is ");
+  Serial.println(gain);
+
+  // Print a success message
+  Serial.println(F("SX1278 configuration finished"));
+
+  Serial.println("Setup finished");
+  Serial.println();
+  // int returnValue = pthread_create(&wifithread, NULL, wifiloop, (void *)0);
+
+  //  if (returnValue) {
+  //     Serial.println("An error has occurred");
+  //  }
+  //   xTaskCreate(mainloop, "MainServer", 10240, NULL, 10, NULL);
+
+
+  // == setup default channel list if qrg.txt read fails =========== //
+  setupChannelList();
+#if 0
+  sonde.clearSonde();
+  sonde.addSonde(402.700, STYPE_RS41);
+  sonde.addSonde(405.700, STYPE_RS41);
+  sonde.addSonde(405.900, STYPE_RS41);
+  sonde.addSonde(403.450, STYPE_DFM09);
+  Serial.println("No channel config file, using defaults!");
+  Serial.println();
+#endif
+  /// not here, done by sonde.setup(): rs41.setup();
+  // == setup default channel list if qrg.txt read fails =========== //
+#ifndef DISABLE_SX1278 
+  xTaskCreate( sx1278Task, "sx1278Task",
+               10000, /* stack size */
+               NULL, /* paramter */
+               1, /* priority */
+               NULL);  /* task handle*/
+#endif              
+  sonde.setup();
+  initGPS();
+
+  WiFi.onEvent(WiFiEvent);
+  getKeyPress();    // clear key buffer
+}
+
+void enterMode(int mode) {
+  Serial.printf("enterMode(%d)\n", mode);
+  // Backround RX task should only be active in mode ST_DECODER for now
+  // (future changes might use RX background task for spectrum display as well)
+  if (mode != ST_DECODER) {
+    rxtask.activate = mode;
+    while (rxtask.activate == mode) {
+      delay(10);  // until cleared by RXtask -- rx task is deactivated
+    }
+  }
+  mainState = (MainState)mode;
+  if (mainState == ST_SPECTRUM) {
+    Serial.println("Entering ST_SPECTRUM mode");
+    sonde.clearDisplay();
+    disp.rdis->setFont(FONT_SMALL);
+    specTimer = millis();
+    //scanner.init();
+  } else if (mainState == ST_WIFISCAN) {
+    sonde.clearDisplay();
+  }
+  if (mode == ST_DECODER) {
+    // trigger activation of background task
+    // currentSonde should be set before enterMode()
+    rxtask.activate = ACT_SONDE(sonde.currentSonde);
+    sonde.clearDisplay();
+    sonde.updateDisplay();
+  }
+}
+
+static char text[40];
+static const char *action2text(uint8_t action) {
+  if (action == ACT_DISPLAY_DEFAULT) return "Default Display";
+  if (action == ACT_DISPLAY_SPECTRUM) return "Spectrum Display";
+  if (action == ACT_DISPLAY_WIFI) return "Wifi Scan Display";
+  if (action == ACT_NEXTSONDE) return "Go to next sonde";
+  if (action == ACT_PREVSONDE) return "presonde (not implemented)";
+  if (action == ACT_NONE) return "none";
+  if (action >= 128) {
+    snprintf(text, 40, "Sonde=%d", action & 127);
+  } else {
+    snprintf(text, 40, "Display=%d", action);
+  }
+  return text;
+}
+void loopDecoder() {
+  // sonde knows the current type and frequency, and delegates to the right decoder
+  uint16_t res = sonde.waitRXcomplete();
+  int action;
+  Serial.printf("waitRX result is %x\n", (int)res);
+  action = (int)(res >> 8);
+  // TODO: update displayed sonde?
+
+  if (action != ACT_NONE) {
+   
+    Serial.printf("Loop: triggering action %s (%d)\n", action2text(action), action);
+    action = sonde.updateState(action);
+    Serial.printf("Loop: action is %d, sonde index is %d\n", action, sonde.currentSonde);
+    if (action != 255) {
+      if (action == ACT_DISPLAY_SPECTRUM) {
+        enterMode(ST_SPECTRUM);
+        return;
+      }
+      else if (action == ACT_DISPLAY_WIFI) {
+        enterMode(ST_WIFISCAN);
+        return;
+      }
+      // no... we are already in DECODER mode, so no need to do anything!?
+      //else if (action == ACT_NEXTSONDE) enterMode(ST_DECODER); // update rx background task
+    }
+    Serial.printf("current main is %d, current rxtask is %d\n", sonde.currentSonde, rxtask.currentSonde);
+  }
+
+  if (!tncclient.connected()) {
+    Serial.println("TNC client not connected");
+    tncclient = tncserver.available();
+    if (tncclient.connected()) {
+      Serial.println("new TCP KISS connection");
+    }
+  }
+  if (tncclient.available()) {
+    Serial.print("TCP KISS socket: recevied ");
+    while (tncclient.available()) {
+      Serial.print(tncclient.read());  // Check if we receive anything from from APRSdroid
+    }
+    Serial.println("");
+  }
+  // wifi (axudp) or bluetooth (bttnc) active => send packet
+  if ((res & 0xff) == 0 && (connected || tncclient.connected() )) {
+    //Send a packet with position information
+    // first check if ID and position lat+lonis ok
+    SondeInfo *s = &sonde.sondeList[rxtask.receiveSonde];
+    if (s->validID && ((s->validPos & 0x03) == 0x03)) {
+      const char *str = aprs_senddata(s, sonde.config.call, sonde.config.udpfeed.symbol);
+      if (connected)  {
+        char raw[201];
+        int rawlen = aprsstr_mon2raw(str, raw, APRS_MAXLEN);
+        Serial.println("Sending position via UDP");
+        Serial.print("Sending: "); Serial.println(raw);
+        udp.beginPacket(sonde.config.udpfeed.host, sonde.config.udpfeed.port);
+        udp.write((const uint8_t *)raw, rawlen);
+        udp.endPacket();
+      }
+      if (tncclient.connected()) {
+        Serial.println("Sending position via TCP");
+        char raw[201];
+        int rawlen = aprsstr_mon2kiss(str, raw, APRS_MAXLEN);
+        Serial.print("sending: "); Serial.println(raw);
+        tncclient.write(raw, rawlen);
+      }
+    }
+    // also send to web socket
+    //TODO
+  }
+  Serial.println("updateDisplay started");
+  if (forceReloadScreenConfig) {
+    disp.initFromFile();
+    sonde.clearDisplay();
+    forceReloadScreenConfig = false;
+  }
+  sonde.updateDisplay();
+  Serial.println("updateDisplay done");
+}
+
+void setCurrentDisplay(int value) {
+  Serial.printf("setCurrentDisplay: setting index %d, entry %d\b", value, sonde.config.display[value]);
+  currentDisplay = sonde.config.display[value];
+}
+
+void loopSpectrum() {
+  int marker = 0;
+  char buf[10];
+
+  switch (getKeyPress()) {
+    case KP_SHORT: /* move selection of peak, TODO */
+      sonde.nextConfig(); // TODO: Should be set specific frequency
+      enterMode(ST_DECODER);
+      return;
+    case KP_MID: /* restart, TODO */ break;
+    case KP_LONG:
+      Serial.println("loopSpectrum: KP_LONG");
+      enterMode(ST_WIFISCAN);
+      return;
+    case KP_DOUBLE:
+      setCurrentDisplay(0);
+      enterMode(ST_DECODER);
+      return;
+    default: break;
+  }
+
+  scanner.scan();
+  scanner.plotResult();
+  if (sonde.config.marker != 0) {
+    itoa((sonde.config.startfreq), buf, 10);
+    disp.rdis->drawString(0, 1, buf);
+    disp.rdis->drawString(7, 1, "MHz");
+    itoa((sonde.config.startfreq + 6), buf, 10);
+    disp.rdis->drawString(13, 1, buf);
+  }
+  if (sonde.config.spectrum > 0) {
+    int remaining = sonde.config.spectrum - (millis() - specTimer) / 1000;
+    itoa(remaining, buf, 10);
+    Serial.printf("config.spectrum:%d  specTimer:%ld millis:%ld remaining:%d\n", sonde.config.spectrum, specTimer, millis(), remaining);
+    if (sonde.config.marker != 0) {
+      marker = 1;
+    }
+    disp.rdis->drawString(0, 1 + marker, buf);
+    disp.rdis->drawString(2, 1 + marker, "Sec.");
+    if (remaining <= 0) {
+      setCurrentDisplay(0);
+      enterMode(ST_DECODER);
+    }
+  }
+}
+
+void startSpectrumDisplay() {
+  sonde.clearDisplay();
+  disp.rdis->setFont(FONT_SMALL);
+  disp.rdis->drawString(0, 0, "Spectrum Scan...");
+  delay(500);
+  enterMode(ST_SPECTRUM);
+}
+
+String translateEncryptionType(wifi_auth_mode_t encryptionType) {
+  switch (encryptionType) {
+    case (WIFI_AUTH_OPEN):
+      return "Open";
+    case (WIFI_AUTH_WEP):
+      return "WEP";
+    case (WIFI_AUTH_WPA_PSK):
+      return "WPA_PSK";
+    case (WIFI_AUTH_WPA2_PSK):
+      return "WPA2_PSK";
+    case (WIFI_AUTH_WPA_WPA2_PSK):
+      return "WPA_WPA2_PSK";
+    case (WIFI_AUTH_WPA2_ENTERPRISE):
+      return "WPA2_ENTERPRISE";
+    default:
+      return "";
+  }
+}
+
+void enableNetwork(bool enable) {
+  if (enable) {
+    MDNS.begin(sonde.config.mdnsname);
+    SetupAsyncServer();
+    udp.begin(WiFi.localIP(), LOCALUDPPORT);
+    MDNS.addService("http", "tcp", 80);
+    if (sonde.config.kisstnc.active) {
+      tncserver.begin();
+    }
+    connected = true;
+  } else {
+    MDNS.end();
+    connected = false;
+  }
+}
+
+
+enum t_wifi_state { WIFI_DISABLED, WIFI_SCAN, WIFI_CONNECT, WIFI_CONNECTED, WIFI_APMODE };
+
+static t_wifi_state wifi_state = WIFI_DISABLED;
+
+// Events used only for debug output right now
+void WiFiEvent(WiFiEvent_t event)
+{
+  Serial.printf("[WiFi-event] event: %d\n", event);
+
+  switch (event) {
+    case SYSTEM_EVENT_WIFI_READY:
+      Serial.println("WiFi interface ready");
+      break;
+    case SYSTEM_EVENT_SCAN_DONE:
+      Serial.println("Completed scan for access points");
+      break;
+    case SYSTEM_EVENT_STA_START:
+      Serial.println("WiFi client started");
+      break;
+    case SYSTEM_EVENT_STA_STOP:
+      Serial.println("WiFi clients stopped");
+      break;
+    case SYSTEM_EVENT_STA_CONNECTED:
+      Serial.println("Connected to access point");
+      break;
+    case SYSTEM_EVENT_STA_DISCONNECTED:
+      Serial.println("Disconnected from WiFi access point");
+      if (wifi_state == WIFI_CONNECT) {
+        // If we get a disconnect event while waiting for connection (as I do sometimes with my FritzBox),
+        // just start from scratch with WiFi scan
+        wifi_state = WIFI_DISABLED;
+        WiFi.disconnect(true);
+      }
+      break;
+    case SYSTEM_EVENT_STA_AUTHMODE_CHANGE:
+      Serial.println("Authentication mode of access point has changed");
+      break;
+    case SYSTEM_EVENT_STA_GOT_IP:
+      Serial.print("Obtained IP address: ");
+      Serial.println(WiFi.localIP());
+      break;
+    case SYSTEM_EVENT_STA_LOST_IP:
+      Serial.println("Lost IP address and IP address is reset to 0");
+      break;
+    case SYSTEM_EVENT_STA_WPS_ER_SUCCESS:
+      Serial.println("WiFi Protected Setup (WPS): succeeded in enrollee mode");
+      break;
+    case SYSTEM_EVENT_STA_WPS_ER_FAILED:
+      Serial.println("WiFi Protected Setup (WPS): failed in enrollee mode");
+      break;
+    case SYSTEM_EVENT_STA_WPS_ER_TIMEOUT:
+      Serial.println("WiFi Protected Setup (WPS): timeout in enrollee mode");
+      break;
+    case SYSTEM_EVENT_STA_WPS_ER_PIN:
+      Serial.println("WiFi Protected Setup (WPS): pin code in enrollee mode");
+      break;
+    case SYSTEM_EVENT_AP_START:
+      Serial.println("WiFi access point started");
+      break;
+    case SYSTEM_EVENT_AP_STOP:
+      Serial.println("WiFi access point  stopped");
+      break;
+    case SYSTEM_EVENT_AP_STACONNECTED:
+      Serial.println("Client connected");
+      break;
+    case SYSTEM_EVENT_AP_STADISCONNECTED:
+      Serial.println("Client disconnected");
+      break;
+    case SYSTEM_EVENT_AP_STAIPASSIGNED:
+      Serial.println("Assigned IP address to client");
+      break;
+    case SYSTEM_EVENT_AP_PROBEREQRECVED:
+      Serial.println("Received probe request");
+      break;
+    case SYSTEM_EVENT_GOT_IP6:
+      Serial.println("IPv6 is preferred");
+      break;
+    case SYSTEM_EVENT_ETH_START:
+      Serial.println("Ethernet started");
+      break;
+    case SYSTEM_EVENT_ETH_STOP:
+      Serial.println("Ethernet stopped");
+      break;
+    case SYSTEM_EVENT_ETH_CONNECTED:
+      Serial.println("Ethernet connected");
+      break;
+    case SYSTEM_EVENT_ETH_DISCONNECTED:
+      Serial.println("Ethernet disconnected");
+      break;
+    case SYSTEM_EVENT_ETH_GOT_IP:
+      Serial.println("Obtained IP address");
+      break;
+    default:
+      break;
+  }
+}
+
+
+void wifiConnect(int16_t res) {
+  Serial.printf("WiFi scan result: found %d networks\n", res);
+
+  // pick best network
+  int bestEntry = -1;
+  int bestRSSI = INT_MIN;
+  uint8_t bestBSSID[6];
+  int32_t bestChannel = 0;
+
+  for (int8_t i = 0; i < res; i++) {
+    String ssid_scan;
+    int32_t rssi_scan;
+    uint8_t sec_scan;
+    uint8_t* BSSID_scan;
+    int32_t chan_scan;
+    WiFi.getNetworkInfo(i, ssid_scan, sec_scan, rssi_scan, BSSID_scan, chan_scan);
+    int networkEntry = fetchWifiIndex(ssid_scan.c_str());
+    if (networkEntry < 0) continue;
+    if (rssi_scan <= bestRSSI) continue;
+    bestEntry = networkEntry;
+    bestRSSI = rssi_scan;
+    bestChannel = chan_scan;
+    memcpy((void*) &bestBSSID, (void*) BSSID_scan, sizeof(bestBSSID));
+  }
+  WiFi.scanDelete();
+  if (bestEntry >= 0) {
+    Serial.printf("WiFi Connecting BSSID: %02X:%02X:%02X:%02X:%02X:%02X SSID: %s PW %s Channel: %d (RSSI %d)\n", bestBSSID[0], bestBSSID[1], bestBSSID[2], bestBSSID[3], bestBSSID[4], bestBSSID[5], fetchWifiSSID(bestEntry), fetchWifiPw(bestEntry), bestChannel, bestRSSI);
+    WiFi.begin(fetchWifiSSID(bestEntry), fetchWifiPw(bestEntry), bestChannel, bestBSSID);
+    wifi_state = WIFI_CONNECT;
+  } else {
+    // rescan
+    // wifiStart();
+    WiFi.disconnect(true);
+    wifi_state = WIFI_DISABLED;
+  }
+}
+
+static int wifi_cto;
+
+void loopWifiBackground() {
+  // Serial.printf("WifiBackground: state %d\n", wifi_state);
+  // handle Wifi station mode in background
+  if (sonde.config.wifi == 0 || sonde.config.wifi == 2) return; // nothing to do if disabled or access point mode
+
+  if (wifi_state == WIFI_DISABLED) {  // stopped => start can
+    wifi_state = WIFI_SCAN;
+    Serial.println("WiFi start scan");
+    WiFi.scanNetworks(true); // scan in async mode
+  } else if (wifi_state == WIFI_SCAN) {
+    int16_t res = WiFi.scanComplete();
+    if (res == 0 || res == WIFI_SCAN_FAILED) {
+      // retry
+      Serial.println("WiFi restart scan");
+      WiFi.disconnect(true);
+      wifi_state = WIFI_DISABLED;
+      return;
+    }
+    if (res == WIFI_SCAN_RUNNING) {
+      return;
+    }
+    // Scan finished, try to connect
+    wifiConnect(res);
+    wifi_cto = 0;
+  } else if (wifi_state == WIFI_CONNECT) {
+    wifi_cto++;
+    if (WiFi.isConnected()) {
+      wifi_state = WIFI_CONNECTED;
+      // update IP in display
+      String localIPstr = WiFi.localIP().toString();
+      sonde.setIP(localIPstr.c_str(), false);
+      sonde.updateDisplayIP();
+      enableNetwork(true);
+    }
+    if (wifi_cto > 20) { // failed, restart scanning
+      wifi_state = WIFI_DISABLED;
+      WiFi.disconnect(true);
+    }
+  } else if (wifi_state == WIFI_CONNECTED) {
+    if (!WiFi.isConnected()) {
+      sonde.setIP("", false);
+      sonde.updateDisplayIP();
+
+      wifi_state = WIFI_DISABLED;  // restart scan
+      enableNetwork(false);
+      WiFi.disconnect(true);
+    }
+  }
+}
+
+void startAP() {
+  Serial.println("Activating access point mode");
+  wifi_state = WIFI_APMODE;
+  WiFi.softAP(networks[0].id.c_str(), networks[0].pw.c_str());
+  IPAddress myIP = WiFi.softAPIP();
+  String myIPstr = myIP.toString();
+  sonde.setIP(myIPstr.c_str(), true);
+  sonde.updateDisplayIP();
+  // enableNetwork(true); done later in WifiLoop.
+}
+
+void initialMode() {
+  if (sonde.config.touch_thresh == 0) {
+    enterMode(ST_TOUCHCALIB);
+    return;
+  }
+  if (sonde.config.spectrum != -1) {    // enable Spectrum in config.txt: spectrum=number_of_seconds
+    startSpectrumDisplay();
+  } else {
+    setCurrentDisplay(0);
+    enterMode(ST_DECODER);
+  }
+}
+
+void loopTouchCalib() {
+  uint8_t dispw, disph, dispxs, dispys;
+  disp.rdis->clear();
+  disp.rdis->getDispSize(&disph, &dispw, &dispxs, &dispys);
+  char num[10];
+
+  while (1) {
+    int t1 = touchRead(button1.pin & 0x7f);
+    int t2 = touchRead(button2.pin & 0x7f);
+    disp.rdis->setFont(FONT_LARGE);
+    disp.rdis->drawString(0, 0, "Touch calib.");
+    disp.rdis->drawString(0, 3 * dispys, "Touch1: ");
+    snprintf(num, 10, "%d  ", t1);
+    disp.rdis->drawString(8 * dispxs, 3 * dispys, num);
+    disp.rdis->drawString(0, 6 * dispys, "Touch2: ");
+    snprintf(num, 10, "%d  ", t2);
+    disp.rdis->drawString(8 * dispxs, 6 * dispys, num);
+    delay(300);
+  }
+}
+
+// Wifi modes
+// 0: disabled. directly start initial mode (spectrum or scanner)
+// 1: station mode in background. directly start initial mode (spectrum or scanner)
+// 2: access point mode in background. directly start initial mode (spectrum or scanner)
+// 3: traditional sync. WifiScan. Tries to connect to a network, in case of failure activates AP.
+//    Mode 3 shows more debug information on serial port and display.
+#define MAXWIFIDELAY 20
+static const char* _scan[2] = {"/", "\\"};
+void loopWifiScan() {
+  if (sonde.config.wifi == 0) {   // no Wifi
+    wifi_state = WIFI_DISABLED;
+    initialMode();
+    return;
+  }
+  if (sonde.config.wifi == 1) { // station mode, setup in background
+    wifi_state = WIFI_DISABLED;  // will start scanning in wifiLoopBackgroiund
+    initialMode();
+    return;
+  }
+  if (sonde.config.wifi == 2) { // AP mode, setup in background
+    startAP();
+    initialMode();
+    return;
+  }
+  // wifi==3 => original mode with non-async wifi setup
+  disp.rdis->setFont(FONT_SMALL);
+  disp.rdis->drawString(0, 0, "WiFi Scan...");
+  uint8_t dispw, disph, dispxs, dispys;
+  disp.rdis->getDispSize(&disph, &dispw, &dispxs, &dispys);
+
+  int line = 0;
+  int cnt = 0;
+
+  WiFi.disconnect(true);
+  WiFi.mode(WIFI_STA);
+  int index = -1;
+  int n = WiFi.scanNetworks();
+  for (int i = 0; i < n; i++) {
+    Serial.print("Network name: ");
+    String ssid = WiFi.SSID(i);
+    Serial.println(ssid);
+    disp.rdis->drawString(0, dispys * (1 + line), ssid.c_str());
+    line = (line + 1) % (disph / dispys);
+    Serial.print("Signal strength: ");
+    Serial.println(WiFi.RSSI(i));
+    Serial.print("MAC address: ");
+    Serial.println(WiFi.BSSIDstr(i));
+    Serial.print("Encryption type: ");
+    String encryptionTypeDescription = translateEncryptionType(WiFi.encryptionType(i));
+    Serial.println(encryptionTypeDescription);
+    Serial.println("-----------------------");
+    int curidx = fetchWifiIndex(ssid.c_str());
+    if (curidx >= 0 && index == -1) {
+      index = curidx;
+      Serial.printf("Match found at scan entry %d, config network %d\n", i, index);
+    }
+  }
+  int lastl = (disph / dispys - 2) * dispys;
+  if (index >= 0) { // some network was found
+    Serial.print("Connecting to: "); Serial.print(fetchWifiSSID(index));
+    Serial.print(" with password "); Serial.println(fetchWifiPw(index));
+
+    disp.rdis->drawString(0, lastl, "Conn:");
+    disp.rdis->drawString(6 * dispxs, lastl, fetchWifiSSID(index));
+    WiFi.begin(fetchWifiSSID(index), fetchWifiPw(index));
+    while (WiFi.status() != WL_CONNECTED && cnt < MAXWIFIDELAY)  {
+      delay(500);
+      Serial.print(".");
+      if (cnt == 5) {
+        // my FritzBox needs this for reconnecting
+        WiFi.disconnect(true);
+        delay(500);
+        WiFi.begin(fetchWifiSSID(index), fetchWifiPw(index));
+        Serial.print("Reconnecting to: "); Serial.print(fetchWifiSSID(index));
+        Serial.print(" with password "); Serial.println(fetchWifiPw(index));
+        delay(500);
+      }
+      disp.rdis->drawString(15 * dispxs, lastl + dispys, _scan[cnt & 1]);
+      cnt++;
+    }
+  }
+  if (index < 0 || cnt >= MAXWIFIDELAY) { // no network found, or connect not successful
+    WiFi.disconnect(true);
+    delay(1000);
+    startAP();
+    IPAddress myIP = WiFi.softAPIP();
+    Serial.print("AP IP address: ");
+    Serial.println(myIP);
+    disp.rdis->drawString(0, lastl, "AP:             ");
+    disp.rdis->drawString(6 * dispxs, lastl + 1, networks[0].id.c_str());
+    delay(3000);
+  } else {
+    Serial.println("");
+    Serial.println("WiFi connected");
+    Serial.println("IP address: ");
+    String localIPstr = WiFi.localIP().toString();
+    Serial.println(localIPstr);
+    sonde.setIP(localIPstr.c_str(), false);
+    sonde.updateDisplayIP();
+    wifi_state = WIFI_CONNECTED;
+    bool hasRS92 = false;
+    for (int i = 0; i < MAXSONDE; i++) {
+      if (sonde.sondeList[i].type == STYPE_RS92) hasRS92 = true;
+    }
+    if (hasRS92) {
+      geteph();
+      get_eph("/brdc");
+    }
+    delay(3000);
+  }
+  enableNetwork(true);
+  initialMode();
+}
+
+
+/// Testing OTA Updates
+/// somewhat based on Arduino's AWS_S3_OTA_Update
+// Utility to extract header value from headers
+String getHeaderValue(String header, String headerName) {
+  return header.substring(strlen(headerName.c_str()));
+}
+
+// OTA Logic
+void execOTA() {
+  int contentLength = 0;
+  bool isValidContentType = false;
+  sonde.clearDisplay();
+  disp.rdis->setFont(FONT_SMALL);
+  disp.rdis->drawString(0, 0, "RadioSonde Upgrade");
+  String dispHost = updateHost.substring(0, 14);
+  //disp.rdis->drawString(2, 0, dispHost.c_str());
+
+  Serial.println("Connecting to: " + updateHost);
+  // Connect to Update host
+  if (client.connect(updateHost.c_str(), updatePort)) {
+    // Connection succeeded, fecthing the bin
+    Serial.println("Fetching bin: " + String(*updateBin));
+    disp.rdis->drawString(0, 1, "Fetching update");
+
+    // Get the contents of the bin file
+    client.print(String("GET ") + *updateBin + " HTTP/1.1\r\n" +
+                 "Host: " + updateHost + "\r\n" +
+                 "Cache-Control: no-cache\r\n" +
+                 "Connection: close\r\n\r\n");
+
+    // Check what is being sent
+    //    Serial.print(String("GET ") + bin + " HTTP/1.1\r\n" +
+    //                 "Host: " + host + "\r\n" +
+    //                 "Cache-Control: no-cache\r\n" +
+    //                 "Connection: close\r\n\r\n");
+
+    unsigned long timeout = millis();
+    while (client.available() == 0) {
+      if (millis() - timeout > 5000) {
+        Serial.println("Client Timeout !");
+        client.stop();
+        return;
+      }
+    }
+    // Once the response is available,
+    // check stuff
+
+    /*
+       Response Structure
+        HTTP/1.1 200 OK
+        x-amz-id-2: NVKxnU1aIQMmpGKhSwpCBh8y2JPbak18QLIfE+OiUDOos+7UftZKjtCFqrwsGOZRN5Zee0jpTd0=
+        x-amz-request-id: 2D56B47560B764EC
+        Date: Wed, 14 Jun 2017 03:33:59 GMT
+        Last-Modified: Fri, 02 Jun 2017 14:50:11 GMT
+        ETag: "d2afebbaaebc38cd669ce36727152af9"
+        Accept-Ranges: bytes
+        Content-Type: application/octet-stream
+        Content-Length: 357280
+        Server: AmazonS3
+
+        {{BIN FILE CONTENTS}}
+
+    */
+    while (client.available()) {
+      // read line till /n
+      String line = client.readStringUntil('\n');
+      // remove space, to check if the line is end of headers
+      line.trim();
+
+      // if the the line is empty,
+      // this is end of headers
+      // break the while and feed the
+      // remaining `client` to the
+      // Update.writeStream();
+      if (!line.length()) {
+        //headers ended
+        break; // and get the OTA started
+      }
+
+      // Check if the HTTP Response is 200
+      // else break and Exit Update
+      if (line.startsWith("HTTP/1.1")) {
+        if (line.indexOf("200") < 0) {
+          Serial.println("Got a non 200 status code from server. Exiting OTA Update.");
+          break;
+        }
+      }
+
+      // extract headers here
+      // Start with content length
+      if (line.startsWith("Content-Length: ")) {
+        contentLength = atoi((getHeaderValue(line, "Content-Length: ")).c_str());
+        Serial.println("Got " + String(contentLength) + " bytes from server");
+      }
+
+      // Next, the content type
+      if (line.startsWith("Content-Type: ")) {
+        String contentType = getHeaderValue(line, "Content-Type: ");
+        Serial.println("Got " + contentType + " payload.");
+        if (contentType == "application/octet-stream") {
+          isValidContentType = true;
+        }
+      }
+    }
+  } else {
+    // Connect to updateHost failed
+    // May be try?
+    // Probably a choppy network?
+    Serial.println("Connection to " + String(updateHost) + " failed. Please check your setup");
+    // retry??
+    // execOTA();
+  }
+
+  // Check what is the contentLength and if content type is `application/octet-stream`
+  Serial.println("contentLength : " + String(contentLength) + ", isValidContentType : " + String(isValidContentType));
+  disp.rdis->drawString(0, 2, "Len: ");
+  String cls = String(contentLength);
+  disp.rdis->drawString(5, 2, cls.c_str());
+
+  // check contentLength and content type
+  if (contentLength && isValidContentType) {
+    // Check if there is enough to OTA Update
+    bool canBegin = Update.begin(contentLength);
+    disp.rdis->drawString(0, 4, "Starting update");
+
+    // If yes, begin
+    if (canBegin) {
+      Serial.println("Begin OTA. This may take 2 - 5 mins to complete. Things might be quite for a while.. Patience!");
+      // No activity would appear on the Serial monitor
+      // So be patient. This may take 2 - 5mins to complete
+      disp.rdis->drawString(0, 5, "Please wait!");
+      size_t written = Update.writeStream(client);
+
+      if (written == contentLength) {
+        Serial.println("Written : " + String(written) + " successfully");
+      } else {
+        Serial.println("Written only : " + String(written) + "/" + String(contentLength) + ". Retry?" );
+        // retry??
+        // execOTA();
+      }
+
+      if (Update.end()) {
+        Serial.println("OTA done!");
+        if (Update.isFinished()) {
+          Serial.println("Update successfully completed. Rebooting.");
+          disp.rdis->drawString(0, 7, "Rebooting....");
+          delay(1000);
+          ESP.restart();
+        } else {
+          Serial.println("Update not finished? Something went wrong!");
+        }
+      } else {
+        Serial.println("Error Occurred. Error #: " + String(Update.getError()));
+      }
+    } else {
+      // not enough space to begin OTA
+      // Understand the partitions and
+      // space availability
+      Serial.println("Not enough space to begin OTA");
+      client.flush();
+    }
+  } else {
+    Serial.println("There was no content in the response");
+    client.flush();
+  }
+  // Back to some normal state
+  enterMode(ST_DECODER);
+}
+
+
+void loop() {
+  if(sonde.config.buzzerOn==1){
+    ledcSetup(0, sonde.config.buzzerFreq, 8);
+    ledcAttachPin(sonde.config.buzzerPort, 0);
+  }
+  Serial.printf("\nRunning main loop in state %d. free heap: %d;\n", mainState, ESP.getFreeHeap());
+  Serial.printf("currentDisp:%d lastDisp:%d\n", currentDisplay, lastDisplay);
+  switch (mainState) {
+    case ST_DECODER: 
+#ifndef DISABLE_MAINRX    
+      loopDecoder();
+#else
+      delay(1000);
+#endif      
+      break;
+    case ST_SPECTRUM: loopSpectrum(); break;
+    case ST_WIFISCAN: loopWifiScan(); break;
+    case ST_UPDATE: execOTA(); break;
+    case ST_TOUCHCALIB: loopTouchCalib(); break;
+  }
+#if 0
+  int rssi = sx1278.getRSSI();
+  Serial.print("  RSSI: ");
+  Serial.print(rssi);
+
+  int gain = sx1278.getLNAGain();
+  Serial.print(" LNA Gain: "),
+               Serial.println(gain);
+#endif
+  loopWifiBackground();
+  if (currentDisplay != lastDisplay && (mainState == ST_DECODER)) {
+    disp.setLayout(currentDisplay);
+    sonde.clearDisplay();
+    sonde.updateDisplay();
+    lastDisplay = currentDisplay;
+
+  }
+  Serial.printf("Unused stack: %d\n", uxTaskGetStackHighWaterMark(0));
+
+}
diff --git a/RadioSonde_FSK/data/config.txt b/RadioSonde_FSK/data/config.txt
new file mode 100755
index 0000000..81ec00b
--- /dev/null
+++ b/RadioSonde_FSK/data/config.txt
@@ -0,0 +1,109 @@
+#-------------------------------#
+# Hardware depending settings
+#-------------------------------#
+# pin: 255=disabled; x=button x+128=touch button
+button_pin=2
+button2_pin=4
+# No specification in config file: try autodetection (gpio4 pin level at startup)
+#button_pin=0
+#button2_pin=255
+#button2_axp=0
+# LED port
+#led_pout=-1
+# OLED Setup is depending on hardware of LoRa board
+# TTGO v1:  SDA=4  SCL=15, RST=16 
+# TTGO v2:  SDA=21 SCL=22, RST=16
+# T-BEAM, OLED: SDA=21, SCL=22, RST=16
+# T-BEAM, ILI9225: SDA=4, CLK=21, RS=2, RST=22, CS=0
+# No specification in config file: try autodetection (gpio4 pin level at startup)
+#
+# disptype: 0=OLED, 1=ILI9225
+#disptype=0
+#oled_sda=21
+#oled_scl=22
+#oled_rst=16
+oled_orient=1
+gpsOn=0
+gps_rxd=-1
+gps_txd=-1
+gps_lat=43.59169
+gps_lon=7.10071
+gps_alt=123
+# Show AFC value (for RS41 only, maybe also DFM, but useful for RS92 or M10)
+# showafc=1
+# Frequency correction, in Hz
+# freqofs=0
+#-------------------------------#
+# General config settings
+#-------------------------------#
+maxsonde=20
+debug=0
+# wifi mode: 1=client in background; 2=AP in background; 3=client on startup, ap if failure
+wifi=3
+# TCP/IP KISS TNC in port 14590 for APRSdroid (0=disabled, 1=enabled)
+kisstnc.active = 1
+mdnsname=radiosonde
+# display configuration. List of "displays"
+# first entry: "Scanner" display
+# second entry: default "Receiver" display
+# additional entries: alternative receiver display, activated by button
+display=0,1,2,3,4,5,6
+# set to -1 to disable (used for "N" values in timers in screens.txt). Value in seconds
+norx_timeout=20
+vbatmax=1.86
+vbatmin=1.64
+sdOn=0
+buzzerOn=0
+buzzerPort=12
+buzzerFreq=700
+dbsmetre=1
+#-------------------------------#
+# Spectrum display settings
+#-------------------------------#
+startfreq=400
+channelbw=10
+spectrum=30 #10
+noisefloor=-125
+marker=1
+#-------------------------------#
+# APRS settings
+#-------------------------------#
+call=NOCALL
+passcode=123456
+#-------------------------------#
+# Sonde specific settings: bandwidth
+# valid values: 3100, 3900, 5200, 6300, 7800, 10400, 12500,
+# 15600, 20800, 25000, ...
+# other values will be rounded up to the next valid value
+# rs92.alt2d: default altitude used by RS92 decoder if only 3 sats available
+#-------------------------------#
+rs41.agcbw=12500
+rs41.rxbw=6300
+rs92.rxbw=12500
+rs92.alt2d=480
+dfm.agcbw=20800
+dfm.rxbw=10400
+#-------------------------------#
+# axudp for sending to aprsmap
+#-------------------------------#
+# local use only, do not feed to public services
+# data not sanitized / quality checked, outliers not filtered out
+axudp.active=1
+axudp.host=monurl.fr
+axudp.port=14580
+axudp.symbol=/O
+axudp.highrate=1
+axudp.idformat=0
+#-------------------------------#
+# maybe some time in the future
+#-------------------------------#
+# currently simply not implemented, no need to put anything here anyway
+tcp.active=0
+tcp.host=radiosondy.info
+tcp.port=14590
+tcp.symbol=/O
+tcp.highrate=20
+tcp.idformat=0
+#-------------------------------#
+# EOF
+#-------------------------------#
diff --git a/RadioSonde_FSK/data/fontawesome-webfont.eot b/RadioSonde_FSK/data/fontawesome-webfont.eot
new file mode 100755
index 0000000..33b2bb8
Binary files /dev/null and b/RadioSonde_FSK/data/fontawesome-webfont.eot differ
diff --git a/RadioSonde_FSK/data/fontawesome-webfont.woff b/RadioSonde_FSK/data/fontawesome-webfont.woff
new file mode 100755
index 0000000..8b280b9
Binary files /dev/null and b/RadioSonde_FSK/data/fontawesome-webfont.woff differ
diff --git a/RadioSonde_FSK/data/index.html b/RadioSonde_FSK/data/index.html
new file mode 100755
index 0000000..4c62df2
--- /dev/null
+++ b/RadioSonde_FSK/data/index.html
@@ -0,0 +1,187 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>RadioSonde (version %VERSION_ID%)</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <link rel="icon" href="data:,">
+  <link rel="stylesheet" type="text/css" href="style.css">
+</head>
+<body style="background-color: #008CBA;">
+<div style="background-color: #FFFFFF;">
+<h2><i onclick="w3_open()" class="fa fa-bars"></i>&nbsp;&nbsp;RadioSonde (version %VERSION_ID%)</h2>
+</div>
+<!--
+  <p>GPIO state: <strong> %STATE%</strong></p>
+  <p><a href="/on"><button class="button">ON</button></a></p>
+  <p><a href="/off"><button class="button button2">OFF</button></a></p>
+-->
+
+<!-- Side Navigation -->
+<nav style="text-align: left; background-color: #aaa; font-weight: bold; display:none" id="mySidebar">
+  <h3>MENU</h3>
+	  <button class="tablinks fa fa-close" onclick="w3_close();"> Close</button><br>
+	  <button class="tablinks fa fa-dashboard" onclick="selTab(event,'QRG'); w3_close()" id="defaultTab"> QRG</button><br>
+	  <button class="tablinks fa fa-wifi" onclick="selTab(event,'WiFi'); w3_close()"> WiFi</button><br>
+	  <button class="tablinks fa fa-database" onclick="selTab(event,'Data'); w3_close()"> Data</button><br>
+	  <button class="tablinks fa fa-map-marker" onclick="selTab(event,'SondeMap'); w3_close()"> URL SondeMap</button><br>
+	  <button class="tablinks fa fa-gears" onclick="selTab(event,'Config'); w3_close()"> Config</button><br>
+	  <button class="tablinks fa fa-sliders" onclick="selTab(event,'Control'); w3_close()"> Control</button><br>
+	  <button class="tablinks fa fa-download" onclick="selTab(event,'Update'); w3_close()"> Update</button><br>
+	  <button class="tablinks fa fa-support" onclick="selTab(event,'About'); w3_close()"> About</button><br><br><br><br>
+</nav>
+
+<div id="QRG" class="tabcontent">
+	<h3> QRG - Setup</h3>
+	<iframe src="qrg.html" style="border:none;" width="100%%" height="100%%"></iframe>
+</div>
+
+<div id="WiFi" class="tabcontent">
+	<h3> WiFi - Settings</h3>
+	<iframe src="wifi.html" style="border:none;" width="100%%" height="100%%"></iframe>
+</div>
+
+<div id="Data" class="tabcontent" data-src="status.html">
+	<h3>Data</h3>
+	<iframe src="status.html" style="border:none;" width="100%%" height="100%%"></iframe>
+</div>
+
+<div id="SondeMap" class="tabcontent" data-src="sondemap.html">
+	<iframe src="sondemap.html" style="border:none;" width="98%%" height="98%%"></iframe>
+</div>
+<!--
+<div id="SondeMap" class="tabcontent" data-src="http://wx.dl2mf.de/#?">
+	<iframe src="http://wx.dl2mf.de/" style="border:none;" width="98%%" height="98%%"></iframe>
+</div>
+<div id="SondeMap2" class="tabcontent" data-src="https://radiosondy.info/">
+	<iframe src="https://radiosondy.info/" style="border:none;" width="98%%" height="98%%"></iframe>
+</div>
+<div id="SondeMap3" class="tabcontent" data-src="https://tracker.sondehub.org/?sondehub=1#!mt=osm&mz=8&qm=6_hours&mc=43.76665,6.24011&f=none&q=RS_*;*chase">
+	<iframe src="https://tracker.sondehub.org/?sondehub=1#!mt=osm&mz=8&qm=6_hours&mc=43.76665,6.24011&f=none&q=RS_*;*chase" style="border:none;" width="98%%" height="98%%"></iframe>
+</div>
+-->
+<div id="Config" class="tabcontent">
+	<h3>Configuration</h3>
+	<iframe src="config.html" style="border:none;" width="100%%" height="100%%"></iframe>
+</div>
+
+<div id="Control" class="tabcontent">
+	<h3>Control</h3>
+	<iframe src="control.html" style="border:none;" width="100%%" height="100%%"></iframe>
+</div>
+
+<div id="Update" class="tabcontent">
+	<h3>Update</h3>
+	<iframe src="update.html" style="border:none;" width="100%%" height="100%%"></iframe>
+</div>
+
+<div id="About" class="tabcontent">
+	<h3>About</h3>
+   %VERSION_NAME%<br>
+   Copyright &copy; 2019 by Hansi Reiser, DL9RDZ<br>
+   (version %VERSION_ID%)<br>
+   with mods by <a href="https://www.dl2mf.de/" target="_blank">Meinhard Guenther, DL2MF</a><br>
+   <br>
+   Autodetect info: %AUTODETECT_INFO%<br>
+   <br>
+    CopyLeft 2020 Modifier par <a href="http://openpmr.cla.fr">FRS2013</a><br>
+    Licence GNU GPL <a href="https://www.gnu.org/licenses/gpl-2.0.txt">https://www.gnu.org/licenses/gpl-2.0.txt</a>
+    for details
+</div>
+
+<div style="background-color: #008CBA;"><br>
+<h2>by FRS2013</h2>
+</div>
+<script>
+function selTab(evt, id) {
+	var i, tabcontent, tablinks;
+	tabcontent=document.getElementsByClassName("tabcontent");
+	for(i=0; i<tabcontent.length; i++) {
+		tabcontent[i].style.display = "none";
+		var link = tabcontent[i].dataset.src;
+		if(link) {
+			var iframe = tabcontent[i].getElementsByTagName("iframe")[0];
+			iframe.setAttribute("src", "");
+		}
+	}
+	tablinks=document.getElementsByClassName("tablinks");
+	for(i=0; i<tablinks.length; i++) {
+		tablinks[i].className = tablinks[i].className.replace(" active", "");
+	}	
+	var act = document.getElementById(id);
+	act.style.display = "block";
+	evt.currentTarget.className += " active";
+	
+	var link = act.dataset.src;
+	if(link) {
+		var iframe = act.getElementsByTagName("iframe")[0];
+		iframe.setAttribute("src", link);
+	}
+}
+document.getElementById("defaultTab").click();
+</script>
+<!-- Script for Sidebar, Tabs, Accordions, Progress bars and slideshows -->
+<script>
+// Side navigation
+function w3_open() {
+  var x = document.getElementById("mySidebar");
+  x.style.width = "100%";
+  x.style.height = "80%";
+  x.style.fontSize = "40px";
+  x.style.paddingTop = "0%";
+  x.style.display = "block";
+}
+function w3_close() {
+  document.getElementById("mySidebar").style.display = "none";
+}
+
+// Tabs
+function openCity(evt, cityName) {
+  var i;
+  var x = document.getElementsByClassName("city");
+  for (i = 0; i < x.length; i++) {
+    x[i].style.display = "none";
+  }
+  var activebtn = document.getElementsByClassName("testbtn");
+  for (i = 0; i < x.length; i++) {
+    activebtn[i].className = activebtn[i].className.replace(" w3-dark-grey", "");
+  }
+  document.getElementById(cityName).style.display = "block";
+  evt.currentTarget.className += " w3-dark-grey";
+}
+
+var mybtn = document.getElementsByClassName("testbtn")[0];
+mybtn.click();
+
+// Accordions
+function myAccFunc(id) {
+  var x = document.getElementById(id);
+  if (x.className.indexOf("w3-show") == -1) {
+    x.className += " w3-show";
+  } else { 
+    x.className = x.className.replace(" w3-show", "");
+  }
+}
+
+// Slideshows
+var slideIndex = 1;
+
+function plusDivs(n) {
+  slideIndex = slideIndex + n;
+  showDivs(slideIndex);
+}
+
+function showDivs(n) {
+  var x = document.getElementsByClassName("mySlides");
+  if (n > x.length) {slideIndex = 1}    
+  if (n < 1) {slideIndex = x.length} ;
+  for (i = 0; i < x.length; i++) {
+    x[i].style.display = "none";  
+  }
+  x[slideIndex-1].style.display = "block";  
+}
+
+showDivs(1);
+</script>
+</body>
+</html>
+
diff --git a/RadioSonde_FSK/data/networks.txt b/RadioSonde_FSK/data/networks.txt
new file mode 100755
index 0000000..877af22
--- /dev/null
+++ b/RadioSonde_FSK/data/networks.txt
@@ -0,0 +1,4 @@
+Radiosonde
+Radiosonde
+VotreSSID
+votrepass
diff --git a/RadioSonde_FSK/data/qrg.txt b/RadioSonde_FSK/data/qrg.txt
new file mode 100755
index 0000000..b485d3d
--- /dev/null
+++ b/RadioSonde_FSK/data/qrg.txt
@@ -0,0 +1,24 @@
+# Frequency in Mhz (format nnn.nnn)
+# Type (4=RS41, R=RS92, 6=DFM normal, DFM-06, 9=DFM inverted, DFM-09, M=M10)
+#
+400.000 9 + Test(FR)
+401.500 4 - Santander(ES)
+402.000 M + Nimes(FR)
+402.800 4 + Cuneo(IT)
+403.000 6 + Ajactio(FR)
+403.010 6 + Canjuers(FR)
+404.200 4 + Rome(IT)
+404.500 4 - Payern(CH)
+404.500 M - Bourges(FR)
+404.789 9 + Frejus1(FR)
+404.800 4 + Milan(IT)
+405.000 R + Frejus2(FR)
+401.199 M - Trappes(FR)
+405.789 9 + Pegomas(FR)
+405.100 4 - Lindenberg
+405.700 4 - Bergen
+405.900 4 - Bergen_2
+405.100 4 - Meppen_2
+405.300 4 - Essen
+405.500 4 - Essen_2
+# end
diff --git a/RadioSonde_FSK/data/screens.txt b/RadioSonde_FSK/data/screens.txt
new file mode 100755
index 0000000..cac60a3
--- /dev/null
+++ b/RadioSonde_FSK/data/screens.txt
@@ -0,0 +1,249 @@
+# Definition of display content and action behaviour
+#
+# Timer: (view timer, rx timer, norx timer)
+# - value -1: timer is disabled; value>=0: timer fires after (value) seconds
+# - view timer: time since current view (display mode and sonde) was started
+# - rx timer: time since when sonde data has been received continuously (trigger immediatly after RX)
+# - norx timer: time since when no sonde data has been received continuously
+#   (rx and norx timer is started after tuning a new frequency and receiving a signal or not receiving
+#    anything for a 1s period)
+# 
+# Actions:
+# - W: activate WiFi scan
+# - F: activate frequency spectrum display
+# - 0: activate "Scan:" display (this is basically just display mode 0)
+# - x: (1..N): activate display mode x [deprecated]
+# - >: activate next display mode 
+# - D: activate default receiver display (display mode specified in config)
+# - +: advance to next active sonde from QRG config
+# - #: no action
+#
+# Display content (lower/upper case: small/large font)
+#    line,column=content
+# for ILI9225 its also possible to indicate
+#    line,column,width=content          for text within a box of width 'width'
+#    line,column,-width=content         for right-justified text
+#
+# XText : Text
+# F(suffix): frequency (with suffix, e.g., " MHz")
+# L latitade
+# O lOngitute
+# A altitude
+# Hm(suffix) hor. speed m/s (suffix: e.g. "m/s"; no suffix=>m/s as 16x8 bitmap for SSD1306 display only)
+# Hk(suffix) hor. speed km/h (suffix: e.g. "km/h"; no suffix=>km/h as 16x8 bitmap for SSD1306 display only)
+# V(suffix) vert. speef (suffix: e.g. "m/s"; no suffix=>m/s  as 16x8 bitmap for SSD1306 display only)
+# Ix sonde ID (dfm format by x: d=>dxlaprs, a=>autorx, s=>real serial number)
+# Q signal quality statistics bar
+# T type string (RS41/DFM9/DFM6/RS92)
+# C afC value
+# N ip address (only tiny font)
+# S scan list entry info:  l/empty: launch site name, #=entry nr, t=total entries, a=active entries, /: #/t  
+# K RS41 kill timer values: Kl launch timer, Kb burst timer, Kc kill countdown
+#   format: K_4: h:mm k_6: h:mm:ss k_s: sssss,  nothing shown for other sonde
+# Mx telemetry value x (t temp p preassure h hyg) [not yet implemented, maybe some day in future]
+# Gx  GPS-related data
+#     raw data from GPS:  GA, GO, GH, GC: LAtitude, lOngitude, Altutide(Height), Course over ground
+#     relative to sonde:  GD, GI, GB: Distance, dIrection (absolute), relative Bearing
+# G0  GPS circle diagram e.g.  3,5=g0NCS,50,ff0000,000033,5,ffff00,4,ffffff
+#     "N" (what is on top: N=north C=course)
+#     "C" (where does the arrow point to: C=course, S=sonde)
+#     "S" (what is shown by the bullet: C=course, S=sonde)
+#     50: circle radius, followed by fg and bg color
+#     5: bullet radius, followed by fg color
+#     4: arrow width, followed by fg color
+# R RSSI
+# B battery(T-Beam 1.0) S=status V=Batt.Volt C=charge current D=discharge current
+#                       U=USB volt I=USB current  T=IC temp
+# AA Azimut degres
+#
+# fonts=x,y can be used to select font (x=small, y=large) for all items below
+# for SSD1306, x and y can be used to select one of those fonts:
+# (y should be a 1x2 font (1,5,6,7), x a small font)
+#                u8x8_font_chroma48medium8_r,        // 0 ** default small
+#                u8x8_font_7x14_1x2_f,               // 1 ** default large
+#                u8x8_font_amstrad_cpc_extended_f,   // 2
+#                u8x8_font_5x7_f,                    // 3
+#                u8x8_font_5x8_f,                    // 4
+#                u8x8_font_8x13_1x2_f,               // 5
+#                u8x8_font_8x13B_1x2_f,              // 6
+#                u8x8_font_7x14B_1x2_f,              // 7
+#                u8x8_font_artossans8_r,             // 8
+#                u8x8_font_artosserif8_r,            // 9
+#                u8x8_font_torussansbold8_r,         // 10 
+#                u8x8_font_victoriabold8_r,          // 11
+#                u8x8_font_victoriamedium8_r,        // 12
+#                u8x8_font_pressstart2p_f,           // 13
+#                u8x8_font_pcsenior_f,               // 14
+#                u8x8_font_pxplusibmcgathin_f,       // 15
+#                u8x8_font_pxplusibmcga_f,           // 16
+#                u8x8_font_pxplustandynewtv_f,       // 17
+#
+#
+# color=rrggbb,rrggbb  can be used to select color (foreground, background)
+# see https://github.com/Nkawu/TFT_22_ILI9225/wiki#color-reference for example (use without "#"-sign)
+#
+# for TFT display, coordinates and width are multiplied by xscale,yscale and later used in pixels
+# with scale=1,1 you can directly use pixel coordinates.  (default: xscale=13,yscale=22 => 8 lines, 16 columns)
+###########
+# 
+# Default configuration for "Scanner" display:
+# - view timer disabled;  rx timer=0; norx timer = 0
+#   => after 1 second immediately an action is triggered
+#      (norx: go to next sonde; rx: go to default receiver display)
+# - key1 actions: D,0,F,W
+#   => Button press activates default receiver view, double press does nothing
+#      Mid press activates Spectrum display, long press activates Wifi scan
+# - key2 has no function
+@Scanner
+timer=-1,0,0
+key1action=D,#,F,W
+key2action=#,#,#,#
+timeaction=#,D,+
+0,0=XScan
+0,5=S#:
+0,9=T
+3,0=F MHz
+5,0=S
+7,0=y%
+7,5=n
+
+############
+# Default configuration for "Legacy" display:
+# - view timer=-1, rx timer=-1 (disabled); norx timer=20 (or -1 for "old" behaviour)
+#    => norx timer fires after not receiving a singla for 20 seconds
+# - key1 actions: +,0,F,W
+#    => Button1 press: next sonde; double press => @Scanner display
+#    => Mid press activates Spectrum display, long press activates Wifi scan
+# - key2 actions: 2,#,#,#
+#    => BUtton2 activates display 2 (@Field)
+# - timer actions: #,#,0
+#   (norx timer: if no signal for >20 seconds: go back to scanner mode)
+#
+@Legacy
+timer=-1,-1,N
+key1action=+,0,F,W
+key2action=>,#,#,#
+timeaction=#,#,0
+0,0=t
+0,5=f MHz
+1,0=is
+1,8=c
+2,0=L
+2,10=a
+3,10=h
+4,0=O
+4,9=v
+5,9=gC
+5,13=gB
+6,0=R
+6,7=Q
+7,6=gD
+7,12=gI°
+
+
+############
+# Configuratoon for "Field" display (display 2)
+# similar to @Legacy, but no norx timer, and Key2 goes to display 4
+@Field
+timer=-1,-1,N
+key1action=+,0,F,W
+key2action=>,#,#,#
+timeaction=#,#,#
+0,0=Is
+2,0=L
+2,9=xEl:
+2,12=gE
+4,0=O
+3,10=h
+4,9=v
+5,9=gC
+5,13=gB
+6,0=A
+6,7=Q
+7,6=gD
+7,12=gI°
+
+############
+# Configuration for "Field2" display (display 3)
+# similar to @Field
+@Field2
+timer=-1,-1,N
+key1action=+,0,F,W
+key2action=>,#,#,#
+timeaction=#,#,#
+0,0=Is
+0,9=f
+1,12=t
+2,9=xEl:
+2,12=gE
+2,0=L
+3,10=h
+4,0=O
+4,9=v
+5,9=gC
+5,13=gB
+6,0=A
+6,7=Q
+7,6=gD
+7,12=gI°
+
+#############
+# Configuration for "GPS" display
+# not yet the final version, just for testing
+@GPSDIST
+timer=-1,-1,-1
+key1action=+,0,F,W
+key2action=>,#,#,#
+timeaction=#,#,#
+0,0=Is
+0,9=f
+1,12=t
+2,0=L
+4,0=O
+2,10=a
+3,10=h
+4,9=v
+5,9=gC
+5,13=gB
+6,0=xEl:
+6,2=gE
+6,7=Q
+7,0=gW
+7,2=xd=
+7,4=gD
+7,11=gI°
+
+############
+# Boussole Oled
+@BOUSSOLE
+timer=-1,-1,-1
+key1action=+,0,F,W
+key2action=>,#,#,#
+timeaction=#,#,#
+0,0=g0
+0,10=a
+1,10=h
+2,9=v
+3,10=gC
+3,13=gB
+4,9=gD
+5,11=gI°
+6,9=xEl:
+6,11=gE
+7,9=t
+
+############
+@BatteryOLED
+timer=-1,-1,-1
+key1action=+,0,F,W
+key2action=>,#,#,#
+timeaction=#,#,#
+fonts=0,1
+0,0=xBat.Status:
+2,0=xCpu:
+2,7=bVV
+4,0=xVbus:
+4,7=bCV 
+6,0=xPower:
+6,7=bPmW
+
diff --git a/RadioSonde_FSK/data/sondemap.html b/RadioSonde_FSK/data/sondemap.html
new file mode 100755
index 0000000..e0ed05b
--- /dev/null
+++ b/RadioSonde_FSK/data/sondemap.html
@@ -0,0 +1,10 @@
+<html>
+<head>
+<link rel=\"stylesheet\" type=\"text/css\" href=\"style.css\">
+</head>
+<body>
+<button class="tablinks" onclick="javascript:window.open('http://wx.dl2mf.de/','_self')"> Sonde Map</button><br><br>
+<button class="tablinks" onclick="javascript:window.open('https://radiosondy.info/','_self')"> RadioSony</button><br><br>
+<button class="tablinks" onclick="javascript:window.open('https://tracker.sondehub.org/?sondehub=1#!mt=osm&mz=8&qm=6_hours&mc=43.76665,6.24011&f=none&q=RS_*;*chase','_self')"> SondeHub</button><br><br>
+ </body>
+ </html>
diff --git a/RadioSonde_FSK/data/style.css b/RadioSonde_FSK/data/style.css
new file mode 100755
index 0000000..d12fbe7
--- /dev/null
+++ b/RadioSonde_FSK/data/style.css
@@ -0,0 +1,659 @@
+body, html {
+	height: 100%;
+	margin: 0;
+	font-family: Arial;
+}
+
+table, th, td {
+	border: 1px solid black;
+	border-collapse: collapse;
+	background-color: #ddd
+}
+
+td#caption {
+	text-align: center;
+	background-color: #aaa;
+	font-weight: bold;
+}
+
+td#sfreq {
+	background-color: #ccc;
+}
+
+.tab {
+	overflow: hidden;
+	border: 1px solid #ccc;
+}
+
+.tab button {
+	background-color: inherit;
+	float: left;
+	border: none;
+	outline: none;
+	cursor: pointer;
+	padding: 14px 16px;
+	transition: 0.3s;
+}
+
+.tab button:hover {
+	background-color: #ddd;
+}
+
+.tab button.active {
+	background-color: #ccc;
+}
+
+.tabcontent {
+	display: none;
+	padding: 6px 12px;
+	border: 1px solid #ccc;
+	border-top: none;
+	height: 100%;
+	background-color: #FFFFFF;
+}
+
+html {
+  font-family: Helvetica;
+  display: inline-block;
+  margin: 0px auto;
+  text-align: center;
+}
+h1{
+  color: #0F3376;
+  padding: 2vh;
+}
+p{
+  font-size: 1.5rem;
+}
+.button {
+  display: inline-block;
+  background-color: #008CBA;
+  border: none;
+  border-radius: 4px;
+  color: white;
+  padding: 16px 40px;
+  text-decoration: none;
+  font-size: 30px;
+  margin: 2px;
+  cursor: pointer;
+}
+.button2 {
+  background-color: #f44336;
+}
+
+/*!
+ *  Font Awesome 4.3.0 by @davegandy - http://fontawesome.io - @fontawesome
+ *  License - http://fontawesome.io/license (Font: SIL OFL 1.1, CSS: MIT License)
+ */@font-face{font-family:'FontAwesome';
+src:url('fontawesome-webfont.eot?v=4.3.0');
+src:url('fontawesome-webfont.eot?#iefix&v=4.3.0') format('embedded-opentype'),url('fontawesome-webfont.woff2?v=4.3.0') format('woff2'),url('fontawesome-webfont.woff?v=4.3.0') format('woff'),url('fontawesome-webfont.ttf?v=4.3.0') format('truetype'),url('fontawesome-webfont.svg?v=4.3.0#fontawesomeregular') format('svg');
+font-weight:normal;
+font-style:normal}.fa{display:inline-block;
+font:normal normal normal 14px/1 FontAwesome;
+font-size:inherit;
+text-rendering:auto;
+-webkit-font-smoothing:antialiased;
+-moz-osx-font-smoothing:grayscale;
+transform:translate(0, 0)}.fa-lg{font-size:1.33333333em;
+line-height:.75em;
+vertical-align:-15%}.fa-2x{font-size:2em}.fa-3x{font-size:3em}.fa-4x{font-size:4em}.fa-5x{font-size:5em}.fa-fw{width:1.28571429em;
+text-align:center}.fa-ul{padding-left:0;
+margin-left:2.14285714em;
+list-style-type:none}.fa-ul>li{position:relative}.fa-li{position:absolute;
+left:-2.14285714em;
+width:2.14285714em;
+top:.14285714em;
+text-align:center}.fa-li.fa-lg{left:-1.85714286em}.fa-border{padding:.2em .25em .15em;
+border:solid .08em #eee;
+border-radius:.1em}.pull-right{float:right}.pull-left{float:left}.fa.pull-left{margin-right:.3em}.fa.pull-right{margin-left:.3em}.fa-spin{-webkit-animation:fa-spin 2s infinite linear;
+animation:fa-spin 2s infinite linear}.fa-pulse{-webkit-animation:fa-spin 1s infinite steps(8);
+animation:fa-spin 1s infinite steps(8)}@-webkit-keyframes fa-spin{0%{-webkit-transform:rotate(0deg);
+transform:rotate(0deg)}100%{-webkit-transform:rotate(359deg);
+transform:rotate(359deg)}}@keyframes fa-spin{0%{-webkit-transform:rotate(0deg);
+transform:rotate(0deg)}100%{-webkit-transform:rotate(359deg);
+transform:rotate(359deg)}}.fa-rotate-90{filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=1);
+-webkit-transform:rotate(90deg);
+-ms-transform:rotate(90deg);
+transform:rotate(90deg)}.fa-rotate-180{filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=2);
+-webkit-transform:rotate(180deg);
+-ms-transform:rotate(180deg);
+transform:rotate(180deg)}.fa-rotate-270{filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=3);
+-webkit-transform:rotate(270deg);
+-ms-transform:rotate(270deg);
+transform:rotate(270deg)}.fa-flip-horizontal{filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1);
+-webkit-transform:scale(-1, 1);
+-ms-transform:scale(-1, 1);
+transform:scale(-1, 1)}.fa-flip-vertical{filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1);
+-webkit-transform:scale(1, -1);
+-ms-transform:scale(1, -1);
+transform:scale(1, -1)}:root .fa-rotate-90,:root .fa-rotate-180,:root .fa-rotate-270,:root .fa-flip-horizontal,:root .fa-flip-vertical{filter:none}.fa-stack{position:relative;
+display:inline-block;
+width:2em;
+height:2em;
+line-height:2em;
+vertical-align:middle}.fa-stack-1x,.fa-stack-2x{position:absolute;
+left:0;
+width:100%;
+text-align:center}
+.fa-stack-1x{line-height:inherit}
+.fa-stack-2x{font-size:2em}
+.fa-inverse{color:#fff}
+.fa-glass:before{content:"\f000"}
+.fa-music:before{content:"\f001"}
+.fa-search:before{content:"\f002"}
+.fa-envelope-o:before{content:"\f003"}
+.fa-heart:before{content:"\f004"}
+.fa-star:before{content:"\f005"}
+.fa-star-o:before{content:"\f006"}
+.fa-user:before{content:"\f007"}
+.fa-film:before{content:"\f008"}
+.fa-th-large:before{content:"\f009"}
+.fa-th:before{content:"\f00a"}
+.fa-th-list:before{content:"\f00b"}
+.fa-check:before{content:"\f00c"}
+.fa-remove:before,.fa-close:before,.fa-times:before{content:"\f00d"}
+.fa-search-plus:before{content:"\f00e"}
+.fa-search-minus:before{content:"\f010"}
+.fa-power-off:before{content:"\f011"}
+.fa-signal:before{content:"\f012"}
+.fa-gear:before,.fa-cog:before{content:"\f013"}
+.fa-trash-o:before{content:"\f014"}
+.fa-home:before{content:"\f015"}
+.fa-file-o:before{content:"\f016"}
+.fa-clock-o:before{content:"\f017"}
+.fa-road:before{content:"\f018"}
+.fa-download:before{content:"\f019"}
+.fa-arrow-circle-o-down:before{content:"\f01a"}
+.fa-arrow-circle-o-up:before{content:"\f01b"}
+.fa-inbox:before{content:"\f01c"}
+.fa-play-circle-o:before{content:"\f01d"}
+.fa-rotate-right:before,.fa-repeat:before{content:"\f01e"}
+.fa-refresh:before{content:"\f021"}
+.fa-list-alt:before{content:"\f022"}
+.fa-lock:before{content:"\f023"}
+.fa-flag:before{content:"\f024"}
+.fa-headphones:before{content:"\f025"}
+.fa-volume-off:before{content:"\f026"}
+.fa-volume-down:before{content:"\f027"}
+.fa-volume-up:before{content:"\f028"}
+.fa-qrcode:before{content:"\f029"}
+.fa-barcode:before{content:"\f02a"}
+.fa-tag:before{content:"\f02b"}
+.fa-tags:before{content:"\f02c"}
+.fa-book:before{content:"\f02d"}
+.fa-bookmark:before{content:"\f02e"}
+.fa-print:before{content:"\f02f"}
+.fa-camera:before{content:"\f030"}
+.fa-font:before{content:"\f031"}
+.fa-bold:before{content:"\f032"}
+.fa-italic:before{content:"\f033"}
+.fa-text-height:before{content:"\f034"}
+.fa-text-width:before{content:"\f035"}
+.fa-align-left:before{content:"\f036"}
+.fa-align-center:before{content:"\f037"}
+.fa-align-right:before{content:"\f038"}
+.fa-align-justify:before{content:"\f039"}
+.fa-list:before{content:"\f03a"}
+.fa-dedent:before,.fa-outdent:before{content:"\f03b"}
+.fa-indent:before{content:"\f03c"}
+.fa-video-camera:before{content:"\f03d"}
+.fa-photo:before,.fa-image:before,.fa-picture-o:before{content:"\f03e"}
+.fa-pencil:before{content:"\f040"}
+.fa-map-marker:before{content:"\f041"}
+.fa-adjust:before{content:"\f042"}
+.fa-tint:before{content:"\f043"}
+.fa-edit:before,.fa-pencil-square-o:before{content:"\f044"}
+.fa-share-square-o:before{content:"\f045"}
+.fa-check-square-o:before{content:"\f046"}
+.fa-arrows:before{content:"\f047"}
+.fa-step-backward:before{content:"\f048"}
+.fa-fast-backward:before{content:"\f049"}
+.fa-backward:before{content:"\f04a"}
+.fa-play:before{content:"\f04b"}
+.fa-pause:before{content:"\f04c"}
+.fa-stop:before{content:"\f04d"}
+.fa-forward:before{content:"\f04e"}
+.fa-fast-forward:before{content:"\f050"}
+.fa-step-forward:before{content:"\f051"}
+.fa-eject:before{content:"\f052"}
+.fa-chevron-left:before{content:"\f053"}
+.fa-chevron-right:before{content:"\f054"}
+.fa-plus-circle:before{content:"\f055"}
+.fa-minus-circle:before{content:"\f056"}
+.fa-times-circle:before{content:"\f057"}
+.fa-check-circle:before{content:"\f058"}
+.fa-question-circle:before{content:"\f059"}
+.fa-info-circle:before{content:"\f05a"}
+.fa-crosshairs:before{content:"\f05b"}
+.fa-times-circle-o:before{content:"\f05c"}
+.fa-check-circle-o:before{content:"\f05d"}
+.fa-ban:before{content:"\f05e"}
+.fa-arrow-left:before{content:"\f060"}
+.fa-arrow-right:before{content:"\f061"}
+.fa-arrow-up:before{content:"\f062"}
+.fa-arrow-down:before{content:"\f063"}
+.fa-mail-forward:before,.fa-share:before{content:"\f064"}
+.fa-expand:before{content:"\f065"}
+.fa-compress:before{content:"\f066"}
+.fa-plus:before{content:"\f067"}
+.fa-minus:before{content:"\f068"}
+.fa-asterisk:before{content:"\f069"}
+.fa-exclamation-circle:before{content:"\f06a"}
+.fa-gift:before{content:"\f06b"}
+.fa-leaf:before{content:"\f06c"}
+.fa-fire:before{content:"\f06d"}
+.fa-eye:before{content:"\f06e"}
+.fa-eye-slash:before{content:"\f070"}
+.fa-warning:before,.fa-exclamation-triangle:before{content:"\f071"}
+.fa-plane:before{content:"\f072"}
+.fa-calendar:before{content:"\f073"}
+.fa-random:before{content:"\f074"}
+.fa-comment:before{content:"\f075"}
+.fa-magnet:before{content:"\f076"}
+.fa-chevron-up:before{content:"\f077"}
+.fa-chevron-down:before{content:"\f078"}
+.fa-retweet:before{content:"\f079"}
+.fa-shopping-cart:before{content:"\f07a"}
+.fa-folder:before{content:"\f07b"}
+.fa-folder-open:before{content:"\f07c"}
+.fa-arrows-v:before{content:"\f07d"}
+.fa-arrows-h:before{content:"\f07e"}
+.fa-bar-chart-o:before,.fa-bar-chart:before{content:"\f080"}
+.fa-twitter-square:before{content:"\f081"}
+.fa-facebook-square:before{content:"\f082"}
+.fa-camera-retro:before{content:"\f083"}
+.fa-key:before{content:"\f084"}
+.fa-gears:before,.fa-cogs:before{content:"\f085"}
+.fa-comments:before{content:"\f086"}
+.fa-thumbs-o-up:before{content:"\f087"}
+.fa-thumbs-o-down:before{content:"\f088"}
+.fa-star-half:before{content:"\f089"}
+.fa-heart-o:before{content:"\f08a"}
+.fa-sign-out:before{content:"\f08b"}
+.fa-linkedin-square:before{content:"\f08c"}
+.fa-thumb-tack:before{content:"\f08d"}
+.fa-external-link:before{content:"\f08e"}
+.fa-sign-in:before{content:"\f090"}
+.fa-trophy:before{content:"\f091"}
+.fa-github-square:before{content:"\f092"}
+.fa-upload:before{content:"\f093"}
+.fa-lemon-o:before{content:"\f094"}
+.fa-phone:before{content:"\f095"}
+.fa-square-o:before{content:"\f096"}
+.fa-bookmark-o:before{content:"\f097"}
+.fa-phone-square:before{content:"\f098"}
+.fa-twitter:before{content:"\f099"}
+.fa-facebook-f:before,.fa-facebook:before{content:"\f09a"}
+.fa-github:before{content:"\f09b"}
+.fa-unlock:before{content:"\f09c"}
+.fa-credit-card:before{content:"\f09d"}
+.fa-rss:before{content:"\f09e"}
+.fa-hdd-o:before{content:"\f0a0"}
+.fa-bullhorn:before{content:"\f0a1"}
+.fa-bell:before{content:"\f0f3"}
+.fa-certificate:before{content:"\f0a3"}
+.fa-hand-o-right:before{content:"\f0a4"}
+.fa-hand-o-left:before{content:"\f0a5"}
+.fa-hand-o-up:before{content:"\f0a6"}
+.fa-hand-o-down:before{content:"\f0a7"}
+.fa-arrow-circle-left:before{content:"\f0a8"}
+.fa-arrow-circle-right:before{content:"\f0a9"}
+.fa-arrow-circle-up:before{content:"\f0aa"}
+.fa-arrow-circle-down:before{content:"\f0ab"}
+.fa-globe:before{content:"\f0ac"}
+.fa-wrench:before{content:"\f0ad"}
+.fa-tasks:before{content:"\f0ae"}
+.fa-filter:before{content:"\f0b0"}
+.fa-briefcase:before{content:"\f0b1"}
+.fa-arrows-alt:before{content:"\f0b2"}
+.fa-group:before,.fa-users:before{content:"\f0c0"}
+.fa-chain:before,.fa-link:before{content:"\f0c1"}
+.fa-cloud:before{content:"\f0c2"}
+.fa-flask:before{content:"\f0c3"}
+.fa-cut:before,.fa-scissors:before{content:"\f0c4"}
+.fa-copy:before,.fa-files-o:before{content:"\f0c5"}
+.fa-paperclip:before{content:"\f0c6"}
+.fa-save:before,.fa-floppy-o:before{content:"\f0c7"}
+.fa-square:before{content:"\f0c8"}
+.fa-navicon:before,.fa-reorder:before,.fa-bars:before{content:"\f0c9"}
+.fa-list-ul:before{content:"\f0ca"}
+.fa-list-ol:before{content:"\f0cb"}
+.fa-strikethrough:before{content:"\f0cc"}
+.fa-underline:before{content:"\f0cd"}
+.fa-table:before{content:"\f0ce"}
+.fa-magic:before{content:"\f0d0"}
+.fa-truck:before{content:"\f0d1"}
+.fa-pinterest:before{content:"\f0d2"}
+.fa-pinterest-square:before{content:"\f0d3"}
+.fa-google-plus-square:before{content:"\f0d4"}
+.fa-google-plus:before{content:"\f0d5"}
+.fa-money:before{content:"\f0d6"}
+.fa-caret-down:before{content:"\f0d7"}
+.fa-caret-up:before{content:"\f0d8"}
+.fa-caret-left:before{content:"\f0d9"}
+.fa-caret-right:before{content:"\f0da"}
+.fa-columns:before{content:"\f0db"}
+.fa-unsorted:before,.fa-sort:before{content:"\f0dc"}
+.fa-sort-down:before,.fa-sort-desc:before{content:"\f0dd"}
+.fa-sort-up:before,.fa-sort-asc:before{content:"\f0de"}
+.fa-envelope:before{content:"\f0e0"}
+.fa-linkedin:before{content:"\f0e1"}
+.fa-rotate-left:before,.fa-undo:before{content:"\f0e2"}
+.fa-legal:before,.fa-gavel:before{content:"\f0e3"}
+.fa-dashboard:before,.fa-tachometer:before{content:"\f0e4"}
+.fa-comment-o:before{content:"\f0e5"}
+.fa-comments-o:before{content:"\f0e6"}
+.fa-flash:before,.fa-bolt:before{content:"\f0e7"}
+.fa-sitemap:before{content:"\f0e8"}
+.fa-umbrella:before{content:"\f0e9"}
+.fa-paste:before,.fa-clipboard:before{content:"\f0ea"}
+.fa-lightbulb-o:before{content:"\f0eb"}
+.fa-exchange:before{content:"\f0ec"}
+.fa-cloud-download:before{content:"\f0ed"}
+.fa-cloud-upload:before{content:"\f0ee"}
+.fa-user-md:before{content:"\f0f0"}
+.fa-stethoscope:before{content:"\f0f1"}
+.fa-suitcase:before{content:"\f0f2"}
+.fa-bell-o:before{content:"\f0a2"}
+.fa-coffee:before{content:"\f0f4"}
+.fa-cutlery:before{content:"\f0f5"}
+.fa-file-text-o:before{content:"\f0f6"}
+.fa-building-o:before{content:"\f0f7"}
+.fa-hospital-o:before{content:"\f0f8"}
+.fa-ambulance:before{content:"\f0f9"}
+.fa-medkit:before{content:"\f0fa"}
+.fa-fighter-jet:before{content:"\f0fb"}
+.fa-beer:before{content:"\f0fc"}
+.fa-h-square:before{content:"\f0fd"}
+.fa-plus-square:before{content:"\f0fe"}
+.fa-angle-double-left:before{content:"\f100"}
+.fa-angle-double-right:before{content:"\f101"}
+.fa-angle-double-up:before{content:"\f102"}
+.fa-angle-double-down:before{content:"\f103"}
+.fa-angle-left:before{content:"\f104"}
+.fa-angle-right:before{content:"\f105"}
+.fa-angle-up:before{content:"\f106"}
+.fa-angle-down:before{content:"\f107"}
+.fa-desktop:before{content:"\f108"}
+.fa-laptop:before{content:"\f109"}
+.fa-tablet:before{content:"\f10a"}
+.fa-mobile-phone:before,.fa-mobile:before{content:"\f10b"}
+.fa-circle-o:before{content:"\f10c"}
+.fa-quote-left:before{content:"\f10d"}
+.fa-quote-right:before{content:"\f10e"}
+.fa-spinner:before{content:"\f110"}
+.fa-circle:before{content:"\f111"}
+.fa-mail-reply:before,.fa-reply:before{content:"\f112"}
+.fa-github-alt:before{content:"\f113"}
+.fa-folder-o:before{content:"\f114"}
+.fa-folder-open-o:before{content:"\f115"}
+.fa-smile-o:before{content:"\f118"}
+.fa-frown-o:before{content:"\f119"}
+.fa-meh-o:before{content:"\f11a"}
+.fa-gamepad:before{content:"\f11b"}
+.fa-keyboard-o:before{content:"\f11c"}
+.fa-flag-o:before{content:"\f11d"}
+.fa-flag-checkered:before{content:"\f11e"}
+.fa-terminal:before{content:"\f120"}
+.fa-code:before{content:"\f121"}
+.fa-mail-reply-all:before,.fa-reply-all:before{content:"\f122"}
+.fa-star-half-empty:before,.fa-star-half-full:before,.fa-star-half-o:before{content:"\f123"}
+.fa-location-arrow:before{content:"\f124"}
+.fa-crop:before{content:"\f125"}
+.fa-code-fork:before{content:"\f126"}
+.fa-unlink:before,.fa-chain-broken:before{content:"\f127"}
+.fa-question:before{content:"\f128"}
+.fa-info:before{content:"\f129"}
+.fa-exclamation:before{content:"\f12a"}
+.fa-superscript:before{content:"\f12b"}
+.fa-subscript:before{content:"\f12c"}
+.fa-eraser:before{content:"\f12d"}
+.fa-puzzle-piece:before{content:"\f12e"}
+.fa-microphone:before{content:"\f130"}
+.fa-microphone-slash:before{content:"\f131"}
+.fa-shield:before{content:"\f132"}
+.fa-calendar-o:before{content:"\f133"}
+.fa-fire-extinguisher:before{content:"\f134"}
+.fa-rocket:before{content:"\f135"}
+.fa-maxcdn:before{content:"\f136"}
+.fa-chevron-circle-left:before{content:"\f137"}
+.fa-chevron-circle-right:before{content:"\f138"}
+.fa-chevron-circle-up:before{content:"\f139"}
+.fa-chevron-circle-down:before{content:"\f13a"}
+.fa-html5:before{content:"\f13b"}
+.fa-css3:before{content:"\f13c"}
+.fa-anchor:before{content:"\f13d"}
+.fa-unlock-alt:before{content:"\f13e"}
+.fa-bullseye:before{content:"\f140"}
+.fa-ellipsis-h:before{content:"\f141"}
+.fa-ellipsis-v:before{content:"\f142"}
+.fa-rss-square:before{content:"\f143"}
+.fa-play-circle:before{content:"\f144"}
+.fa-ticket:before{content:"\f145"}
+.fa-minus-square:before{content:"\f146"}
+.fa-minus-square-o:before{content:"\f147"}
+.fa-level-up:before{content:"\f148"}
+.fa-level-down:before{content:"\f149"}
+.fa-check-square:before{content:"\f14a"}
+.fa-pencil-square:before{content:"\f14b"}
+.fa-external-link-square:before{content:"\f14c"}
+.fa-share-square:before{content:"\f14d"}
+.fa-compass:before{content:"\f14e"}
+.fa-toggle-down:before,.fa-caret-square-o-down:before{content:"\f150"}
+.fa-toggle-up:before,.fa-caret-square-o-up:before{content:"\f151"}
+.fa-toggle-right:before,.fa-caret-square-o-right:before{content:"\f152"}
+.fa-euro:before,.fa-eur:before{content:"\f153"}
+.fa-gbp:before{content:"\f154"}
+.fa-dollar:before,.fa-usd:before{content:"\f155"}
+.fa-rupee:before,.fa-inr:before{content:"\f156"}
+.fa-cny:before,.fa-rmb:before,.fa-yen:before,.fa-jpy:before{content:"\f157"}
+.fa-ruble:before,.fa-rouble:before,.fa-rub:before{content:"\f158"}
+.fa-won:before,.fa-krw:before{content:"\f159"}
+.fa-bitcoin:before,.fa-btc:before{content:"\f15a"}
+.fa-file:before{content:"\f15b"}
+.fa-file-text:before{content:"\f15c"}
+.fa-sort-alpha-asc:before{content:"\f15d"}
+.fa-sort-alpha-desc:before{content:"\f15e"}
+.fa-sort-amount-asc:before{content:"\f160"}
+.fa-sort-amount-desc:before{content:"\f161"}
+.fa-sort-numeric-asc:before{content:"\f162"}
+.fa-sort-numeric-desc:before{content:"\f163"}
+.fa-thumbs-up:before{content:"\f164"}
+.fa-thumbs-down:before{content:"\f165"}
+.fa-youtube-square:before{content:"\f166"}
+.fa-youtube:before{content:"\f167"}
+.fa-xing:before{content:"\f168"}
+.fa-xing-square:before{content:"\f169"}
+.fa-youtube-play:before{content:"\f16a"}
+.fa-dropbox:before{content:"\f16b"}
+.fa-stack-overflow:before{content:"\f16c"}
+.fa-instagram:before{content:"\f16d"}
+.fa-flickr:before{content:"\f16e"}
+.fa-adn:before{content:"\f170"}
+.fa-bitbucket:before{content:"\f171"}
+.fa-bitbucket-square:before{content:"\f172"}
+.fa-tumblr:before{content:"\f173"}
+.fa-tumblr-square:before{content:"\f174"}
+.fa-long-arrow-down:before{content:"\f175"}
+.fa-long-arrow-up:before{content:"\f176"}
+.fa-long-arrow-left:before{content:"\f177"}
+.fa-long-arrow-right:before{content:"\f178"}
+.fa-apple:before{content:"\f179"}
+.fa-windows:before{content:"\f17a"}
+.fa-android:before{content:"\f17b"}
+.fa-linux:before{content:"\f17c"}
+.fa-dribbble:before{content:"\f17d"}
+.fa-skype:before{content:"\f17e"}
+.fa-foursquare:before{content:"\f180"}
+.fa-trello:before{content:"\f181"}
+.fa-female:before{content:"\f182"}
+.fa-male:before{content:"\f183"}
+.fa-gittip:before,.fa-gratipay:before{content:"\f184"}
+.fa-sun-o:before{content:"\f185"}
+.fa-moon-o:before{content:"\f186"}
+.fa-archive:before{content:"\f187"}
+.fa-bug:before{content:"\f188"}
+.fa-vk:before{content:"\f189"}
+.fa-weibo:before{content:"\f18a"}
+.fa-renren:before{content:"\f18b"}
+.fa-pagelines:before{content:"\f18c"}
+.fa-stack-exchange:before{content:"\f18d"}
+.fa-arrow-circle-o-right:before{content:"\f18e"}
+.fa-arrow-circle-o-left:before{content:"\f190"}
+.fa-toggle-left:before,.fa-caret-square-o-left:before{content:"\f191"}
+.fa-dot-circle-o:before{content:"\f192"}
+.fa-wheelchair:before{content:"\f193"}
+.fa-vimeo-square:before{content:"\f194"}
+.fa-turkish-lira:before,.fa-try:before{content:"\f195"}
+.fa-plus-square-o:before{content:"\f196"}
+.fa-space-shuttle:before{content:"\f197"}
+.fa-slack:before{content:"\f198"}
+.fa-envelope-square:before{content:"\f199"}
+.fa-wordpress:before{content:"\f19a"}
+.fa-openid:before{content:"\f19b"}
+.fa-institution:before,.fa-bank:before,.fa-university:before{content:"\f19c"}
+.fa-mortar-board:before,.fa-graduation-cap:before{content:"\f19d"}
+.fa-yahoo:before{content:"\f19e"}
+.fa-google:before{content:"\f1a0"}
+.fa-reddit:before{content:"\f1a1"}
+.fa-reddit-square:before{content:"\f1a2"}
+.fa-stumbleupon-circle:before{content:"\f1a3"}
+.fa-stumbleupon:before{content:"\f1a4"}
+.fa-delicious:before{content:"\f1a5"}
+.fa-digg:before{content:"\f1a6"}
+.fa-pied-piper:before{content:"\f1a7"}
+.fa-pied-piper-alt:before{content:"\f1a8"}
+.fa-drupal:before{content:"\f1a9"}
+.fa-joomla:before{content:"\f1aa"}
+.fa-language:before{content:"\f1ab"}
+.fa-fax:before{content:"\f1ac"}
+.fa-building:before{content:"\f1ad"}
+.fa-child:before{content:"\f1ae"}
+.fa-paw:before{content:"\f1b0"}
+.fa-spoon:before{content:"\f1b1"}
+.fa-cube:before{content:"\f1b2"}
+.fa-cubes:before{content:"\f1b3"}
+.fa-behance:before{content:"\f1b4"}
+.fa-behance-square:before{content:"\f1b5"}
+.fa-steam:before{content:"\f1b6"}
+.fa-steam-square:before{content:"\f1b7"}
+.fa-recycle:before{content:"\f1b8"}
+.fa-automobile:before,.fa-car:before{content:"\f1b9"}
+.fa-cab:before,.fa-taxi:before{content:"\f1ba"}
+.fa-tree:before{content:"\f1bb"}
+.fa-spotify:before{content:"\f1bc"}
+.fa-deviantart:before{content:"\f1bd"}
+.fa-soundcloud:before{content:"\f1be"}
+.fa-database:before{content:"\f1c0"}
+.fa-file-pdf-o:before{content:"\f1c1"}
+.fa-file-word-o:before{content:"\f1c2"}
+.fa-file-excel-o:before{content:"\f1c3"}
+.fa-file-powerpoint-o:before{content:"\f1c4"}
+.fa-file-photo-o:before,.fa-file-picture-o:before,.fa-file-image-o:before{content:"\f1c5"}
+.fa-file-zip-o:before,.fa-file-archive-o:before{content:"\f1c6"}
+.fa-file-sound-o:before,.fa-file-audio-o:before{content:"\f1c7"}
+.fa-file-movie-o:before,.fa-file-video-o:before{content:"\f1c8"}
+.fa-file-code-o:before{content:"\f1c9"}
+.fa-vine:before{content:"\f1ca"}
+.fa-codepen:before{content:"\f1cb"}
+.fa-jsfiddle:before{content:"\f1cc"}
+.fa-life-bouy:before,.fa-life-buoy:before,.fa-life-saver:before,.fa-support:before,.fa-life-ring:before{content:"\f1cd"}
+.fa-circle-o-notch:before{content:"\f1ce"}
+.fa-ra:before,.fa-rebel:before{content:"\f1d0"}
+.fa-ge:before,.fa-empire:before{content:"\f1d1"}
+.fa-git-square:before{content:"\f1d2"}
+.fa-git:before{content:"\f1d3"}
+.fa-hacker-news:before{content:"\f1d4"}
+.fa-tencent-weibo:before{content:"\f1d5"}
+.fa-qq:before{content:"\f1d6"}
+.fa-wechat:before,.fa-weixin:before{content:"\f1d7"}
+.fa-send:before,.fa-paper-plane:before{content:"\f1d8"}
+.fa-send-o:before,.fa-paper-plane-o:before{content:"\f1d9"}
+.fa-history:before{content:"\f1da"}
+.fa-genderless:before,.fa-circle-thin:before{content:"\f1db"}
+.fa-header:before{content:"\f1dc"}
+.fa-paragraph:before{content:"\f1dd"}
+.fa-sliders:before{content:"\f1de"}
+.fa-share-alt:before{content:"\f1e0"}
+.fa-share-alt-square:before{content:"\f1e1"}
+.fa-bomb:before{content:"\f1e2"}
+.fa-soccer-ball-o:before,.fa-futbol-o:before{content:"\f1e3"}
+.fa-tty:before{content:"\f1e4"}
+.fa-binoculars:before{content:"\f1e5"}
+.fa-plug:before{content:"\f1e6"}
+.fa-slideshare:before{content:"\f1e7"}
+.fa-twitch:before{content:"\f1e8"}
+.fa-yelp:before{content:"\f1e9"}
+.fa-newspaper-o:before{content:"\f1ea"}
+.fa-wifi:before{content:"\f1eb"}
+.fa-calculator:before{content:"\f1ec"}
+.fa-paypal:before{content:"\f1ed"}
+.fa-google-wallet:before{content:"\f1ee"}
+.fa-cc-visa:before{content:"\f1f0"}
+.fa-cc-mastercard:before{content:"\f1f1"}
+.fa-cc-discover:before{content:"\f1f2"}
+.fa-cc-amex:before{content:"\f1f3"}
+.fa-cc-paypal:before{content:"\f1f4"}
+.fa-cc-stripe:before{content:"\f1f5"}
+.fa-bell-slash:before{content:"\f1f6"}
+.fa-bell-slash-o:before{content:"\f1f7"}
+.fa-trash:before{content:"\f1f8"}
+.fa-copyright:before{content:"\f1f9"}
+.fa-at:before{content:"\f1fa"}
+.fa-eyedropper:before{content:"\f1fb"}
+.fa-paint-brush:before{content:"\f1fc"}
+.fa-birthday-cake:before{content:"\f1fd"}
+.fa-area-chart:before{content:"\f1fe"}
+.fa-pie-chart:before{content:"\f200"}
+.fa-line-chart:before{content:"\f201"}
+.fa-lastfm:before{content:"\f202"}
+.fa-lastfm-square:before{content:"\f203"}
+.fa-toggle-off:before{content:"\f204"}
+.fa-toggle-on:before{content:"\f205"}
+.fa-bicycle:before{content:"\f206"}
+.fa-bus:before{content:"\f207"}
+.fa-ioxhost:before{content:"\f208"}
+.fa-angellist:before{content:"\f209"}
+.fa-cc:before{content:"\f20a"}
+.fa-shekel:before,.fa-sheqel:before,.fa-ils:before{content:"\f20b"}
+.fa-meanpath:before{content:"\f20c"}
+.fa-buysellads:before{content:"\f20d"}
+.fa-connectdevelop:before{content:"\f20e"}
+.fa-dashcube:before{content:"\f210"}
+.fa-forumbee:before{content:"\f211"}
+.fa-leanpub:before{content:"\f212"}
+.fa-sellsy:before{content:"\f213"}
+.fa-shirtsinbulk:before{content:"\f214"}
+.fa-simplybuilt:before{content:"\f215"}
+.fa-skyatlas:before{content:"\f216"}
+.fa-cart-plus:before{content:"\f217"}
+.fa-cart-arrow-down:before{content:"\f218"}
+.fa-diamond:before{content:"\f219"}
+.fa-ship:before{content:"\f21a"}
+.fa-user-secret:before{content:"\f21b"}
+.fa-motorcycle:before{content:"\f21c"}
+.fa-street-view:before{content:"\f21d"}
+.fa-heartbeat:before{content:"\f21e"}
+.fa-venus:before{content:"\f221"}
+.fa-mars:before{content:"\f222"}
+.fa-mercury:before{content:"\f223"}
+.fa-transgender:before{content:"\f224"}
+.fa-transgender-alt:before{content:"\f225"}
+.fa-venus-double:before{content:"\f226"}
+.fa-mars-double:before{content:"\f227"}
+.fa-venus-mars:before{content:"\f228"}
+.fa-mars-stroke:before{content:"\f229"}
+.fa-mars-stroke-v:before{content:"\f22a"}
+.fa-mars-stroke-h:before{content:"\f22b"}
+.fa-neuter:before{content:"\f22c"}
+.fa-facebook-official:before{content:"\f230"}
+.fa-pinterest-p:before{content:"\f231"}
+.fa-whatsapp:before{content:"\f232"}
+.fa-server:before{content:"\f233"}
+.fa-user-plus:before{content:"\f234"}
+.fa-user-times:before{content:"\f235"}
+.fa-hotel:before,.fa-bed:before{content:"\f236"}
+.fa-viacoin:before{content:"\f237"}
+.fa-train:before{content:"\f238"}
+.fa-subway:before{content:"\f239"}
+.fa-medium:before{content:"\f23a"}
diff --git a/RadioSonde_FSK/version.h b/RadioSonde_FSK/version.h
new file mode 100755
index 0000000..ed5ac02
--- /dev/null
+++ b/RadioSonde_FSK/version.h
@@ -0,0 +1,4 @@
+const char *version_name = "RadioSonde";
+const char *version_id = "0.8.5";
+const int SPIFFS_MAJOR=2;
+const int SPIFFS_MINOR=4;
diff --git a/Setup.md b/Setup.md
new file mode 100755
index 0000000..acc29af
--- /dev/null
+++ b/Setup.md
@@ -0,0 +1,101 @@
+# Près-requis
+<img src="http://xavier.debert.free.fr/RS/TTGO2.jpg" width="50%">
+
+
+## Arduino IDE
+
+Avoir une version à jour exemple 1.8.13(juillet2020)
+
+## ESP32 support
+
+Fichier -> Préférences
+
+en bas dans la case "URL de gestionnaire de cartes supplémentaires"
+
+Ajouter *https://dl.espressif.com/dl/package_esp32_index.json* et appuier sur oK
+
+Puis dans Outils
+Outils -> type de cartes -> Gestionnaire de cartes
+
+dans la case de recherche taper "esp32"
+
+Installer "esp32 by Espressif Systems"
+
+Puis après
+
+## ESP32 Flash Filesystem Upload support
+
+Télécharger le fichier zip de la dernière version 
+https://github.com/me-no-dev/arduino-esp32fs-plugin/releases/
+
+Décompresser l'archive dans le répértoire tools de votre Arduino IDE
+
+## Ajouter les bibliothèques
+
+Séléctionner Outils -> Gestionnaire de bibliothèques
+
+Installer "U8g2"
+
+Installer "MicroNMEA"
+
+Installer "TFT_22_ILI9225" nécessaire pas pour l'écran car j'ai tout supprimé 
+mais pour les fonts, car le TTGO fonctionne avec OLED SSD1306 par défaut!
+
+
+## Ajouter les bibliothèques, parties 2
+
+Depuis https://github.com/me-no-dev/ESPAsyncWebServer télécharger le ZIP , l'extraire dans "libraries"
+, renommer le répertoire en  ESPAsyncWebServer (supprimer juste "-master")
+
+Depuis https://github.com/me-no-dev/AsyncTCP télécharger le ZIP, l'extraire dans "libraries", et renommer le répertoire en AsyncTCP
+
+de même pour https://github.com/lewisxhe/AXP202X_Library télécharger le ZIP, l'extraire dans "libraries", et renommer le répertoire en AXP202X_Library
+
+
+## Ajouter les bibliothèques, parties 3
+
+Copier libraries/SX1278FSK 
+et libraries/SondeLib 
+et libraries/fonts 
+
+fourni dans libraries
+
+
+```
+ou sous Linux un lien symbolique est aussi possible mais pas obligatoire!
+cd ~/Arduino/libraries
+ln -s <whereyouclonedthegit>/radiosonde/libraries/SondeLib/ .
+ln -s <whereyouclonedthegit>/radiosonde/libraries/SX1278FSK/ .
+```
+Redémarrer Arduino IDE
+
+## Ajout carte esp32
+
+Allez dans Outils-> type de cartes -> gestionnaire de cartes
+
+puis dans la case taper esp32 et Installer.
+
+## Dernière parties
+
+Dans Outils -> Esp32 arduino: ->
+Séléctionner "TTGO LoRa32-OLED v1"
+
+Puis il vous faut ouvrir le fichier
+RadioSonde_FSK.ino
+
+Compiler et Téléverser le dans votre TTGO 
+
+puis il faut téléverser maintenant les DATA!
+
+Dans Outils
+cliquer sur ESP32 Sketch Data Upload
+
+voila le TTGO est prêt!
+
+Pour les futur mise à jour,
+j'ai prévue une mise à jour directe via OTA depuis le TTGO donc
+s'il est connecté à internet depuis votre Smartphone ou votre Box.
+Cela se fera depuis le menu de la page Web.
+73
+Xavier
+
diff --git a/ant_cju.jpg b/ant_cju.jpg
new file mode 100755
index 0000000..251a9ad
Binary files /dev/null and b/ant_cju.jpg differ
diff --git a/libraries/SD/.travis.yml b/libraries/SD/.travis.yml
new file mode 100755
index 0000000..ad3f202
--- /dev/null
+++ b/libraries/SD/.travis.yml
@@ -0,0 +1,89 @@
+# default language
+language: generic
+
+env:
+  global:
+    - CLI_VERSION=latest
+
+matrix:
+  include:
+    # compile example sketches for the following boards
+    - env:
+        - BOARD='arduino:avr:mega:cpu=atmega2560'
+      install:
+        - arduino-cli core install arduino:avr
+
+    - env:
+        - BOARD='arduino:samd:mkrzero'
+      install:
+        - arduino-cli core install arduino:samd
+
+    - env:
+        - BOARD='arduino:megaavr:uno2018:mode=on'
+      install:
+        - arduino-cli core install arduino:megaavr
+
+    - env:
+        - BOARD='arduino:sam:arduino_due_x'
+      install:
+        - arduino-cli core install arduino:sam
+
+    # check all code files for compliance with the Arduino code formatting style
+    - env:
+        - NAME='Code Formatting Check'
+      language: minimal
+      before_install:
+        # install Artistic Style code formatter tool: http://astyle.sourceforge.net
+        - |
+          mkdir "${HOME}/astyle";
+          wget --no-verbose --output-document="${HOME}/astyle/astyle.tar.gz" "https://iweb.dl.sourceforge.net/project/astyle/astyle/astyle%203.1/astyle_3.1_linux.tar.gz";
+          tar --extract --file="${HOME}/astyle/astyle.tar.gz" --directory="${HOME}/astyle";
+          cd "${HOME}/astyle/astyle/build/gcc";
+          make;
+          export PATH="$PWD/bin:$PATH";
+          cd "$TRAVIS_BUILD_DIR"
+        # download Arduino's Artistic Style configuration file
+        - wget --directory-prefix="${HOME}/astyle" https://raw.githubusercontent.com/arduino/Arduino/master/build/shared/examples_formatter.conf
+      script:
+        # check code formatting
+        - find . -regextype posix-extended -path './.git' -prune -or \( -iregex '.*\.((ino)|(h)|(hpp)|(hh)|(hxx)|(h\+\+)|(cpp)|(cc)|(cxx)|(c\+\+)|(cp)|(c)|(ipp)|(ii)|(ixx)|(inl)|(tpp)|(txx)|(tpl))$' -and -type f \) -print0 | xargs -0 -L1 bash -c 'if ! diff "$0" <(astyle --options=${HOME}/astyle/examples_formatter.conf --dry-run < "$0"); then echo "Non-compliant code formatting in $0"; false; fi'
+
+    # check all files for commonly misspelled words
+    - env:
+        - NAME='Spell Check'
+      language: python
+      python: 3.6
+      before_install:
+        # https://github.com/codespell-project/codespell
+        - pip install codespell
+      script:
+        # codespell will ignore any words in extras/codespell-ignore-words-list.txt, which may be used to fix false positives
+        - codespell --skip="${TRAVIS_BUILD_DIR}/.git" --ignore-words="${TRAVIS_BUILD_DIR}/extras/codespell-ignore-words-list.txt" "${TRAVIS_BUILD_DIR}"
+
+# default phases shared by the compilation tests
+before_install:
+  - wget http://downloads.arduino.cc/arduino-cli/arduino-cli-$CLI_VERSION-linux64.tar.bz2
+  - tar xf arduino-cli-$CLI_VERSION-linux64.tar.bz2
+  - mkdir -p "$HOME/bin"
+  - mv arduino-cli "$HOME/bin"
+  - export PATH="$PATH:$HOME/bin"
+  - arduino-cli core update-index
+  - buildExampleSketch() { arduino-cli compile --verbose --warnings all --fqbn $BOARD "$PWD/examples/$1"; }
+  - mkdir -p "$HOME/Arduino/libraries"
+  - ln -s "$PWD" "$HOME/Arduino/libraries/."
+
+script:
+  - buildExampleSketch CardInfo
+  - buildExampleSketch Datalogger
+  - buildExampleSketch DumpFile
+  - buildExampleSketch Files
+  - buildExampleSketch listfiles
+  - buildExampleSketch ReadWrite
+
+notifications:
+  webhooks:
+    # use TravisBuddy to comment on any pull request that results in a failed CI build
+    urls:
+      - https://www.travisbuddy.com/
+    on_success: never
+    on_failure: always
diff --git a/libraries/SD/README.adoc b/libraries/SD/README.adoc
new file mode 100755
index 0000000..fb3ed03
--- /dev/null
+++ b/libraries/SD/README.adoc
@@ -0,0 +1,26 @@
+= SD Library for Arduino =
+
+image:https://travis-ci.org/arduino-libraries/SD.svg?branch=master[Build Status, link=https://travis-ci.org/arduino-libraries/SD]
+
+The SD library allows for reading from and writing to SD cards.
+
+For more information about this library please visit us at
+http://www.arduino.cc/en/Reference/SD
+
+== License ==
+
+ Copyright (C) 2009 by William Greiman
+Copyright (c) 2010 SparkFun Electronics
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
diff --git a/libraries/SD/examples/CardInfo/CardInfo.ino b/libraries/SD/examples/CardInfo/CardInfo.ino
new file mode 100755
index 0000000..97913ef
--- /dev/null
+++ b/libraries/SD/examples/CardInfo/CardInfo.ino
@@ -0,0 +1,116 @@
+/*
+  SD card test
+
+  This example shows how use the utility libraries on which the'
+  SD library is based in order to get info about your SD card.
+  Very useful for testing a card when you're not sure whether its working or not.
+
+  The circuit:
+    SD card attached to SPI bus as follows:
+ ** MOSI - pin 11 on Arduino Uno/Duemilanove/Diecimila
+ ** MISO - pin 12 on Arduino Uno/Duemilanove/Diecimila
+ ** CLK - pin 13 on Arduino Uno/Duemilanove/Diecimila
+ ** CS - depends on your SD card shield or module.
+ 		Pin 4 used here for consistency with other Arduino examples
+
+
+  created  28 Mar 2011
+  by Limor Fried
+  modified 9 Apr 2012
+  by Tom Igoe
+*/
+// include the SD library:
+#include <SPI.h>
+#include <SD.h>
+
+// set up variables using the SD utility library functions:
+Sd2Card card;
+SdVolume volume;
+SdFile root;
+
+// change this to match your SD shield or module;
+// Arduino Ethernet shield: pin 4
+// Adafruit SD shields and modules: pin 10
+// Sparkfun SD shield: pin 8
+// MKRZero SD: SDCARD_SS_PIN
+const int chipSelect = 4;
+
+void setup() {
+  // Open serial communications and wait for port to open:
+  Serial.begin(9600);
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for native USB port only
+  }
+
+
+  Serial.print("\nInitializing SD card...");
+
+  // we'll use the initialization code from the utility libraries
+  // since we're just testing if the card is working!
+  if (!card.init(SPI_HALF_SPEED, chipSelect)) {
+    Serial.println("initialization failed. Things to check:");
+    Serial.println("* is a card inserted?");
+    Serial.println("* is your wiring correct?");
+    Serial.println("* did you change the chipSelect pin to match your shield or module?");
+    while (1);
+  } else {
+    Serial.println("Wiring is correct and a card is present.");
+  }
+
+  // print the type of card
+  Serial.println();
+  Serial.print("Card type:         ");
+  switch (card.type()) {
+    case SD_CARD_TYPE_SD1:
+      Serial.println("SD1");
+      break;
+    case SD_CARD_TYPE_SD2:
+      Serial.println("SD2");
+      break;
+    case SD_CARD_TYPE_SDHC:
+      Serial.println("SDHC");
+      break;
+    default:
+      Serial.println("Unknown");
+  }
+
+  // Now we will try to open the 'volume'/'partition' - it should be FAT16 or FAT32
+  if (!volume.init(card)) {
+    Serial.println("Could not find FAT16/FAT32 partition.\nMake sure you've formatted the card");
+    while (1);
+  }
+
+  Serial.print("Clusters:          ");
+  Serial.println(volume.clusterCount());
+  Serial.print("Blocks x Cluster:  ");
+  Serial.println(volume.blocksPerCluster());
+
+  Serial.print("Total Blocks:      ");
+  Serial.println(volume.blocksPerCluster() * volume.clusterCount());
+  Serial.println();
+
+  // print the type and size of the first FAT-type volume
+  uint32_t volumesize;
+  Serial.print("Volume type is:    FAT");
+  Serial.println(volume.fatType(), DEC);
+
+  volumesize = volume.blocksPerCluster();    // clusters are collections of blocks
+  volumesize *= volume.clusterCount();       // we'll have a lot of clusters
+  volumesize /= 2;                           // SD card blocks are always 512 bytes (2 blocks are 1KB)
+  Serial.print("Volume size (Kb):  ");
+  Serial.println(volumesize);
+  Serial.print("Volume size (Mb):  ");
+  volumesize /= 1024;
+  Serial.println(volumesize);
+  Serial.print("Volume size (Gb):  ");
+  Serial.println((float)volumesize / 1024.0);
+
+  Serial.println("\nFiles found on the card (name, date and size in bytes): ");
+  root.openRoot(volume);
+
+  // list all files in the card with date and size
+  root.ls(LS_R | LS_DATE | LS_SIZE);
+}
+
+void loop(void) {
+}
diff --git a/libraries/SD/examples/Datalogger/Datalogger.ino b/libraries/SD/examples/Datalogger/Datalogger.ino
new file mode 100755
index 0000000..c2631c0
--- /dev/null
+++ b/libraries/SD/examples/Datalogger/Datalogger.ino
@@ -0,0 +1,84 @@
+/*
+  SD card datalogger
+
+  This example shows how to log data from three analog sensors
+  to an SD card using the SD library.
+
+  The circuit:
+   analog sensors on analog ins 0, 1, and 2
+   SD card attached to SPI bus as follows:
+ ** MOSI - pin 11
+ ** MISO - pin 12
+ ** CLK - pin 13
+ ** CS - pin 4 (for MKRZero SD: SDCARD_SS_PIN)
+
+  created  24 Nov 2010
+  modified 9 Apr 2012
+  by Tom Igoe
+
+  This example code is in the public domain.
+
+*/
+
+#include <SPI.h>
+#include <SD.h>
+
+const int chipSelect = 4;
+
+void setup() {
+  // Open serial communications and wait for port to open:
+  Serial.begin(9600);
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for native USB port only
+  }
+
+
+  Serial.print("Initializing SD card...");
+
+  // see if the card is present and can be initialized:
+  if (!SD.begin(chipSelect)) {
+    Serial.println("Card failed, or not present");
+    // don't do anything more:
+    while (1);
+  }
+  Serial.println("card initialized.");
+}
+
+void loop() {
+  // make a string for assembling the data to log:
+  String dataString = "";
+
+  // read three sensors and append to the string:
+  for (int analogPin = 0; analogPin < 3; analogPin++) {
+    int sensor = analogRead(analogPin);
+    dataString += String(sensor);
+    if (analogPin < 2) {
+      dataString += ",";
+    }
+  }
+
+  // open the file. note that only one file can be open at a time,
+  // so you have to close this one before opening another.
+  File dataFile = SD.open("datalog.txt", FILE_WRITE);
+
+  // if the file is available, write to it:
+  if (dataFile) {
+    dataFile.println(dataString);
+    dataFile.close();
+    // print to the serial port too:
+    Serial.println(dataString);
+  }
+  // if the file isn't open, pop up an error:
+  else {
+    Serial.println("error opening datalog.txt");
+  }
+}
+
+
+
+
+
+
+
+
+
diff --git a/libraries/SD/examples/DumpFile/DumpFile.ino b/libraries/SD/examples/DumpFile/DumpFile.ino
new file mode 100755
index 0000000..7491999
--- /dev/null
+++ b/libraries/SD/examples/DumpFile/DumpFile.ino
@@ -0,0 +1,65 @@
+/*
+  SD card file dump
+
+  This example shows how to read a file from the SD card using the
+  SD library and send it over the serial port.
+
+  The circuit:
+   SD card attached to SPI bus as follows:
+ ** MOSI - pin 11
+ ** MISO - pin 12
+ ** CLK - pin 13
+ ** CS - pin 4 (for MKRZero SD: SDCARD_SS_PIN)
+
+  created  22 December 2010
+  by Limor Fried
+  modified 9 Apr 2012
+  by Tom Igoe
+
+  This example code is in the public domain.
+
+*/
+
+#include <SPI.h>
+#include <SD.h>
+
+const int chipSelect = 4;
+
+void setup() {
+  // Open serial communications and wait for port to open:
+  Serial.begin(9600);
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for native USB port only
+  }
+
+
+  Serial.print("Initializing SD card...");
+
+  // see if the card is present and can be initialized:
+  if (!SD.begin(chipSelect)) {
+    Serial.println("Card failed, or not present");
+    // don't do anything more:
+    while (1);
+  }
+  Serial.println("card initialized.");
+
+  // open the file. note that only one file can be open at a time,
+  // so you have to close this one before opening another.
+  File dataFile = SD.open("datalog.txt");
+
+  // if the file is available, write to it:
+  if (dataFile) {
+    while (dataFile.available()) {
+      Serial.write(dataFile.read());
+    }
+    dataFile.close();
+  }
+  // if the file isn't open, pop up an error:
+  else {
+    Serial.println("error opening datalog.txt");
+  }
+}
+
+void loop() {
+}
+
diff --git a/libraries/SD/examples/Files/Files.ino b/libraries/SD/examples/Files/Files.ino
new file mode 100755
index 0000000..cabebba
--- /dev/null
+++ b/libraries/SD/examples/Files/Files.ino
@@ -0,0 +1,75 @@
+/*
+  SD card basic file example
+
+  This example shows how to create and destroy an SD card file
+  The circuit:
+   SD card attached to SPI bus as follows:
+ ** MOSI - pin 11
+ ** MISO - pin 12
+ ** CLK - pin 13
+ ** CS - pin 4 (for MKRZero SD: SDCARD_SS_PIN)
+
+  created   Nov 2010
+  by David A. Mellis
+  modified 9 Apr 2012
+  by Tom Igoe
+
+  This example code is in the public domain.
+
+*/
+#include <SPI.h>
+#include <SD.h>
+
+File myFile;
+
+void setup() {
+  // Open serial communications and wait for port to open:
+  Serial.begin(9600);
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for native USB port only
+  }
+
+
+  Serial.print("Initializing SD card...");
+
+  if (!SD.begin(4)) {
+    Serial.println("initialization failed!");
+    while (1);
+  }
+  Serial.println("initialization done.");
+
+  if (SD.exists("example.txt")) {
+    Serial.println("example.txt exists.");
+  } else {
+    Serial.println("example.txt doesn't exist.");
+  }
+
+  // open a new file and immediately close it:
+  Serial.println("Creating example.txt...");
+  myFile = SD.open("example.txt", FILE_WRITE);
+  myFile.close();
+
+  // Check to see if the file exists:
+  if (SD.exists("example.txt")) {
+    Serial.println("example.txt exists.");
+  } else {
+    Serial.println("example.txt doesn't exist.");
+  }
+
+  // delete the file:
+  Serial.println("Removing example.txt...");
+  SD.remove("example.txt");
+
+  if (SD.exists("example.txt")) {
+    Serial.println("example.txt exists.");
+  } else {
+    Serial.println("example.txt doesn't exist.");
+  }
+}
+
+void loop() {
+  // nothing happens after setup finishes.
+}
+
+
+
diff --git a/libraries/SD/examples/NonBlockingWrite/NonBlockingWrite.ino b/libraries/SD/examples/NonBlockingWrite/NonBlockingWrite.ino
new file mode 100755
index 0000000..29d8ec6
--- /dev/null
+++ b/libraries/SD/examples/NonBlockingWrite/NonBlockingWrite.ino
@@ -0,0 +1,91 @@
+/*
+  Non-blocking Write
+
+  This example demonstrates how to perform non-blocking writes
+  to a file on a SD card. The file will contain the current millis()
+  value every 10ms. If the SD card is busy, the data will be buffered
+  in order to not block the sketch.
+
+  NOTE: myFile.availableForWrite() will automatically sync the
+        file contents as needed. You may lose some unsynced data
+        still if myFile.sync() or myFile.close() is not called.
+
+  The circuit:
+  - Arduino MKR Zero board
+  - micro SD card attached
+
+  This example code is in the public domain.
+*/
+
+#include <SD.h>
+
+// file name to use for writing
+const char filename[] = "demo.txt";
+
+// File object to represent file
+File txtFile;
+
+// string to buffer output
+String buffer;
+
+unsigned long lastMillis = 0;
+
+void setup() {
+  Serial.begin(9600);
+  while (!Serial);
+
+  // reserve 1kB for String used as a buffer
+  buffer.reserve(1024);
+
+  // set LED pin to output, used to blink when writing
+  pinMode(LED_BUILTIN, OUTPUT);
+
+  // init the SD card
+  if (!SD.begin()) {
+    Serial.println("Card failed, or not present");
+    // don't do anything more:
+    while (1);
+  }
+
+  // If you want to start from an empty file,
+  // uncomment the next line:
+  // SD.remove(filename);
+
+  // try to open the file for writing
+  txtFile = SD.open(filename, FILE_WRITE);
+  if (!txtFile) {
+    Serial.print("error opening ");
+    Serial.println(filename);
+    while (1);
+  }
+
+  // add some new lines to start
+  txtFile.println();
+  txtFile.println("Hello World!");
+}
+
+void loop() {
+  // check if it's been over 10 ms since the last line added
+  unsigned long now = millis();
+  if ((now - lastMillis) >= 10) {
+    // add a new line to the buffer
+    buffer += "Hello ";
+    buffer += now;
+    buffer += "\r\n";
+
+    lastMillis = now;
+  }
+
+  // check if the SD card is available to write data without blocking
+  // and if the buffered data is enough for the full chunk size
+  unsigned int chunkSize = txtFile.availableForWrite();
+  if (chunkSize && buffer.length() >= chunkSize) {
+    // write to file and blink LED
+    digitalWrite(LED_BUILTIN, HIGH);
+    txtFile.write(buffer.c_str(), chunkSize);
+    digitalWrite(LED_BUILTIN, LOW);
+
+    // remove written data from buffer
+    buffer.remove(0, chunkSize);
+  }
+}
diff --git a/libraries/SD/examples/ReadWrite/ReadWrite.ino b/libraries/SD/examples/ReadWrite/ReadWrite.ino
new file mode 100755
index 0000000..d964668
--- /dev/null
+++ b/libraries/SD/examples/ReadWrite/ReadWrite.ino
@@ -0,0 +1,79 @@
+/*
+  SD card read/write
+
+  This example shows how to read and write data to and from an SD card file
+  The circuit:
+   SD card attached to SPI bus as follows:
+ ** MOSI - pin 11
+ ** MISO - pin 12
+ ** CLK - pin 13
+ ** CS - pin 4 (for MKRZero SD: SDCARD_SS_PIN)
+
+  created   Nov 2010
+  by David A. Mellis
+  modified 9 Apr 2012
+  by Tom Igoe
+
+  This example code is in the public domain.
+
+*/
+
+#include <SPI.h>
+#include <SD.h>
+
+File myFile;
+
+void setup() {
+  // Open serial communications and wait for port to open:
+  Serial.begin(9600);
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for native USB port only
+  }
+
+
+  Serial.print("Initializing SD card...");
+
+  if (!SD.begin(4)) {
+    Serial.println("initialization failed!");
+    while (1);
+  }
+  Serial.println("initialization done.");
+
+  // open the file. note that only one file can be open at a time,
+  // so you have to close this one before opening another.
+  myFile = SD.open("test.txt", FILE_WRITE);
+
+  // if the file opened okay, write to it:
+  if (myFile) {
+    Serial.print("Writing to test.txt...");
+    myFile.println("testing 1, 2, 3.");
+    // close the file:
+    myFile.close();
+    Serial.println("done.");
+  } else {
+    // if the file didn't open, print an error:
+    Serial.println("error opening test.txt");
+  }
+
+  // re-open the file for reading:
+  myFile = SD.open("test.txt");
+  if (myFile) {
+    Serial.println("test.txt:");
+
+    // read from the file until there's nothing else in it:
+    while (myFile.available()) {
+      Serial.write(myFile.read());
+    }
+    // close the file:
+    myFile.close();
+  } else {
+    // if the file didn't open, print an error:
+    Serial.println("error opening test.txt");
+  }
+}
+
+void loop() {
+  // nothing happens after setup
+}
+
+
diff --git a/libraries/SD/examples/listfiles/listfiles.ino b/libraries/SD/examples/listfiles/listfiles.ino
new file mode 100755
index 0000000..48f84fb
--- /dev/null
+++ b/libraries/SD/examples/listfiles/listfiles.ino
@@ -0,0 +1,80 @@
+/*
+  Listfiles
+
+  This example shows how print out the files in a
+  directory on a SD card
+
+  The circuit:
+   SD card attached to SPI bus as follows:
+ ** MOSI - pin 11
+ ** MISO - pin 12
+ ** CLK - pin 13
+ ** CS - pin 4 (for MKRZero SD: SDCARD_SS_PIN)
+
+  created   Nov 2010
+  by David A. Mellis
+  modified 9 Apr 2012
+  by Tom Igoe
+  modified 2 Feb 2014
+  by Scott Fitzgerald
+
+  This example code is in the public domain.
+
+*/
+#include <SPI.h>
+#include <SD.h>
+
+File root;
+
+void setup() {
+  // Open serial communications and wait for port to open:
+  Serial.begin(9600);
+  while (!Serial) {
+    ; // wait for serial port to connect. Needed for native USB port only
+  }
+
+  Serial.print("Initializing SD card...");
+
+  if (!SD.begin(4)) {
+    Serial.println("initialization failed!");
+    while (1);
+  }
+  Serial.println("initialization done.");
+
+  root = SD.open("/");
+
+  printDirectory(root, 0);
+
+  Serial.println("done!");
+}
+
+void loop() {
+  // nothing happens after setup finishes.
+}
+
+void printDirectory(File dir, int numTabs) {
+  while (true) {
+
+    File entry =  dir.openNextFile();
+    if (! entry) {
+      // no more files
+      break;
+    }
+    for (uint8_t i = 0; i < numTabs; i++) {
+      Serial.print('\t');
+    }
+    Serial.print(entry.name());
+    if (entry.isDirectory()) {
+      Serial.println("/");
+      printDirectory(entry, numTabs + 1);
+    } else {
+      // files have sizes, directories do not
+      Serial.print("\t\t");
+      Serial.println(entry.size(), DEC);
+    }
+    entry.close();
+  }
+}
+
+
+
diff --git a/libraries/SD/extras/codespell-ignore-words-list.txt b/libraries/SD/extras/codespell-ignore-words-list.txt
new file mode 100755
index 0000000..e69de29
diff --git a/libraries/SD/keywords.txt b/libraries/SD/keywords.txt
new file mode 100755
index 0000000..91e74b8
--- /dev/null
+++ b/libraries/SD/keywords.txt
@@ -0,0 +1,31 @@
+#######################################
+# Syntax Coloring Map SD
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+SD	KEYWORD1	SD
+File	KEYWORD1	SD
+SDFile	KEYWORD1	SD
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+begin	KEYWORD2
+exists	KEYWORD2
+mkdir	KEYWORD2
+remove	KEYWORD2
+rmdir	KEYWORD2
+open	KEYWORD2
+close	KEYWORD2
+seek	KEYWORD2
+position	KEYWORD2
+size	KEYWORD2	
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+FILE_READ	LITERAL1
+FILE_WRITE	LITERAL1
diff --git a/libraries/SD/library.properties b/libraries/SD/library.properties
new file mode 100755
index 0000000..60e8859
--- /dev/null
+++ b/libraries/SD/library.properties
@@ -0,0 +1,9 @@
+name=SD
+version=1.2.4
+author=Arduino, SparkFun
+maintainer=Arduino <info@arduino.cc>
+sentence=Enables reading and writing on SD cards. 
+paragraph=Once an SD memory card is connected to the SPI interface of the Arduino or Genuino board you can 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=*
diff --git a/libraries/SD/src/File.cpp b/libraries/SD/src/File.cpp
new file mode 100755
index 0000000..5e37166
--- /dev/null
+++ b/libraries/SD/src/File.cpp
@@ -0,0 +1,168 @@
+/*
+
+  SD - a slightly more friendly wrapper for sdfatlib
+
+  This library aims to expose a subset of SD card functionality
+  in the form of a higher level "wrapper" object.
+
+  License: GNU General Public License V3
+          (Because sdfatlib is licensed with this.)
+
+  (C) Copyright 2010 SparkFun Electronics
+
+*/
+
+#include <SD.h>
+
+/* for debugging file open/close leaks
+   uint8_t nfilecount=0;
+*/
+
+File::File(SdFile f, const char *n) {
+  // oh man you are kidding me, new() doesn't exist? Ok we do it by hand!
+  _file = (SdFile *)malloc(sizeof(SdFile));
+  if (_file) {
+    memcpy(_file, &f, sizeof(SdFile));
+
+    strncpy(_name, n, 12);
+    _name[12] = 0;
+
+    /* for debugging file open/close leaks
+       nfilecount++;
+       Serial.print("Created \"");
+       Serial.print(n);
+       Serial.print("\": ");
+       Serial.println(nfilecount, DEC);
+    */
+  }
+}
+
+File::File(void) {
+  _file = 0;
+  _name[0] = 0;
+  //Serial.print("Created empty file object");
+}
+
+// returns a pointer to the file name
+char *File::name(void) {
+  return _name;
+}
+
+// a directory is a special type of file
+boolean File::isDirectory(void) {
+  return (_file && _file->isDir());
+}
+
+
+size_t File::write(uint8_t val) {
+  return write(&val, 1);
+}
+
+size_t File::write(const uint8_t *buf, size_t size) {
+  size_t t;
+  if (!_file) {
+    setWriteError();
+    return 0;
+  }
+  _file->clearWriteError();
+  t = _file->write(buf, size);
+  if (_file->getWriteError()) {
+    setWriteError();
+    return 0;
+  }
+  return t;
+}
+
+int File::availableForWrite() {
+  if (_file) {
+    return _file->availableForWrite();
+  }
+  return 0;
+}
+
+int File::peek() {
+  if (! _file) {
+    return 0;
+  }
+
+  int c = _file->read();
+  if (c != -1) {
+    _file->seekCur(-1);
+  }
+  return c;
+}
+
+int File::read() {
+  if (_file) {
+    return _file->read();
+  }
+  return -1;
+}
+
+// buffered read for more efficient, high speed reading
+int File::read(void *buf, uint16_t nbyte) {
+  if (_file) {
+    return _file->read(buf, nbyte);
+  }
+  return 0;
+}
+
+int File::available() {
+  if (! _file) {
+    return 0;
+  }
+
+  uint32_t n = size() - position();
+
+  return n > 0X7FFF ? 0X7FFF : n;
+}
+
+void File::flush() {
+  if (_file) {
+    _file->sync();
+  }
+}
+
+boolean File::seek(uint32_t pos) {
+  if (! _file) {
+    return false;
+  }
+
+  return _file->seekSet(pos);
+}
+
+uint32_t File::position() {
+  if (! _file) {
+    return -1;
+  }
+  return _file->curPosition();
+}
+
+uint32_t File::size() {
+  if (! _file) {
+    return 0;
+  }
+  return _file->fileSize();
+}
+
+void File::close() {
+  if (_file) {
+    _file->close();
+    free(_file);
+    _file = 0;
+
+    /* for debugging file open/close leaks
+      nfilecount--;
+      Serial.print("Deleted ");
+      Serial.println(nfilecount, DEC);
+    */
+  }
+}
+
+File::operator bool() {
+  if (_file) {
+    return  _file->isOpen();
+  }
+  return false;
+}
+
diff --git a/libraries/SD/src/README.txt b/libraries/SD/src/README.txt
new file mode 100755
index 0000000..495ea4c
--- /dev/null
+++ b/libraries/SD/src/README.txt
@@ -0,0 +1,13 @@
+
+** SD - a slightly more friendly wrapper for sdfatlib **
+
+This library aims to expose a subset of SD card functionality in the
+form of a higher level "wrapper" object.
+
+License: GNU General Public License V3
+         (Because sdfatlib is licensed with this.)
+
+(C) Copyright 2010 SparkFun Electronics
+
+Now better than ever with optimization, multiple file support, directory handling, etc - ladyada!
+
diff --git a/libraries/SD/src/SD.cpp b/libraries/SD/src/SD.cpp
new file mode 100755
index 0000000..8c9a29e
--- /dev/null
+++ b/libraries/SD/src/SD.cpp
@@ -0,0 +1,637 @@
+/*
+
+  SD - a slightly more friendly wrapper for sdfatlib
+
+  This library aims to expose a subset of SD card functionality
+  in the form of a higher level "wrapper" object.
+
+  License: GNU General Public License V3
+          (Because sdfatlib is licensed with this.)
+
+  (C) Copyright 2010 SparkFun Electronics
+
+
+  This library provides four key benefits:
+
+     Including `SD.h` automatically creates a global
+     `SD` object which can be interacted with in a similar
+     manner to other standard global objects like `Serial` and `Ethernet`.
+
+     Boilerplate initialisation code is contained in one method named
+     `begin` and no further objects need to be created in order to access
+     the SD card.
+
+     Calls to `open` can supply a full path name including parent
+     directories which simplifies interacting with files in subdirectories.
+
+     Utility methods are provided to determine whether a file exists
+     and to create a directory hierarchy.
+
+
+  Note however that not all functionality provided by the underlying
+  sdfatlib library is exposed.
+
+*/
+
+/*
+
+  Implementation Notes
+
+  In order to handle multi-directory path traversal, functionality that
+  requires this ability is implemented as callback functions.
+
+  Individual methods call the `walkPath` function which performs the actual
+  directory traversal (swapping between two different directory/file handles
+  along the way) and at each level calls the supplied callback function.
+
+  Some types of functionality will take an action at each level (e.g. exists
+  or make directory) which others will only take an action at the bottom
+  level (e.g. open).
+
+*/
+
+#include "SD.h"
+
+namespace SDLib {
+
+  // Used by `getNextPathComponent`
+#define MAX_COMPONENT_LEN 12 // What is max length?
+#define PATH_COMPONENT_BUFFER_LEN MAX_COMPONENT_LEN+1
+
+  bool getNextPathComponent(const char *path, unsigned int *p_offset,
+                            char *buffer) {
+    /*
+
+      Parse individual path components from a path.
+
+        e.g. after repeated calls '/foo/bar/baz' will be split
+             into 'foo', 'bar', 'baz'.
+
+      This is similar to `strtok()` but copies the component into the
+      supplied buffer rather than modifying the original string.
+
+
+      `buffer` needs to be PATH_COMPONENT_BUFFER_LEN in size.
+
+      `p_offset` needs to point to an integer of the offset at
+      which the previous path component finished.
+
+      Returns `true` if more components remain.
+
+      Returns `false` if this is the last component.
+        (This means path ended with 'foo' or 'foo/'.)
+
+    */
+
+    // TODO: Have buffer local to this function, so we know it's the
+    //       correct length?
+
+    int bufferOffset = 0;
+
+    int offset = *p_offset;
+
+    // Skip root or other separator
+    if (path[offset] == '/') {
+      offset++;
+    }
+
+    // Copy the next next path segment
+    while (bufferOffset < MAX_COMPONENT_LEN
+           && (path[offset] != '/')
+           && (path[offset] != '\0')) {
+      buffer[bufferOffset++] = path[offset++];
+    }
+
+    buffer[bufferOffset] = '\0';
+
+    // Skip trailing separator so we can determine if this
+    // is the last component in the path or not.
+    if (path[offset] == '/') {
+      offset++;
+    }
+
+    *p_offset = offset;
+
+    return (path[offset] != '\0');
+  }
+
+
+
+  boolean walkPath(const char *filepath, SdFile& parentDir,
+                   boolean(*callback)(SdFile& parentDir,
+                                      const char *filePathComponent,
+                                      boolean isLastComponent,
+                                      void *object),
+                   void *object = NULL) {
+    /*
+
+       When given a file path (and parent directory--normally root),
+       this function traverses the directories in the path and at each
+       level calls the supplied callback function while also providing
+       the supplied object for context if required.
+
+         e.g. given the path '/foo/bar/baz'
+              the callback would be called at the equivalent of
+        '/foo', '/foo/bar' and '/foo/bar/baz'.
+
+       The implementation swaps between two different directory/file
+       handles as it traverses the directories and does not use recursion
+       in an attempt to use memory efficiently.
+
+       If a callback wishes to stop the directory traversal it should
+       return false--in this case the function will stop the traversal,
+       tidy up and return false.
+
+       If a directory path doesn't exist at some point this function will
+       also return false and not subsequently call the callback.
+
+       If a directory path specified is complete, valid and the callback
+       did not indicate the traversal should be interrupted then this
+       function will return true.
+
+    */
+
+
+    SdFile subfile1;
+    SdFile subfile2;
+
+    char buffer[PATH_COMPONENT_BUFFER_LEN];
+
+    unsigned int offset = 0;
+
+    SdFile *p_parent;
+    SdFile *p_child;
+
+    SdFile *p_tmp_sdfile;
+
+    p_child = &subfile1;
+
+    p_parent = &parentDir;
+
+    while (true) {
+
+      boolean moreComponents = getNextPathComponent(filepath, &offset, buffer);
+
+      boolean shouldContinue = callback((*p_parent), buffer, !moreComponents, object);
+
+      if (!shouldContinue) {
+        // TODO: Don't repeat this code?
+        // If it's one we've created then we
+        // don't need the parent handle anymore.
+        if (p_parent != &parentDir) {
+          (*p_parent).close();
+        }
+        return false;
+      }
+
+      if (!moreComponents) {
+        break;
+      }
+
+      boolean exists = (*p_child).open(*p_parent, buffer, O_RDONLY);
+
+      // If it's one we've created then we
+      // don't need the parent handle anymore.
+      if (p_parent != &parentDir) {
+        (*p_parent).close();
+      }
+
+      // Handle case when it doesn't exist and we can't continue...
+      if (exists) {
+        // We alternate between two file handles as we go down
+        // the path.
+        if (p_parent == &parentDir) {
+          p_parent = &subfile2;
+        }
+
+        p_tmp_sdfile = p_parent;
+        p_parent = p_child;
+        p_child = p_tmp_sdfile;
+      } else {
+        return false;
+      }
+    }
+
+    if (p_parent != &parentDir) {
+      (*p_parent).close(); // TODO: Return/ handle different?
+    }
+
+    return true;
+  }
+
+
+
+  /*
+
+     The callbacks used to implement various functionality follow.
+
+     Each callback is supplied with a parent directory handle,
+     character string with the name of the current file path component,
+     a flag indicating if this component is the last in the path and
+     a pointer to an arbitrary object used for context.
+
+  */
+
+  boolean callback_pathExists(SdFile& parentDir, const char *filePathComponent,
+                              boolean /* isLastComponent */, void * /* object */) {
+    /*
+
+      Callback used to determine if a file/directory exists in parent
+      directory.
+
+      Returns true if file path exists.
+
+    */
+    SdFile child;
+
+    boolean exists = child.open(parentDir, filePathComponent, O_RDONLY);
+
+    if (exists) {
+      child.close();
+    }
+
+    return exists;
+  }
+
+
+
+  boolean callback_makeDirPath(SdFile& parentDir, const char *filePathComponent,
+                               boolean isLastComponent, void *object) {
+    /*
+
+      Callback used to create a directory in the parent directory if
+      it does not already exist.
+
+      Returns true if a directory was created or it already existed.
+
+    */
+    boolean result = false;
+    SdFile child;
+
+    result = callback_pathExists(parentDir, filePathComponent, isLastComponent, object);
+    if (!result) {
+      result = child.makeDir(parentDir, filePathComponent);
+    }
+
+    return result;
+  }
+
+
+  /*
+
+    boolean callback_openPath(SdFile& parentDir, char *filePathComponent,
+  		  boolean isLastComponent, void *object) {
+
+    Callback used to open a file specified by a filepath that may
+    specify one or more directories above it.
+
+    Expects the context object to be an instance of `SDClass` and
+    will use the `file` property of the instance to open the requested
+    file/directory with the associated file open mode property.
+
+    Always returns true if the directory traversal hasn't reached the
+    bottom of the directory hierarchy.
+
+    Returns false once the file has been opened--to prevent the traversal
+    from descending further. (This may be unnecessary.)
+
+    if (isLastComponent) {
+    SDClass *p_SD = static_cast<SDClass*>(object);
+    p_SD->file.open(parentDir, filePathComponent, p_SD->fileOpenMode);
+    if (p_SD->fileOpenMode == FILE_WRITE) {
+      p_SD->file.seekSet(p_SD->file.fileSize());
+    }
+    // TODO: Return file open result?
+    return false;
+    }
+    return true;
+    }
+  */
+
+
+
+  boolean callback_remove(SdFile& parentDir, const char *filePathComponent,
+                          boolean isLastComponent, void * /* object */) {
+    if (isLastComponent) {
+      return SdFile::remove(parentDir, filePathComponent);
+    }
+    return true;
+  }
+
+  boolean callback_rmdir(SdFile& parentDir, const char *filePathComponent,
+                         boolean isLastComponent, void * /* object */) {
+    if (isLastComponent) {
+      SdFile f;
+      if (!f.open(parentDir, filePathComponent, O_READ)) {
+        return false;
+      }
+      return f.rmDir();
+    }
+    return true;
+  }
+
+
+
+  /* Implementation of class used to create `SDCard` object. */
+
+
+
+  boolean SDClass::begin(uint8_t csPin) {
+    if (root.isOpen()) {
+      root.close();
+    }
+
+    /*
+
+      Performs the initialisation required by the sdfatlib library.
+
+      Return true if initialization succeeds, false otherwise.
+
+    */
+    return card.init(SPI_HALF_SPEED, csPin) &&
+           volume.init(card) &&
+           root.openRoot(volume);
+  }
+
+  boolean SDClass::begin(uint32_t clock, uint8_t csPin) {
+    if (root.isOpen()) {
+      root.close();
+    }
+
+    return card.init(SPI_HALF_SPEED, csPin) &&
+           card.setSpiClock(clock) &&
+           volume.init(card) &&
+           root.openRoot(volume);
+  }
+
+  //call this when a card is removed. It will allow you to insert and initialise a new card.
+  void SDClass::end() {
+    root.close();
+  }
+
+  // this little helper is used to traverse paths
+  SdFile SDClass::getParentDir(const char *filepath, int *index) {
+    // get parent directory
+    SdFile d1;
+    SdFile d2;
+
+    d1.openRoot(volume); // start with the mostparent, root!
+
+    // we'll use the pointers to swap between the two objects
+    SdFile *parent = &d1;
+    SdFile *subdir = &d2;
+
+    const char *origpath = filepath;
+
+    while (strchr(filepath, '/')) {
+
+      // get rid of leading /'s
+      if (filepath[0] == '/') {
+        filepath++;
+        continue;
+      }
+
+      if (! strchr(filepath, '/')) {
+        // it was in the root directory, so leave now
+        break;
+      }
+
+      // extract just the name of the next subdirectory
+      uint8_t idx = strchr(filepath, '/') - filepath;
+      if (idx > 12) {
+        idx = 12;  // don't let them specify long names
+      }
+      char subdirname[13];
+      strncpy(subdirname, filepath, idx);
+      subdirname[idx] = 0;
+
+      // close the subdir (we reuse them) if open
+      subdir->close();
+      if (! subdir->open(parent, subdirname, O_READ)) {
+        // failed to open one of the subdirectories
+        return SdFile();
+      }
+      // move forward to the next subdirectory
+      filepath += idx;
+
+      // we reuse the objects, close it.
+      parent->close();
+
+      // swap the pointers
+      SdFile *t = parent;
+      parent = subdir;
+      subdir = t;
+    }
+
+    *index = (int)(filepath - origpath);
+    // parent is now the parent directory of the file!
+    return *parent;
+  }
+
+
+  File SDClass::open(const char *filepath, uint8_t mode) {
+    /*
+
+       Open the supplied file path for reading or writing.
+
+       The file content can be accessed via the `file` property of
+       the `SDClass` object--this property is currently
+       a standard `SdFile` object from `sdfatlib`.
+
+       Defaults to read only.
+
+       If `write` is true, default action (when `append` is true) is to
+       append data to the end of the file.
+
+       If `append` is false then the file will be truncated first.
+
+       If the file does not exist and it is opened for writing the file
+       will be created.
+
+       An attempt to open a file for reading that does not exist is an
+       error.
+
+    */
+
+    int pathidx;
+
+    // do the interactive search
+    SdFile parentdir = getParentDir(filepath, &pathidx);
+    // no more subdirs!
+
+    filepath += pathidx;
+
+    if (! filepath[0]) {
+      // it was the directory itself!
+      return File(parentdir, "/");
+    }
+
+    // Open the file itself
+    SdFile file;
+
+    // failed to open a subdir!
+    if (!parentdir.isOpen()) {
+      return File();
+    }
+
+    if (! file.open(parentdir, filepath, mode)) {
+      return File();
+    }
+    // close the parent
+    parentdir.close();
+
+    if ((mode & (O_APPEND | O_WRITE)) == (O_APPEND | O_WRITE)) {
+      file.seekSet(file.fileSize());
+    }
+    return File(file, filepath);
+  }
+
+
+  /*
+    File SDClass::open(char *filepath, uint8_t mode) {
+    //
+
+       Open the supplied file path for reading or writing.
+
+       The file content can be accessed via the `file` property of
+       the `SDClass` object--this property is currently
+       a standard `SdFile` object from `sdfatlib`.
+
+       Defaults to read only.
+
+       If `write` is true, default action (when `append` is true) is to
+       append data to the end of the file.
+
+       If `append` is false then the file will be truncated first.
+
+       If the file does not exist and it is opened for writing the file
+       will be created.
+
+       An attempt to open a file for reading that does not exist is an
+       error.
+
+     //
+
+    // TODO: Allow for read&write? (Possibly not, as it requires seek.)
+
+    fileOpenMode = mode;
+    walkPath(filepath, root, callback_openPath, this);
+
+    return File();
+
+    }
+  */
+
+
+  //boolean SDClass::close() {
+  //  /*
+  //
+  //    Closes the file opened by the `open` method.
+  //
+  //   */
+  //  file.close();
+  //}
+
+
+  boolean SDClass::exists(const char *filepath) {
+    /*
+
+       Returns true if the supplied file path exists.
+
+    */
+    return walkPath(filepath, root, callback_pathExists);
+  }
+
+
+  //boolean SDClass::exists(char *filepath, SdFile& parentDir) {
+  //  /*
+  //
+  //     Returns true if the supplied file path rooted at `parentDir`
+  //     exists.
+  //
+  //   */
+  //  return walkPath(filepath, parentDir, callback_pathExists);
+  //}
+
+
+  boolean SDClass::mkdir(const char *filepath) {
+    /*
+
+      Makes a single directory or a hierarchy of directories.
+
+      A rough equivalent to `mkdir -p`.
+
+    */
+    return walkPath(filepath, root, callback_makeDirPath);
+  }
+
+  boolean SDClass::rmdir(const char *filepath) {
+    /*
+
+      Remove a single directory or a hierarchy of directories.
+
+      A rough equivalent to `rm -rf`.
+
+    */
+    return walkPath(filepath, root, callback_rmdir);
+  }
+
+  boolean SDClass::remove(const char *filepath) {
+    return walkPath(filepath, root, callback_remove);
+  }
+
+
+  // allows you to recurse into a directory
+  File File::openNextFile(uint8_t mode) {
+    dir_t p;
+
+    //Serial.print("\t\treading dir...");
+    while (_file->readDir(&p) > 0) {
+
+      // done if past last used entry
+      if (p.name[0] == DIR_NAME_FREE) {
+        //Serial.println("end");
+        return File();
+      }
+
+      // skip deleted entry and entries for . and  ..
+      if (p.name[0] == DIR_NAME_DELETED || p.name[0] == '.') {
+        //Serial.println("dots");
+        continue;
+      }
+
+      // only list subdirectories and files
+      if (!DIR_IS_FILE_OR_SUBDIR(&p)) {
+        //Serial.println("notafile");
+        continue;
+      }
+
+      // print file name with possible blank fill
+      SdFile f;
+      char name[13];
+      _file->dirName(p, name);
+      //Serial.print("try to open file ");
+      //Serial.println(name);
+
+      if (f.open(_file, name, mode)) {
+        //Serial.println("OK!");
+        return File(f, name);
+      } else {
+        //Serial.println("ugh");
+        return File();
+      }
+    }
+
+    //Serial.println("nothing");
+    return File();
+  }
+
+  void File::rewindDirectory(void) {
+    if (isDirectory()) {
+      _file->rewind();
+    }
+  }
+
+  SDClass SD;
+
+};
diff --git a/libraries/SD/src/SD.h b/libraries/SD/src/SD.h
new file mode 100755
index 0000000..fa34ccd
--- /dev/null
+++ b/libraries/SD/src/SD.h
@@ -0,0 +1,138 @@
+/*
+
+  SD - a slightly more friendly wrapper for sdfatlib
+
+  This library aims to expose a subset of SD card functionality
+  in the form of a higher level "wrapper" object.
+
+  License: GNU General Public License V3
+          (Because sdfatlib is licensed with this.)
+
+  (C) Copyright 2010 SparkFun Electronics
+
+*/
+
+#ifndef __SD_H__
+#define __SD_H__
+
+#include <Arduino.h>
+
+#include "utility/SdFat.h"
+#include "utility/SdFatUtil.h"
+
+#define FILE_READ O_READ
+#define FILE_WRITE (O_READ | O_WRITE | O_CREAT | O_APPEND)
+
+namespace SDLib {
+
+  class File : public Stream {
+    private:
+      char _name[13]; // our name
+      SdFile *_file;  // underlying file pointer
+
+    public:
+      File(SdFile f, const char *name);     // wraps an underlying SdFile
+      File(void);      // 'empty' constructor
+      virtual size_t write(uint8_t);
+      virtual size_t write(const uint8_t *buf, size_t size);
+      virtual int availableForWrite();
+      virtual int read();
+      virtual int peek();
+      virtual int available();
+      virtual void flush();
+      int read(void *buf, uint16_t nbyte);
+      boolean seek(uint32_t pos);
+      uint32_t position();
+      uint32_t size();
+      void close();
+      operator bool();
+      char * name();
+
+      boolean isDirectory(void);
+      File openNextFile(uint8_t mode = O_RDONLY);
+      void rewindDirectory(void);
+
+      using Print::write;
+  };
+
+  class SDClass {
+
+    private:
+      // These are required for initialisation and use of sdfatlib
+      Sd2Card card;
+      SdVolume volume;
+      SdFile root;
+
+      // my quick&dirty iterator, should be replaced
+      SdFile getParentDir(const char *filepath, int *indx);
+    public:
+      // This needs to be called to set up the connection to the SD card
+      // before other methods are used.
+      boolean begin(uint8_t csPin = SD_CHIP_SELECT_PIN);
+      boolean begin(uint32_t clock, uint8_t csPin);
+
+      //call this when a card is removed. It will allow you to insert and initialise a new card.
+      void end();
+
+      // Open the specified file/directory with the supplied mode (e.g. read or
+      // write, etc). Returns a File object for interacting with the file.
+      // Note that currently only one file can be open at a time.
+      File open(const char *filename, uint8_t mode = FILE_READ);
+      File open(const String &filename, uint8_t mode = FILE_READ) {
+        return open(filename.c_str(), mode);
+      }
+
+      // Methods to determine if the requested file path exists.
+      boolean exists(const char *filepath);
+      boolean exists(const String &filepath) {
+        return exists(filepath.c_str());
+      }
+
+      // Create the requested directory heirarchy--if intermediate directories
+      // do not exist they will be created.
+      boolean mkdir(const char *filepath);
+      boolean mkdir(const String &filepath) {
+        return mkdir(filepath.c_str());
+      }
+
+      // Delete the file.
+      boolean remove(const char *filepath);
+      boolean remove(const String &filepath) {
+        return remove(filepath.c_str());
+      }
+
+      boolean rmdir(const char *filepath);
+      boolean rmdir(const String &filepath) {
+        return rmdir(filepath.c_str());
+      }
+
+    private:
+
+      // This is used to determine the mode used to open a file
+      // it's here because it's the easiest place to pass the
+      // information through the directory walking function. But
+      // it's probably not the best place for it.
+      // It shouldn't be set directly--it is set via the parameters to `open`.
+      int fileOpenMode;
+
+      friend class File;
+      friend boolean callback_openPath(SdFile&, const char *, boolean, void *);
+  };
+
+  extern SDClass SD;
+
+};
+
+// We enclose File and SD classes in namespace SDLib to avoid conflicts
+// with others legacy libraries that redefines File class.
+
+// This ensure compatibility with sketches that uses only SD library
+using namespace SDLib;
+
+// This allows sketches to use SDLib::File with other libraries (in the
+// sketch you must use SDFile instead of File to disambiguate)
+typedef SDLib::File    SDFile;
+typedef SDLib::SDClass SDFileSystemClass;
+#define SDFileSystem   SDLib::SD
+
+#endif
diff --git a/libraries/SD/src/utility/FatStructs.h b/libraries/SD/src/utility/FatStructs.h
new file mode 100755
index 0000000..84c1cc7
--- /dev/null
+++ b/libraries/SD/src/utility/FatStructs.h
@@ -0,0 +1,418 @@
+/* Arduino SdFat Library
+   Copyright (C) 2009 by William Greiman
+
+   This file is part of the Arduino SdFat Library
+
+   This Library is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with the Arduino SdFat Library.  If not, see
+   <http://www.gnu.org/licenses/>.
+*/
+#ifndef FatStructs_h
+#define FatStructs_h
+/**
+   \file
+   FAT file structures
+*/
+/*
+   mostly from Microsoft document fatgen103.doc
+   http://www.microsoft.com/whdc/system/platform/firmware/fatgen.mspx
+*/
+//------------------------------------------------------------------------------
+/** Value for byte 510 of boot block or MBR */
+uint8_t const BOOTSIG0 = 0X55;
+/** Value for byte 511 of boot block or MBR */
+uint8_t const BOOTSIG1 = 0XAA;
+//------------------------------------------------------------------------------
+/**
+   \struct partitionTable
+   \brief MBR partition table entry
+
+   A partition table entry for a MBR formatted storage device.
+   The MBR partition table has four entries.
+*/
+struct partitionTable {
+  /**
+     Boot Indicator . Indicates whether the volume is the active
+     partition.  Legal values include: 0X00. Do not use for booting.
+     0X80 Active partition.
+  */
+  uint8_t  boot;
+  /**
+      Head part of Cylinder-head-sector address of the first block in
+      the partition. Legal values are 0-255. Only used in old PC BIOS.
+  */
+  uint8_t  beginHead;
+  /**
+     Sector part of Cylinder-head-sector address of the first block in
+     the partition. Legal values are 1-63. Only used in old PC BIOS.
+  */
+  unsigned beginSector : 6;
+  /** High bits cylinder for first block in partition. */
+  unsigned beginCylinderHigh : 2;
+  /**
+     Combine beginCylinderLow with beginCylinderHigh. Legal values
+     are 0-1023.  Only used in old PC BIOS.
+  */
+  uint8_t  beginCylinderLow;
+  /**
+     Partition type. See defines that begin with PART_TYPE_ for
+     some Microsoft partition types.
+  */
+  uint8_t  type;
+  /**
+     head part of cylinder-head-sector address of the last sector in the
+     partition.  Legal values are 0-255. Only used in old PC BIOS.
+  */
+  uint8_t  endHead;
+  /**
+     Sector part of cylinder-head-sector address of the last sector in
+     the partition.  Legal values are 1-63. Only used in old PC BIOS.
+  */
+  unsigned endSector : 6;
+  /** High bits of end cylinder */
+  unsigned endCylinderHigh : 2;
+  /**
+     Combine endCylinderLow with endCylinderHigh. Legal values
+     are 0-1023.  Only used in old PC BIOS.
+  */
+  uint8_t  endCylinderLow;
+  /** Logical block address of the first block in the partition. */
+  uint32_t firstSector;
+  /** Length of the partition, in blocks. */
+  uint32_t totalSectors;
+} __attribute__((packed));
+/** Type name for partitionTable */
+typedef struct partitionTable part_t;
+//------------------------------------------------------------------------------
+/**
+   \struct masterBootRecord
+
+   \brief Master Boot Record
+
+   The first block of a storage device that is formatted with a MBR.
+*/
+struct masterBootRecord {
+  /** Code Area for master boot program. */
+  uint8_t  codeArea[440];
+  /** Optional WindowsNT disk signature. May contain more boot code. */
+  uint32_t diskSignature;
+  /** Usually zero but may be more boot code. */
+  uint16_t usuallyZero;
+  /** Partition tables. */
+  part_t   part[4];
+  /** First MBR signature byte. Must be 0X55 */
+  uint8_t  mbrSig0;
+  /** Second MBR signature byte. Must be 0XAA */
+  uint8_t  mbrSig1;
+} __attribute__((packed));
+/** Type name for masterBootRecord */
+typedef struct masterBootRecord mbr_t;
+//------------------------------------------------------------------------------
+/**
+   \struct biosParmBlock
+
+   \brief BIOS parameter block
+
+    The BIOS parameter block describes the physical layout of a FAT volume.
+*/
+struct biosParmBlock {
+  /**
+     Count of bytes per sector. This value may take on only the
+     following values: 512, 1024, 2048 or 4096
+  */
+  uint16_t bytesPerSector;
+  /**
+     Number of sectors per allocation unit. This value must be a
+     power of 2 that is greater than 0. The legal values are
+     1, 2, 4, 8, 16, 32, 64, and 128.
+  */
+  uint8_t  sectorsPerCluster;
+  /**
+     Number of sectors before the first FAT.
+     This value must not be zero.
+  */
+  uint16_t reservedSectorCount;
+  /** The count of FAT data structures on the volume. This field should
+      always contain the value 2 for any FAT volume of any type.
+  */
+  uint8_t  fatCount;
+  /**
+    For FAT12 and FAT16 volumes, this field contains the count of
+    32-byte directory entries in the root directory. For FAT32 volumes,
+    this field must be set to 0. For FAT12 and FAT16 volumes, this
+    value should always specify a count that when multiplied by 32
+    results in a multiple of bytesPerSector.  FAT16 volumes should
+    use the value 512.
+  */
+  uint16_t rootDirEntryCount;
+  /**
+     This field is the old 16-bit total count of sectors on the volume.
+     This count includes the count of all sectors in all four regions
+     of the volume. This field can be 0; if it is 0, then totalSectors32
+     must be non-zero.  For FAT32 volumes, this field must be 0. For
+     FAT12 and FAT16 volumes, this field contains the sector count, and
+     totalSectors32 is 0 if the total sector count fits
+     (is less than 0x10000).
+  */
+  uint16_t totalSectors16;
+  /**
+     This dates back to the old MS-DOS 1.x media determination and is
+     no longer usually used for anything.  0xF8 is the standard value
+     for fixed (non-removable) media. For removable media, 0xF0 is
+     frequently used. Legal values are 0xF0 or 0xF8-0xFF.
+  */
+  uint8_t  mediaType;
+  /**
+     Count of sectors occupied by one FAT on FAT12/FAT16 volumes.
+     On FAT32 volumes this field must be 0, and sectorsPerFat32
+     contains the FAT size count.
+  */
+  uint16_t sectorsPerFat16;
+  /** Sectors per track for interrupt 0x13. Not used otherwise. */
+  uint16_t sectorsPerTrtack;
+  /** Number of heads for interrupt 0x13.  Not used otherwise. */
+  uint16_t headCount;
+  /**
+     Count of hidden sectors preceding the partition that contains this
+     FAT volume. This field is generally only relevant for media
+      visible on interrupt 0x13.
+  */
+  uint32_t hidddenSectors;
+  /**
+     This field is the new 32-bit total count of sectors on the volume.
+     This count includes the count of all sectors in all four regions
+     of the volume.  This field can be 0; if it is 0, then
+     totalSectors16 must be non-zero.
+  */
+  uint32_t totalSectors32;
+  /**
+     Count of sectors occupied by one FAT on FAT32 volumes.
+  */
+  uint32_t sectorsPerFat32;
+  /**
+     This field is only defined for FAT32 media and does not exist on
+     FAT12 and FAT16 media.
+     Bits 0-3 -- Zero-based number of active FAT.
+                 Only valid if mirroring is disabled.
+     Bits 4-6 -- Reserved.
+     Bit 7	-- 0 means the FAT is mirrored at runtime into all FATs.
+            -- 1 means only one FAT is active; it is the one referenced in bits 0-3.
+     Bits 8-15 	-- Reserved.
+  */
+  uint16_t fat32Flags;
+  /**
+     FAT32 version. High byte is major revision number.
+     Low byte is minor revision number. Only 0.0 define.
+  */
+  uint16_t fat32Version;
+  /**
+     Cluster number of the first cluster of the root directory for FAT32.
+     This usually 2 but not required to be 2.
+  */
+  uint32_t fat32RootCluster;
+  /**
+     Sector number of FSINFO structure in the reserved area of the
+     FAT32 volume. Usually 1.
+  */
+  uint16_t fat32FSInfo;
+  /**
+     If non-zero, indicates the sector number in the reserved area
+     of the volume of a copy of the boot record. Usually 6.
+     No value other than 6 is recommended.
+  */
+  uint16_t fat32BackBootBlock;
+  /**
+     Reserved for future expansion. Code that formats FAT32 volumes
+     should always set all of the bytes of this field to 0.
+  */
+  uint8_t  fat32Reserved[12];
+} __attribute__((packed));
+/** Type name for biosParmBlock */
+typedef struct biosParmBlock bpb_t;
+//------------------------------------------------------------------------------
+/**
+   \struct fat32BootSector
+
+   \brief Boot sector for a FAT16 or FAT32 volume.
+
+*/
+struct fat32BootSector {
+  /** X86 jmp to boot program */
+  uint8_t  jmpToBootCode[3];
+  /** informational only - don't depend on it */
+  char     oemName[8];
+  /** BIOS Parameter Block */
+  bpb_t    bpb;
+  /** for int0x13 use value 0X80 for hard drive */
+  uint8_t  driveNumber;
+  /** used by Windows NT - should be zero for FAT */
+  uint8_t  reserved1;
+  /** 0X29 if next three fields are valid */
+  uint8_t  bootSignature;
+  /** usually generated by combining date and time */
+  uint32_t volumeSerialNumber;
+  /** should match volume label in root dir */
+  char     volumeLabel[11];
+  /** informational only - don't depend on it */
+  char     fileSystemType[8];
+  /** X86 boot code */
+  uint8_t  bootCode[420];
+  /** must be 0X55 */
+  uint8_t  bootSectorSig0;
+  /** must be 0XAA */
+  uint8_t  bootSectorSig1;
+} __attribute__((packed));
+//------------------------------------------------------------------------------
+// End Of Chain values for FAT entries
+/** FAT16 end of chain value used by Microsoft. */
+uint16_t const FAT16EOC = 0XFFFF;
+/** Minimum value for FAT16 EOC.  Use to test for EOC. */
+uint16_t const FAT16EOC_MIN = 0XFFF8;
+/** FAT32 end of chain value used by Microsoft. */
+uint32_t const FAT32EOC = 0X0FFFFFFF;
+/** Minimum value for FAT32 EOC.  Use to test for EOC. */
+uint32_t const FAT32EOC_MIN = 0X0FFFFFF8;
+/** Mask a for FAT32 entry. Entries are 28 bits. */
+uint32_t const FAT32MASK = 0X0FFFFFFF;
+
+/** Type name for fat32BootSector */
+typedef struct fat32BootSector fbs_t;
+//------------------------------------------------------------------------------
+/**
+   \struct directoryEntry
+   \brief FAT short directory entry
+
+   Short means short 8.3 name, not the entry size.
+
+   Date Format. A FAT directory entry date stamp is a 16-bit field that is
+   basically a date relative to the MS-DOS epoch of 01/01/1980. Here is the
+   format (bit 0 is the LSB of the 16-bit word, bit 15 is the MSB of the
+   16-bit word):
+
+   Bits 9-15: Count of years from 1980, valid value range 0-127
+   inclusive (1980-2107).
+
+   Bits 5-8: Month of year, 1 = January, valid value range 1-12 inclusive.
+
+   Bits 0-4: Day of month, valid value range 1-31 inclusive.
+
+   Time Format. A FAT directory entry time stamp is a 16-bit field that has
+   a granularity of 2 seconds. Here is the format (bit 0 is the LSB of the
+   16-bit word, bit 15 is the MSB of the 16-bit word).
+
+   Bits 11-15: Hours, valid value range 0-23 inclusive.
+
+   Bits 5-10: Minutes, valid value range 0-59 inclusive.
+
+   Bits 0-4: 2-second count, valid value range 0-29 inclusive (0 - 58 seconds).
+
+   The valid time range is from Midnight 00:00:00 to 23:59:58.
+*/
+struct directoryEntry {
+  /**
+     Short 8.3 name.
+     The first eight bytes contain the file name with blank fill.
+     The last three bytes contain the file extension with blank fill.
+  */
+  uint8_t  name[11];
+  /** Entry attributes.
+
+     The upper two bits of the attribute byte are reserved and should
+     always be set to 0 when a file is created and never modified or
+     looked at after that.  See defines that begin with DIR_ATT_.
+  */
+  uint8_t  attributes;
+  /**
+     Reserved for use by Windows NT. Set value to 0 when a file is
+     created and never modify or look at it after that.
+  */
+  uint8_t  reservedNT;
+  /**
+     The granularity of the seconds part of creationTime is 2 seconds
+     so this field is a count of tenths of a second and its valid
+     value range is 0-199 inclusive. (WHG note - seems to be hundredths)
+  */
+  uint8_t  creationTimeTenths;
+  /** Time file was created. */
+  uint16_t creationTime;
+  /** Date file was created. */
+  uint16_t creationDate;
+  /**
+     Last access date. Note that there is no last access time, only
+     a date.  This is the date of last read or write. In the case of
+     a write, this should be set to the same date as lastWriteDate.
+  */
+  uint16_t lastAccessDate;
+  /**
+     High word of this entry's first cluster number (always 0 for a
+     FAT12 or FAT16 volume).
+  */
+  uint16_t firstClusterHigh;
+  /** Time of last write. File creation is considered a write. */
+  uint16_t lastWriteTime;
+  /** Date of last write. File creation is considered a write. */
+  uint16_t lastWriteDate;
+  /** Low word of this entry's first cluster number. */
+  uint16_t firstClusterLow;
+  /** 32-bit unsigned holding this file's size in bytes. */
+  uint32_t fileSize;
+} __attribute__((packed));
+//------------------------------------------------------------------------------
+// Definitions for directory entries
+//
+/** Type name for directoryEntry */
+typedef struct directoryEntry dir_t;
+/** escape for name[0] = 0XE5 */
+uint8_t const DIR_NAME_0XE5 = 0X05;
+/** name[0] value for entry that is free after being "deleted" */
+uint8_t const DIR_NAME_DELETED = 0XE5;
+/** name[0] value for entry that is free and no allocated entries follow */
+uint8_t const DIR_NAME_FREE = 0X00;
+/** file is read-only */
+uint8_t const DIR_ATT_READ_ONLY = 0X01;
+/** File should hidden in directory listings */
+uint8_t const DIR_ATT_HIDDEN = 0X02;
+/** Entry is for a system file */
+uint8_t const DIR_ATT_SYSTEM = 0X04;
+/** Directory entry contains the volume label */
+uint8_t const DIR_ATT_VOLUME_ID = 0X08;
+/** Entry is for a directory */
+uint8_t const DIR_ATT_DIRECTORY = 0X10;
+/** Old DOS archive bit for backup support */
+uint8_t const DIR_ATT_ARCHIVE = 0X20;
+/** Test value for long name entry.  Test is
+  (d->attributes & DIR_ATT_LONG_NAME_MASK) == DIR_ATT_LONG_NAME. */
+uint8_t const DIR_ATT_LONG_NAME = 0X0F;
+/** Test mask for long name entry */
+uint8_t const DIR_ATT_LONG_NAME_MASK = 0X3F;
+/** defined attribute bits */
+uint8_t const DIR_ATT_DEFINED_BITS = 0X3F;
+/** Directory entry is part of a long name */
+static inline uint8_t DIR_IS_LONG_NAME(const dir_t* dir) {
+  return (dir->attributes & DIR_ATT_LONG_NAME_MASK) == DIR_ATT_LONG_NAME;
+}
+/** Mask for file/subdirectory tests */
+uint8_t const DIR_ATT_FILE_TYPE_MASK = (DIR_ATT_VOLUME_ID | DIR_ATT_DIRECTORY);
+/** Directory entry is for a file */
+static inline uint8_t DIR_IS_FILE(const dir_t* dir) {
+  return (dir->attributes & DIR_ATT_FILE_TYPE_MASK) == 0;
+}
+/** Directory entry is for a subdirectory */
+static inline uint8_t DIR_IS_SUBDIR(const dir_t* dir) {
+  return (dir->attributes & DIR_ATT_FILE_TYPE_MASK) == DIR_ATT_DIRECTORY;
+}
+/** Directory entry is for a file or subdirectory */
+static inline uint8_t DIR_IS_FILE_OR_SUBDIR(const dir_t* dir) {
+  return (dir->attributes & DIR_ATT_VOLUME_ID) == 0;
+}
+#endif  // FatStructs_h
diff --git a/libraries/SD/src/utility/Sd2Card.cpp b/libraries/SD/src/utility/Sd2Card.cpp
new file mode 100755
index 0000000..7cfbe73
--- /dev/null
+++ b/libraries/SD/src/utility/Sd2Card.cpp
@@ -0,0 +1,777 @@
+/* Arduino Sd2Card Library
+   Copyright (C) 2009 by William Greiman
+
+   This file is part of the Arduino Sd2Card Library
+
+   This Library is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with the Arduino Sd2Card Library.  If not, see
+   <http://www.gnu.org/licenses/>.
+*/
+#define USE_SPI_LIB
+#include <Arduino.h>
+#include "Sd2Card.h"
+//------------------------------------------------------------------------------
+#ifndef SOFTWARE_SPI
+#ifdef USE_SPI_LIB
+
+  #ifndef SDCARD_SPI
+    #define SDCARD_SPI SPI
+  #endif
+
+  #include <SPI.h>
+  static SPISettings settings;
+#endif
+// functions for hardware SPI
+/** Send a byte to the card */
+static void spiSend(uint8_t b) {
+  #ifndef USE_SPI_LIB
+  SPDR = b;
+  while (!(SPSR & (1 << SPIF)))
+    ;
+  #else
+  SDCARD_SPI.transfer(b);
+  #endif
+}
+/** Receive a byte from the card */
+static  uint8_t spiRec(void) {
+  #ifndef USE_SPI_LIB
+  spiSend(0XFF);
+  return SPDR;
+  #else
+  return SDCARD_SPI.transfer(0xFF);
+  #endif
+}
+#else  // SOFTWARE_SPI
+//------------------------------------------------------------------------------
+/** nop to tune soft SPI timing */
+#define nop asm volatile ("nop\n\t")
+//------------------------------------------------------------------------------
+/** Soft SPI receive */
+uint8_t spiRec(void) {
+  uint8_t data = 0;
+  // no interrupts during byte receive - about 8 us
+  cli();
+  // output pin high - like sending 0XFF
+  fastDigitalWrite(SPI_MOSI_PIN, HIGH);
+
+  for (uint8_t i = 0; i < 8; i++) {
+    fastDigitalWrite(SPI_SCK_PIN, HIGH);
+
+    // adjust so SCK is nice
+    nop;
+    nop;
+
+    data <<= 1;
+
+    if (fastDigitalRead(SPI_MISO_PIN)) {
+      data |= 1;
+    }
+
+    fastDigitalWrite(SPI_SCK_PIN, LOW);
+  }
+  // enable interrupts
+  sei();
+  return data;
+}
+//------------------------------------------------------------------------------
+/** Soft SPI send */
+void spiSend(uint8_t data) {
+  // no interrupts during byte send - about 8 us
+  cli();
+  for (uint8_t i = 0; i < 8; i++) {
+    fastDigitalWrite(SPI_SCK_PIN, LOW);
+
+    fastDigitalWrite(SPI_MOSI_PIN, data & 0X80);
+
+    data <<= 1;
+
+    fastDigitalWrite(SPI_SCK_PIN, HIGH);
+  }
+  // hold SCK high for a few ns
+  nop;
+  nop;
+  nop;
+  nop;
+
+  fastDigitalWrite(SPI_SCK_PIN, LOW);
+  // enable interrupts
+  sei();
+}
+#endif  // SOFTWARE_SPI
+//------------------------------------------------------------------------------
+// send command and return error code.  Return zero for OK
+uint8_t Sd2Card::cardCommand(uint8_t cmd, uint32_t arg) {
+  // end read if in partialBlockRead mode
+  readEnd();
+
+  // select card
+  chipSelectLow();
+
+  // wait up to 300 ms if busy
+  waitNotBusy(300);
+
+  // send command
+  spiSend(cmd | 0x40);
+
+  // send argument
+  for (int8_t s = 24; s >= 0; s -= 8) {
+    spiSend(arg >> s);
+  }
+
+  // send CRC
+  uint8_t crc = 0XFF;
+  if (cmd == CMD0) {
+    crc = 0X95;  // correct crc for CMD0 with arg 0
+  }
+  if (cmd == CMD8) {
+    crc = 0X87;  // correct crc for CMD8 with arg 0X1AA
+  }
+  spiSend(crc);
+
+  // wait for response
+  for (uint8_t i = 0; ((status_ = spiRec()) & 0X80) && i != 0XFF; i++)
+    ;
+  return status_;
+}
+//------------------------------------------------------------------------------
+/**
+   Determine the size of an SD flash memory card.
+
+   \return The number of 512 byte data blocks in the card
+           or zero if an error occurs.
+*/
+uint32_t Sd2Card::cardSize(void) {
+  csd_t csd;
+  if (!readCSD(&csd)) {
+    return 0;
+  }
+  if (csd.v1.csd_ver == 0) {
+    uint8_t read_bl_len = csd.v1.read_bl_len;
+    uint16_t c_size = (csd.v1.c_size_high << 10)
+                      | (csd.v1.c_size_mid << 2) | csd.v1.c_size_low;
+    uint8_t c_size_mult = (csd.v1.c_size_mult_high << 1)
+                          | csd.v1.c_size_mult_low;
+    return (uint32_t)(c_size + 1) << (c_size_mult + read_bl_len - 7);
+  } else if (csd.v2.csd_ver == 1) {
+    uint32_t c_size = ((uint32_t)csd.v2.c_size_high << 16)
+                      | (csd.v2.c_size_mid << 8) | csd.v2.c_size_low;
+    return (c_size + 1) << 10;
+  } else {
+    error(SD_CARD_ERROR_BAD_CSD);
+    return 0;
+  }
+}
+//------------------------------------------------------------------------------
+static uint8_t chip_select_asserted = 0;
+
+void Sd2Card::chipSelectHigh(void) {
+  digitalWrite(chipSelectPin_, HIGH);
+  #ifdef USE_SPI_LIB
+  if (chip_select_asserted) {
+    chip_select_asserted = 0;
+    SDCARD_SPI.endTransaction();
+  }
+  #endif
+}
+//------------------------------------------------------------------------------
+void Sd2Card::chipSelectLow(void) {
+  #ifdef USE_SPI_LIB
+  if (!chip_select_asserted) {
+    chip_select_asserted = 1;
+    SDCARD_SPI.beginTransaction(settings);
+  }
+  #endif
+  digitalWrite(chipSelectPin_, LOW);
+}
+//------------------------------------------------------------------------------
+/** Erase a range of blocks.
+
+   \param[in] firstBlock The address of the first block in the range.
+   \param[in] lastBlock The address of the last block in the range.
+
+   \note This function requests the SD card to do a flash erase for a
+   range of blocks.  The data on the card after an erase operation is
+   either 0 or 1, depends on the card vendor.  The card must support
+   single block erase.
+
+   \return The value one, true, is returned for success and
+   the value zero, false, is returned for failure.
+*/
+uint8_t Sd2Card::erase(uint32_t firstBlock, uint32_t lastBlock) {
+  if (!eraseSingleBlockEnable()) {
+    error(SD_CARD_ERROR_ERASE_SINGLE_BLOCK);
+    goto fail;
+  }
+  if (type_ != SD_CARD_TYPE_SDHC) {
+    firstBlock <<= 9;
+    lastBlock <<= 9;
+  }
+  if (cardCommand(CMD32, firstBlock)
+      || cardCommand(CMD33, lastBlock)
+      || cardCommand(CMD38, 0)) {
+    error(SD_CARD_ERROR_ERASE);
+    goto fail;
+  }
+  if (!waitNotBusy(SD_ERASE_TIMEOUT)) {
+    error(SD_CARD_ERROR_ERASE_TIMEOUT);
+    goto fail;
+  }
+  chipSelectHigh();
+  return true;
+
+fail:
+  chipSelectHigh();
+  return false;
+}
+//------------------------------------------------------------------------------
+/** Determine if card supports single block erase.
+
+   \return The value one, true, is returned if single block erase is supported.
+   The value zero, false, is returned if single block erase is not supported.
+*/
+uint8_t Sd2Card::eraseSingleBlockEnable(void) {
+  csd_t csd;
+  return readCSD(&csd) ? csd.v1.erase_blk_en : 0;
+}
+//------------------------------------------------------------------------------
+/**
+   Initialize an SD flash memory card.
+
+   \param[in] sckRateID SPI clock rate selector. See setSckRate().
+   \param[in] chipSelectPin SD chip select pin number.
+
+   \return The value one, true, is returned for success and
+   the value zero, false, is returned for failure.  The reason for failure
+   can be determined by calling errorCode() and errorData().
+*/
+uint8_t Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin) {
+  errorCode_ = inBlock_ = partialBlockRead_ = type_ = 0;
+  chipSelectPin_ = chipSelectPin;
+  // 16-bit init start time allows over a minute
+  unsigned int t0 = millis();
+  uint32_t arg;
+
+  // set pin modes
+  pinMode(chipSelectPin_, OUTPUT);
+  digitalWrite(chipSelectPin_, HIGH);
+  #ifndef USE_SPI_LIB
+  pinMode(SPI_MISO_PIN, INPUT);
+  pinMode(SPI_MOSI_PIN, OUTPUT);
+  pinMode(SPI_SCK_PIN, OUTPUT);
+  #endif
+
+  #ifndef SOFTWARE_SPI
+  #ifndef USE_SPI_LIB
+  // SS must be in output mode even it is not chip select
+  pinMode(SS_PIN, OUTPUT);
+  digitalWrite(SS_PIN, HIGH); // disable any SPI device using hardware SS pin
+  // Enable SPI, Master, clock rate f_osc/128
+  SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR1) | (1 << SPR0);
+  // clear double speed
+  SPSR &= ~(1 << SPI2X);
+  #else // USE_SPI_LIB
+  SDCARD_SPI.begin();
+  settings = SPISettings(250000, MSBFIRST, SPI_MODE0);
+  #endif // USE_SPI_LIB
+  #endif // SOFTWARE_SPI
+
+  // must supply min of 74 clock cycles with CS high.
+  #ifdef USE_SPI_LIB
+  SDCARD_SPI.beginTransaction(settings);
+  #endif
+  for (uint8_t i = 0; i < 10; i++) {
+    spiSend(0XFF);
+  }
+  #ifdef USE_SPI_LIB
+  SDCARD_SPI.endTransaction();
+  #endif
+
+  chipSelectLow();
+
+  // command to go idle in SPI mode
+  while ((status_ = cardCommand(CMD0, 0)) != R1_IDLE_STATE) {
+    unsigned int d = millis() - t0;
+    if (d > SD_INIT_TIMEOUT) {
+      error(SD_CARD_ERROR_CMD0);
+      goto fail;
+    }
+  }
+  // check SD version
+  if ((cardCommand(CMD8, 0x1AA) & R1_ILLEGAL_COMMAND)) {
+    type(SD_CARD_TYPE_SD1);
+  } else {
+    // only need last byte of r7 response
+    for (uint8_t i = 0; i < 4; i++) {
+      status_ = spiRec();
+    }
+    if (status_ != 0XAA) {
+      error(SD_CARD_ERROR_CMD8);
+      goto fail;
+    }
+    type(SD_CARD_TYPE_SD2);
+  }
+  // initialize card and send host supports SDHC if SD2
+  arg = type() == SD_CARD_TYPE_SD2 ? 0X40000000 : 0;
+
+  while ((status_ = cardAcmd(ACMD41, arg)) != R1_READY_STATE) {
+    // check for timeout
+    unsigned int d = millis() - t0;
+    if (d > SD_INIT_TIMEOUT) {
+      error(SD_CARD_ERROR_ACMD41);
+      goto fail;
+    }
+  }
+  // if SD2 read OCR register to check for SDHC card
+  if (type() == SD_CARD_TYPE_SD2) {
+    if (cardCommand(CMD58, 0)) {
+      error(SD_CARD_ERROR_CMD58);
+      goto fail;
+    }
+    if ((spiRec() & 0XC0) == 0XC0) {
+      type(SD_CARD_TYPE_SDHC);
+    }
+    // discard rest of ocr - contains allowed voltage range
+    for (uint8_t i = 0; i < 3; i++) {
+      spiRec();
+    }
+  }
+  chipSelectHigh();
+
+  #ifndef SOFTWARE_SPI
+  return setSckRate(sckRateID);
+  #else  // SOFTWARE_SPI
+  return true;
+  #endif  // SOFTWARE_SPI
+
+fail:
+  chipSelectHigh();
+  return false;
+}
+//------------------------------------------------------------------------------
+/**
+   Enable or disable partial block reads.
+
+   Enabling partial block reads improves performance by allowing a block
+   to be read over the SPI bus as several sub-blocks.  Errors may occur
+   if the time between reads is too long since the SD card may timeout.
+   The SPI SS line will be held low until the entire block is read or
+   readEnd() is called.
+
+   Use this for applications like the Adafruit Wave Shield.
+
+   \param[in] value The value TRUE (non-zero) or FALSE (zero).)
+*/
+void Sd2Card::partialBlockRead(uint8_t value) {
+  readEnd();
+  partialBlockRead_ = value;
+}
+//------------------------------------------------------------------------------
+/**
+   Read a 512 byte block from an SD card device.
+
+   \param[in] block Logical block to be read.
+   \param[out] dst Pointer to the location that will receive the data.
+
+   \return The value one, true, is returned for success and
+   the value zero, false, is returned for failure.
+*/
+uint8_t Sd2Card::readBlock(uint32_t block, uint8_t* dst) {
+  return readData(block, 0, 512, dst);
+}
+//------------------------------------------------------------------------------
+/**
+   Read part of a 512 byte block from an SD card.
+
+   \param[in] block Logical block to be read.
+   \param[in] offset Number of bytes to skip at start of block
+   \param[out] dst Pointer to the location that will receive the data.
+   \param[in] count Number of bytes to read
+   \return The value one, true, is returned for success and
+   the value zero, false, is returned for failure.
+*/
+uint8_t Sd2Card::readData(uint32_t block,
+                          uint16_t offset, uint16_t count, uint8_t* dst) {
+  if (count == 0) {
+    return true;
+  }
+  if ((count + offset) > 512) {
+    goto fail;
+  }
+  if (!inBlock_ || block != block_ || offset < offset_) {
+    block_ = block;
+    // use address if not SDHC card
+    if (type() != SD_CARD_TYPE_SDHC) {
+      block <<= 9;
+    }
+    if (cardCommand(CMD17, block)) {
+      error(SD_CARD_ERROR_CMD17);
+      goto fail;
+    }
+    if (!waitStartBlock()) {
+      goto fail;
+    }
+    offset_ = 0;
+    inBlock_ = 1;
+  }
+
+  #ifdef OPTIMIZE_HARDWARE_SPI
+  // start first spi transfer
+  SPDR = 0XFF;
+
+  // skip data before offset
+  for (; offset_ < offset; offset_++) {
+    while (!(SPSR & (1 << SPIF)))
+      ;
+    SPDR = 0XFF;
+  }
+  // transfer data
+  n = count - 1;
+  for (uint16_t i = 0; i < n; i++) {
+    while (!(SPSR & (1 << SPIF)))
+      ;
+    dst[i] = SPDR;
+    SPDR = 0XFF;
+  }
+  // wait for last byte
+  while (!(SPSR & (1 << SPIF)))
+    ;
+  dst[n] = SPDR;
+
+  #else  // OPTIMIZE_HARDWARE_SPI
+
+  // skip data before offset
+  for (; offset_ < offset; offset_++) {
+    spiRec();
+  }
+  // transfer data
+  for (uint16_t i = 0; i < count; i++) {
+    dst[i] = spiRec();
+  }
+  #endif  // OPTIMIZE_HARDWARE_SPI
+
+  offset_ += count;
+  if (!partialBlockRead_ || offset_ >= 512) {
+    // read rest of data, checksum and set chip select high
+    readEnd();
+  }
+  return true;
+
+fail:
+  chipSelectHigh();
+  return false;
+}
+//------------------------------------------------------------------------------
+/** Skip remaining data in a block when in partial block read mode. */
+void Sd2Card::readEnd(void) {
+  if (inBlock_) {
+    // skip data and crc
+    #ifdef OPTIMIZE_HARDWARE_SPI
+    // optimize skip for hardware
+    SPDR = 0XFF;
+    while (offset_++ < 513) {
+      while (!(SPSR & (1 << SPIF)))
+        ;
+      SPDR = 0XFF;
+    }
+    // wait for last crc byte
+    while (!(SPSR & (1 << SPIF)))
+      ;
+    #else  // OPTIMIZE_HARDWARE_SPI
+    while (offset_++ < 514) {
+      spiRec();
+    }
+    #endif  // OPTIMIZE_HARDWARE_SPI
+    chipSelectHigh();
+    inBlock_ = 0;
+  }
+}
+//------------------------------------------------------------------------------
+/** read CID or CSR register */
+uint8_t Sd2Card::readRegister(uint8_t cmd, void* buf) {
+  uint8_t* dst = reinterpret_cast<uint8_t*>(buf);
+  if (cardCommand(cmd, 0)) {
+    error(SD_CARD_ERROR_READ_REG);
+    goto fail;
+  }
+  if (!waitStartBlock()) {
+    goto fail;
+  }
+  // transfer data
+  for (uint16_t i = 0; i < 16; i++) {
+    dst[i] = spiRec();
+  }
+  spiRec();  // get first crc byte
+  spiRec();  // get second crc byte
+  chipSelectHigh();
+  return true;
+
+fail:
+  chipSelectHigh();
+  return false;
+}
+//------------------------------------------------------------------------------
+/**
+   Set the SPI clock rate.
+
+   \param[in] sckRateID A value in the range [0, 6].
+
+   The SPI clock will be set to F_CPU/pow(2, 1 + sckRateID). The maximum
+   SPI rate is F_CPU/2 for \a sckRateID = 0 and the minimum rate is F_CPU/128
+   for \a scsRateID = 6.
+
+   \return The value one, true, is returned for success and the value zero,
+   false, is returned for an invalid value of \a sckRateID.
+*/
+uint8_t Sd2Card::setSckRate(uint8_t sckRateID) {
+  if (sckRateID > 6) {
+    error(SD_CARD_ERROR_SCK_RATE);
+    return false;
+  }
+  #ifndef USE_SPI_LIB
+  // see avr processor datasheet for SPI register bit definitions
+  if ((sckRateID & 1) || sckRateID == 6) {
+    SPSR &= ~(1 << SPI2X);
+  } else {
+    SPSR |= (1 << SPI2X);
+  }
+  SPCR &= ~((1 << SPR1) | (1 << SPR0));
+  SPCR |= (sckRateID & 4 ? (1 << SPR1) : 0)
+          | (sckRateID & 2 ? (1 << SPR0) : 0);
+  #else // USE_SPI_LIB
+  switch (sckRateID) {
+    case 0:  settings = SPISettings(25000000, MSBFIRST, SPI_MODE0); break;
+    case 1:  settings = SPISettings(4000000, MSBFIRST, SPI_MODE0); break;
+    case 2:  settings = SPISettings(2000000, MSBFIRST, SPI_MODE0); break;
+    case 3:  settings = SPISettings(1000000, MSBFIRST, SPI_MODE0); break;
+    case 4:  settings = SPISettings(500000, MSBFIRST, SPI_MODE0); break;
+    case 5:  settings = SPISettings(250000, MSBFIRST, SPI_MODE0); break;
+    default: settings = SPISettings(125000, MSBFIRST, SPI_MODE0);
+  }
+  #endif // USE_SPI_LIB
+  return true;
+}
+#ifdef USE_SPI_LIB
+//------------------------------------------------------------------------------
+// set the SPI clock frequency
+uint8_t Sd2Card::setSpiClock(uint32_t clock) {
+  settings = SPISettings(clock, MSBFIRST, SPI_MODE0);
+  return true;
+}
+#endif
+//------------------------------------------------------------------------------
+// wait for card to go not busy
+uint8_t Sd2Card::waitNotBusy(unsigned int timeoutMillis) {
+  unsigned int t0 = millis();
+  unsigned int d;
+  do {
+    if (spiRec() == 0XFF) {
+      return true;
+    }
+    d = millis() - t0;
+  } while (d < timeoutMillis);
+  return false;
+}
+//------------------------------------------------------------------------------
+/** Wait for start block token */
+uint8_t Sd2Card::waitStartBlock(void) {
+  unsigned int t0 = millis();
+  while ((status_ = spiRec()) == 0XFF) {
+    unsigned int d = millis() - t0;
+    if (d > SD_READ_TIMEOUT) {
+      error(SD_CARD_ERROR_READ_TIMEOUT);
+      goto fail;
+    }
+  }
+  if (status_ != DATA_START_BLOCK) {
+    error(SD_CARD_ERROR_READ);
+    goto fail;
+  }
+  return true;
+
+fail:
+  chipSelectHigh();
+  return false;
+}
+//------------------------------------------------------------------------------
+/**
+   Writes a 512 byte block to an SD card.
+
+   \param[in] blockNumber Logical block to be written.
+   \param[in] src Pointer to the location of the data to be written.
+   \param[in] blocking If the write should be blocking.
+   \return The value one, true, is returned for success and
+   the value zero, false, is returned for failure.
+*/
+uint8_t Sd2Card::writeBlock(uint32_t blockNumber, const uint8_t* src, uint8_t blocking) {
+  #if SD_PROTECT_BLOCK_ZERO
+  // don't allow write to first block
+  if (blockNumber == 0) {
+    error(SD_CARD_ERROR_WRITE_BLOCK_ZERO);
+    goto fail;
+  }
+  #endif  // SD_PROTECT_BLOCK_ZERO
+
+  // use address if not SDHC card
+  if (type() != SD_CARD_TYPE_SDHC) {
+    blockNumber <<= 9;
+  }
+  if (cardCommand(CMD24, blockNumber)) {
+    error(SD_CARD_ERROR_CMD24);
+    goto fail;
+  }
+  if (!writeData(DATA_START_BLOCK, src)) {
+    goto fail;
+  }
+  if (blocking) {
+    // wait for flash programming to complete
+    if (!waitNotBusy(SD_WRITE_TIMEOUT)) {
+      error(SD_CARD_ERROR_WRITE_TIMEOUT);
+      goto fail;
+    }
+    // response is r2 so get and check two bytes for nonzero
+    if (cardCommand(CMD13, 0) || spiRec()) {
+      error(SD_CARD_ERROR_WRITE_PROGRAMMING);
+      goto fail;
+    }
+  }
+  chipSelectHigh();
+  return true;
+
+fail:
+  chipSelectHigh();
+  return false;
+}
+//------------------------------------------------------------------------------
+/** Write one data block in a multiple block write sequence */
+uint8_t Sd2Card::writeData(const uint8_t* src) {
+  // wait for previous write to finish
+  if (!waitNotBusy(SD_WRITE_TIMEOUT)) {
+    error(SD_CARD_ERROR_WRITE_MULTIPLE);
+    chipSelectHigh();
+    return false;
+  }
+  return writeData(WRITE_MULTIPLE_TOKEN, src);
+}
+//------------------------------------------------------------------------------
+// send one block of data for write block or write multiple blocks
+uint8_t Sd2Card::writeData(uint8_t token, const uint8_t* src) {
+  #ifdef OPTIMIZE_HARDWARE_SPI
+
+  // send data - optimized loop
+  SPDR = token;
+
+  // send two byte per iteration
+  for (uint16_t i = 0; i < 512; i += 2) {
+    while (!(SPSR & (1 << SPIF)))
+      ;
+    SPDR = src[i];
+    while (!(SPSR & (1 << SPIF)))
+      ;
+    SPDR = src[i + 1];
+  }
+
+  // wait for last data byte
+  while (!(SPSR & (1 << SPIF)))
+    ;
+
+  #else  // OPTIMIZE_HARDWARE_SPI
+  spiSend(token);
+  for (uint16_t i = 0; i < 512; i++) {
+    spiSend(src[i]);
+  }
+  #endif  // OPTIMIZE_HARDWARE_SPI
+  spiSend(0xff);  // dummy crc
+  spiSend(0xff);  // dummy crc
+
+  status_ = spiRec();
+  if ((status_ & DATA_RES_MASK) != DATA_RES_ACCEPTED) {
+    error(SD_CARD_ERROR_WRITE);
+    chipSelectHigh();
+    return false;
+  }
+  return true;
+}
+//------------------------------------------------------------------------------
+/** Start a write multiple blocks sequence.
+
+   \param[in] blockNumber Address of first block in sequence.
+   \param[in] eraseCount The number of blocks to be pre-erased.
+
+   \note This function is used with writeData() and writeStop()
+   for optimized multiple block writes.
+
+   \return The value one, true, is returned for success and
+   the value zero, false, is returned for failure.
+*/
+uint8_t Sd2Card::writeStart(uint32_t blockNumber, uint32_t eraseCount) {
+  #if SD_PROTECT_BLOCK_ZERO
+  // don't allow write to first block
+  if (blockNumber == 0) {
+    error(SD_CARD_ERROR_WRITE_BLOCK_ZERO);
+    goto fail;
+  }
+  #endif  // SD_PROTECT_BLOCK_ZERO
+  // send pre-erase count
+  if (cardAcmd(ACMD23, eraseCount)) {
+    error(SD_CARD_ERROR_ACMD23);
+    goto fail;
+  }
+  // use address if not SDHC card
+  if (type() != SD_CARD_TYPE_SDHC) {
+    blockNumber <<= 9;
+  }
+  if (cardCommand(CMD25, blockNumber)) {
+    error(SD_CARD_ERROR_CMD25);
+    goto fail;
+  }
+  return true;
+
+fail:
+  chipSelectHigh();
+  return false;
+}
+//------------------------------------------------------------------------------
+/** End a write multiple blocks sequence.
+
+  \return The value one, true, is returned for success and
+   the value zero, false, is returned for failure.
+*/
+uint8_t Sd2Card::writeStop(void) {
+  if (!waitNotBusy(SD_WRITE_TIMEOUT)) {
+    goto fail;
+  }
+  spiSend(STOP_TRAN_TOKEN);
+  if (!waitNotBusy(SD_WRITE_TIMEOUT)) {
+    goto fail;
+  }
+  chipSelectHigh();
+  return true;
+
+fail:
+  error(SD_CARD_ERROR_STOP_TRAN);
+  chipSelectHigh();
+  return false;
+}
+//------------------------------------------------------------------------------
+/** Check if the SD card is busy
+
+  \return The value one, true, is returned when is busy and
+   the value zero, false, is returned for when is NOT busy.
+*/
+uint8_t Sd2Card::isBusy(void) {
+  chipSelectLow();
+  byte b = spiRec();
+  chipSelectHigh();
+
+  return (b != 0XFF);
+}
diff --git a/libraries/SD/src/utility/Sd2Card.h b/libraries/SD/src/utility/Sd2Card.h
new file mode 100755
index 0000000..5d91ebf
--- /dev/null
+++ b/libraries/SD/src/utility/Sd2Card.h
@@ -0,0 +1,273 @@
+/* Arduino Sd2Card Library
+   Copyright (C) 2009 by William Greiman
+
+   This file is part of the Arduino Sd2Card Library
+
+   This Library is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with the Arduino Sd2Card Library.  If not, see
+   <http://www.gnu.org/licenses/>.
+*/
+#ifndef Sd2Card_h
+#define Sd2Card_h
+/**
+   \file
+   Sd2Card class
+*/
+#include "Sd2PinMap.h"
+#include "SdInfo.h"
+/** Set SCK to max rate of F_CPU/2. See Sd2Card::setSckRate(). */
+uint8_t const SPI_FULL_SPEED = 0;
+/** Set SCK rate to F_CPU/4. See Sd2Card::setSckRate(). */
+uint8_t const SPI_HALF_SPEED = 1;
+/** Set SCK rate to F_CPU/8. Sd2Card::setSckRate(). */
+uint8_t const SPI_QUARTER_SPEED = 2;
+/**
+   USE_SPI_LIB: if set, use the SPI library bundled with Arduino IDE, otherwise
+   run with a standalone driver for AVR.
+*/
+#define USE_SPI_LIB
+/**
+   Define MEGA_SOFT_SPI non-zero to use software SPI on Mega Arduinos.
+   Pins used are SS 10, MOSI 11, MISO 12, and SCK 13.
+
+   MEGA_SOFT_SPI allows an unmodified Adafruit GPS Shield to be used
+   on Mega Arduinos.  Software SPI works well with GPS Shield V1.1
+   but many SD cards will fail with GPS Shield V1.0.
+*/
+#define MEGA_SOFT_SPI 0
+//------------------------------------------------------------------------------
+#if MEGA_SOFT_SPI && (defined(__AVR_ATmega1280__)||defined(__AVR_ATmega2560__))
+  #define SOFTWARE_SPI
+#endif  // MEGA_SOFT_SPI
+//------------------------------------------------------------------------------
+// SPI pin definitions
+//
+#ifndef SOFTWARE_SPI
+  // hardware pin defs
+
+  // include pins_arduino.h or variant.h depending on architecture, via Arduino.h
+  #include <Arduino.h>
+
+  /**
+  SD Chip Select pin
+
+  Warning if this pin is redefined the hardware SS will pin will be enabled
+  as an output by init().  An avr processor will not function as an SPI
+  master unless SS is set to output mode.
+  */
+  #ifndef SDCARD_SS_PIN
+    /** The default chip select pin for the SD card is SS. */
+    uint8_t const  SD_CHIP_SELECT_PIN = SS;
+  #else
+    uint8_t const  SD_CHIP_SELECT_PIN = SDCARD_SS_PIN;
+  #endif
+
+  // The following three pins must not be redefined for hardware SPI,
+  // so ensure that they are taken from pins_arduino.h or variant.h, depending on architecture.
+  #ifndef SDCARD_MOSI_PIN
+    /** SPI Master Out Slave In pin */
+    uint8_t const  SPI_MOSI_PIN = MOSI;
+    /** SPI Master In Slave Out pin */
+    uint8_t const  SPI_MISO_PIN = MISO;
+    /** SPI Clock pin */
+    uint8_t const  SPI_SCK_PIN = SCK;
+  #else
+    uint8_t const  SPI_MOSI_PIN = SDCARD_MOSI_PIN;
+    uint8_t const  SPI_MISO_PIN = SDCARD_MISO_PIN;
+    uint8_t const  SPI_SCK_PIN = SDCARD_SCK_PIN;
+  #endif
+
+  /** optimize loops for hardware SPI */
+  #ifndef USE_SPI_LIB
+    #define OPTIMIZE_HARDWARE_SPI
+  #endif
+
+#else  // SOFTWARE_SPI
+  // define software SPI pins so Mega can use unmodified GPS Shield
+  /** SPI chip select pin */
+  uint8_t const SD_CHIP_SELECT_PIN = 10;
+  /** SPI Master Out Slave In pin */
+  uint8_t const SPI_MOSI_PIN = 11;
+  /** SPI Master In Slave Out pin */
+  uint8_t const SPI_MISO_PIN = 12;
+  /** SPI Clock pin */
+  uint8_t const SPI_SCK_PIN = 13;
+#endif  // SOFTWARE_SPI
+//------------------------------------------------------------------------------
+/** Protect block zero from write if nonzero */
+#define SD_PROTECT_BLOCK_ZERO 1
+/** init timeout ms */
+unsigned int const SD_INIT_TIMEOUT = 2000;
+/** erase timeout ms */
+unsigned int const SD_ERASE_TIMEOUT = 10000;
+/** read timeout ms */
+unsigned int const SD_READ_TIMEOUT = 300;
+/** write time out ms */
+unsigned int const SD_WRITE_TIMEOUT = 600;
+//------------------------------------------------------------------------------
+// SD card errors
+/** timeout error for command CMD0 */
+uint8_t const SD_CARD_ERROR_CMD0 = 0X1;
+/** CMD8 was not accepted - not a valid SD card*/
+uint8_t const SD_CARD_ERROR_CMD8 = 0X2;
+/** card returned an error response for CMD17 (read block) */
+uint8_t const SD_CARD_ERROR_CMD17 = 0X3;
+/** card returned an error response for CMD24 (write block) */
+uint8_t const SD_CARD_ERROR_CMD24 = 0X4;
+/**  WRITE_MULTIPLE_BLOCKS command failed */
+uint8_t const SD_CARD_ERROR_CMD25 = 0X05;
+/** card returned an error response for CMD58 (read OCR) */
+uint8_t const SD_CARD_ERROR_CMD58 = 0X06;
+/** SET_WR_BLK_ERASE_COUNT failed */
+uint8_t const SD_CARD_ERROR_ACMD23 = 0X07;
+/** card's ACMD41 initialization process timeout */
+uint8_t const SD_CARD_ERROR_ACMD41 = 0X08;
+/** card returned a bad CSR version field */
+uint8_t const SD_CARD_ERROR_BAD_CSD = 0X09;
+/** erase block group command failed */
+uint8_t const SD_CARD_ERROR_ERASE = 0X0A;
+/** card not capable of single block erase */
+uint8_t const SD_CARD_ERROR_ERASE_SINGLE_BLOCK = 0X0B;
+/** Erase sequence timed out */
+uint8_t const SD_CARD_ERROR_ERASE_TIMEOUT = 0X0C;
+/** card returned an error token instead of read data */
+uint8_t const SD_CARD_ERROR_READ = 0X0D;
+/** read CID or CSD failed */
+uint8_t const SD_CARD_ERROR_READ_REG = 0X0E;
+/** timeout while waiting for start of read data */
+uint8_t const SD_CARD_ERROR_READ_TIMEOUT = 0X0F;
+/** card did not accept STOP_TRAN_TOKEN */
+uint8_t const SD_CARD_ERROR_STOP_TRAN = 0X10;
+/** card returned an error token as a response to a write operation */
+uint8_t const SD_CARD_ERROR_WRITE = 0X11;
+/** attempt to write protected block zero */
+uint8_t const SD_CARD_ERROR_WRITE_BLOCK_ZERO = 0X12;
+/** card did not go ready for a multiple block write */
+uint8_t const SD_CARD_ERROR_WRITE_MULTIPLE = 0X13;
+/** card returned an error to a CMD13 status check after a write */
+uint8_t const SD_CARD_ERROR_WRITE_PROGRAMMING = 0X14;
+/** timeout occurred during write programming */
+uint8_t const SD_CARD_ERROR_WRITE_TIMEOUT = 0X15;
+/** incorrect rate selected */
+uint8_t const SD_CARD_ERROR_SCK_RATE = 0X16;
+//------------------------------------------------------------------------------
+// card types
+/** Standard capacity V1 SD card */
+uint8_t const SD_CARD_TYPE_SD1 = 1;
+/** Standard capacity V2 SD card */
+uint8_t const SD_CARD_TYPE_SD2 = 2;
+/** High Capacity SD card */
+uint8_t const SD_CARD_TYPE_SDHC = 3;
+//------------------------------------------------------------------------------
+/**
+   \class Sd2Card
+   \brief Raw access to SD and SDHC flash memory cards.
+*/
+class Sd2Card {
+  public:
+    /** Construct an instance of Sd2Card. */
+    Sd2Card(void) : errorCode_(0), inBlock_(0), partialBlockRead_(0), type_(0) {}
+    uint32_t cardSize(void);
+    uint8_t erase(uint32_t firstBlock, uint32_t lastBlock);
+    uint8_t eraseSingleBlockEnable(void);
+    /**
+       \return error code for last error. See Sd2Card.h for a list of error codes.
+    */
+    uint8_t errorCode(void) const {
+      return errorCode_;
+    }
+    /** \return error data for last error. */
+    uint8_t errorData(void) const {
+      return status_;
+    }
+    /**
+       Initialize an SD flash memory card with default clock rate and chip
+       select pin.  See sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin).
+    */
+    uint8_t init(void) {
+      return init(SPI_FULL_SPEED, SD_CHIP_SELECT_PIN);
+    }
+    /**
+       Initialize an SD flash memory card with the selected SPI clock rate
+       and the default SD chip select pin.
+       See sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin).
+    */
+    uint8_t init(uint8_t sckRateID) {
+      return init(sckRateID, SD_CHIP_SELECT_PIN);
+    }
+    uint8_t init(uint8_t sckRateID, uint8_t chipSelectPin);
+    void partialBlockRead(uint8_t value);
+    /** Returns the current value, true or false, for partial block read. */
+    uint8_t partialBlockRead(void) const {
+      return partialBlockRead_;
+    }
+    uint8_t readBlock(uint32_t block, uint8_t* dst);
+    uint8_t readData(uint32_t block,
+                     uint16_t offset, uint16_t count, uint8_t* dst);
+    /**
+       Read a cards CID register. The CID contains card identification
+       information such as Manufacturer ID, Product name, Product serial
+       number and Manufacturing date. */
+    uint8_t readCID(cid_t* cid) {
+      return readRegister(CMD10, cid);
+    }
+    /**
+       Read a cards CSD register. The CSD contains Card-Specific Data that
+       provides information regarding access to the card's contents. */
+    uint8_t readCSD(csd_t* csd) {
+      return readRegister(CMD9, csd);
+    }
+    void readEnd(void);
+    uint8_t setSckRate(uint8_t sckRateID);
+    #ifdef USE_SPI_LIB
+    uint8_t setSpiClock(uint32_t clock);
+    #endif
+    /** Return the card type: SD V1, SD V2 or SDHC */
+    uint8_t type(void) const {
+      return type_;
+    }
+    uint8_t writeBlock(uint32_t blockNumber, const uint8_t* src, uint8_t blocking = 1);
+    uint8_t writeData(const uint8_t* src);
+    uint8_t writeStart(uint32_t blockNumber, uint32_t eraseCount);
+    uint8_t writeStop(void);
+    uint8_t isBusy(void);
+  private:
+    uint32_t block_;
+    uint8_t chipSelectPin_;
+    uint8_t errorCode_;
+    uint8_t inBlock_;
+    uint16_t offset_;
+    uint8_t partialBlockRead_;
+    uint8_t status_;
+    uint8_t type_;
+    // private functions
+    uint8_t cardAcmd(uint8_t cmd, uint32_t arg) {
+      cardCommand(CMD55, 0);
+      return cardCommand(cmd, arg);
+    }
+    uint8_t cardCommand(uint8_t cmd, uint32_t arg);
+    void error(uint8_t code) {
+      errorCode_ = code;
+    }
+    uint8_t readRegister(uint8_t cmd, void* buf);
+    uint8_t sendWriteCommand(uint32_t blockNumber, uint32_t eraseCount);
+    void chipSelectHigh(void);
+    void chipSelectLow(void);
+    void type(uint8_t value) {
+      type_ = value;
+    }
+    uint8_t waitNotBusy(unsigned int timeoutMillis);
+    uint8_t writeData(uint8_t token, const uint8_t* src);
+    uint8_t waitStartBlock(void);
+};
+#endif  // Sd2Card_h
diff --git a/libraries/SD/src/utility/Sd2PinMap.h b/libraries/SD/src/utility/Sd2PinMap.h
new file mode 100755
index 0000000..0609ffe
--- /dev/null
+++ b/libraries/SD/src/utility/Sd2PinMap.h
@@ -0,0 +1,525 @@
+/* Arduino SdFat Library
+   Copyright (C) 2010 by William Greiman
+
+   This file is part of the Arduino SdFat Library
+
+   This Library is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with the Arduino SdFat Library.  If not, see
+   <http://www.gnu.org/licenses/>.
+*/
+#if defined(__arm__) // Arduino Due Board follows
+
+#ifndef Sd2PinMap_h
+  #define Sd2PinMap_h
+
+  #include <Arduino.h>
+
+  uint8_t const SS_PIN = SS;
+  uint8_t const MOSI_PIN = MOSI;
+  uint8_t const MISO_PIN = MISO;
+  uint8_t const SCK_PIN = SCK;
+
+#endif // Sd2PinMap_h
+
+#elif defined(__AVR_ATmega4809__) // Arduino UNO WiFI Rev2 follows
+
+#ifndef Sd2PinMap_h
+  #define Sd2PinMap_h
+
+  #include <Arduino.h>
+
+  uint8_t const SS_PIN = SS;
+  uint8_t const MOSI_PIN = MOSI;
+  uint8_t const MISO_PIN = MISO;
+  uint8_t const SCK_PIN = SCK;
+
+#endif // Sd2PinMap_h
+
+#elif defined(__AVR__) // Other AVR based Boards follows
+
+// Warning this file was generated by a program.
+#ifndef Sd2PinMap_h
+#define Sd2PinMap_h
+#include <avr/io.h>
+
+//------------------------------------------------------------------------------
+/** struct for mapping digital pins */
+struct pin_map_t {
+  volatile uint8_t* ddr;
+  volatile uint8_t* pin;
+  volatile uint8_t* port;
+  uint8_t bit;
+};
+//------------------------------------------------------------------------------
+#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
+// Mega
+
+// Two Wire (aka I2C) ports
+uint8_t const SDA_PIN = 20;
+uint8_t const SCL_PIN = 21;
+
+// SPI port
+uint8_t const SS_PIN = 53;
+uint8_t const MOSI_PIN = 51;
+uint8_t const MISO_PIN = 50;
+uint8_t const SCK_PIN = 52;
+
+static const pin_map_t digitalPinMap[] = {
+  {&DDRE, &PINE, &PORTE, 0},  // E0  0
+  {&DDRE, &PINE, &PORTE, 1},  // E1  1
+  {&DDRE, &PINE, &PORTE, 4},  // E4  2
+  {&DDRE, &PINE, &PORTE, 5},  // E5  3
+  {&DDRG, &PING, &PORTG, 5},  // G5  4
+  {&DDRE, &PINE, &PORTE, 3},  // E3  5
+  {&DDRH, &PINH, &PORTH, 3},  // H3  6
+  {&DDRH, &PINH, &PORTH, 4},  // H4  7
+  {&DDRH, &PINH, &PORTH, 5},  // H5  8
+  {&DDRH, &PINH, &PORTH, 6},  // H6  9
+  {&DDRB, &PINB, &PORTB, 4},  // B4 10
+  {&DDRB, &PINB, &PORTB, 5},  // B5 11
+  {&DDRB, &PINB, &PORTB, 6},  // B6 12
+  {&DDRB, &PINB, &PORTB, 7},  // B7 13
+  {&DDRJ, &PINJ, &PORTJ, 1},  // J1 14
+  {&DDRJ, &PINJ, &PORTJ, 0},  // J0 15
+  {&DDRH, &PINH, &PORTH, 1},  // H1 16
+  {&DDRH, &PINH, &PORTH, 0},  // H0 17
+  {&DDRD, &PIND, &PORTD, 3},  // D3 18
+  {&DDRD, &PIND, &PORTD, 2},  // D2 19
+  {&DDRD, &PIND, &PORTD, 1},  // D1 20
+  {&DDRD, &PIND, &PORTD, 0},  // D0 21
+  {&DDRA, &PINA, &PORTA, 0},  // A0 22
+  {&DDRA, &PINA, &PORTA, 1},  // A1 23
+  {&DDRA, &PINA, &PORTA, 2},  // A2 24
+  {&DDRA, &PINA, &PORTA, 3},  // A3 25
+  {&DDRA, &PINA, &PORTA, 4},  // A4 26
+  {&DDRA, &PINA, &PORTA, 5},  // A5 27
+  {&DDRA, &PINA, &PORTA, 6},  // A6 28
+  {&DDRA, &PINA, &PORTA, 7},  // A7 29
+  {&DDRC, &PINC, &PORTC, 7},  // C7 30
+  {&DDRC, &PINC, &PORTC, 6},  // C6 31
+  {&DDRC, &PINC, &PORTC, 5},  // C5 32
+  {&DDRC, &PINC, &PORTC, 4},  // C4 33
+  {&DDRC, &PINC, &PORTC, 3},  // C3 34
+  {&DDRC, &PINC, &PORTC, 2},  // C2 35
+  {&DDRC, &PINC, &PORTC, 1},  // C1 36
+  {&DDRC, &PINC, &PORTC, 0},  // C0 37
+  {&DDRD, &PIND, &PORTD, 7},  // D7 38
+  {&DDRG, &PING, &PORTG, 2},  // G2 39
+  {&DDRG, &PING, &PORTG, 1},  // G1 40
+  {&DDRG, &PING, &PORTG, 0},  // G0 41
+  {&DDRL, &PINL, &PORTL, 7},  // L7 42
+  {&DDRL, &PINL, &PORTL, 6},  // L6 43
+  {&DDRL, &PINL, &PORTL, 5},  // L5 44
+  {&DDRL, &PINL, &PORTL, 4},  // L4 45
+  {&DDRL, &PINL, &PORTL, 3},  // L3 46
+  {&DDRL, &PINL, &PORTL, 2},  // L2 47
+  {&DDRL, &PINL, &PORTL, 1},  // L1 48
+  {&DDRL, &PINL, &PORTL, 0},  // L0 49
+  {&DDRB, &PINB, &PORTB, 3},  // B3 50
+  {&DDRB, &PINB, &PORTB, 2},  // B2 51
+  {&DDRB, &PINB, &PORTB, 1},  // B1 52
+  {&DDRB, &PINB, &PORTB, 0},  // B0 53
+  {&DDRF, &PINF, &PORTF, 0},  // F0 54
+  {&DDRF, &PINF, &PORTF, 1},  // F1 55
+  {&DDRF, &PINF, &PORTF, 2},  // F2 56
+  {&DDRF, &PINF, &PORTF, 3},  // F3 57
+  {&DDRF, &PINF, &PORTF, 4},  // F4 58
+  {&DDRF, &PINF, &PORTF, 5},  // F5 59
+  {&DDRF, &PINF, &PORTF, 6},  // F6 60
+  {&DDRF, &PINF, &PORTF, 7},  // F7 61
+  {&DDRK, &PINK, &PORTK, 0},  // K0 62
+  {&DDRK, &PINK, &PORTK, 1},  // K1 63
+  {&DDRK, &PINK, &PORTK, 2},  // K2 64
+  {&DDRK, &PINK, &PORTK, 3},  // K3 65
+  {&DDRK, &PINK, &PORTK, 4},  // K4 66
+  {&DDRK, &PINK, &PORTK, 5},  // K5 67
+  {&DDRK, &PINK, &PORTK, 6},  // K6 68
+  {&DDRK, &PINK, &PORTK, 7}   // K7 69
+};
+//------------------------------------------------------------------------------
+#elif (defined(__AVR_ATmega644P__) || defined(__AVR_ATmega1284P__)) && defined(CORE_MICRODUINO)
+// Microduino Core+
+
+// Two Wire (aka I2C) ports
+uint8_t const SDA_PIN = 20;
+uint8_t const SCL_PIN = 21;
+
+// SPI port
+uint8_t const SS_PIN = 10;
+uint8_t const MOSI_PIN = 11;
+uint8_t const MISO_PIN = 12;
+uint8_t const SCK_PIN = 13;
+
+static const pin_map_t digitalPinMap[] = {
+  {&DDRD, &PIND, &PORTD, 0},  // D0 PD0
+  {&DDRD, &PIND, &PORTD, 1},  // D1 PD1
+  {&DDRD, &PIND, &PORTD, 2},  // D2 PD2
+  {&DDRD, &PIND, &PORTD, 3},  // D3 PD3
+  {&DDRB, &PINB, &PORTB, 0},  // D4 PB0
+  {&DDRB, &PINB, &PORTB, 1},  // D5 PB1
+  {&DDRB, &PINB, &PORTB, 2},  // D6 PB2
+  {&DDRB, &PINB, &PORTB, 3},  // D7 PB3
+  {&DDRD, &PIND, &PORTD, 6},  // D8 PD6
+  {&DDRD, &PIND, &PORTD, 5},  // D9 PD5
+  {&DDRB, &PINB, &PORTB, 4},  // D10 PB4
+  {&DDRB, &PINB, &PORTB, 5},  // D11 PB5
+  {&DDRB, &PINB, &PORTB, 6},  // D12 PB6
+  {&DDRB, &PINB, &PORTB, 7},  // D13 PB7
+  {&DDRC, &PINC, &PORTC, 7},  // D14 PC7
+  {&DDRC, &PINC, &PORTC, 6},  // D15 PC6
+  {&DDRC, &PINC, &PORTC, 5},  // D16 PC5
+  {&DDRC, &PINC, &PORTC, 4},  // D17 PC4
+  {&DDRC, &PINC, &PORTC, 3},  // D18 PC3
+  {&DDRC, &PINC, &PORTC, 2},  // D19 PC2
+  {&DDRC, &PINC, &PORTC, 1},  // D20 PC1
+  {&DDRC, &PINC, &PORTC, 0},  // D21 PC0
+  {&DDRD, &PIND, &PORTD, 4},  // D22 PD4
+  {&DDRD, &PIND, &PORTD, 7},  // D23 PD7
+  {&DDRA, &PINA, &PORTA, 7},  // D24 PA7
+  {&DDRA, &PINA, &PORTA, 6},  // D25 PA6
+  {&DDRA, &PINA, &PORTA, 5},  // D26 PA5
+  {&DDRA, &PINA, &PORTA, 4},  // D27 PA4
+  {&DDRA, &PINA, &PORTA, 3},  // D28 PA3
+  {&DDRA, &PINA, &PORTA, 2},  // D29 PA2
+  {&DDRA, &PINA, &PORTA, 1},  // D30 PA1
+  {&DDRA, &PINA, &PORTA, 0}   // D31 PA0
+};
+//------------------------------------------------------------------------------
+#elif defined(__AVR_ATmega128RFA1__) && defined(CORE_MICRODUINO)
+// Microduino Core RF
+
+// Two Wire (aka I2C) ports
+uint8_t const SDA_PIN = 18;
+uint8_t const SCL_PIN = 19;
+
+// SPI port
+uint8_t const SS_PIN = 10;
+uint8_t const MOSI_PIN = 11;
+uint8_t const MISO_PIN = 12;
+uint8_t const SCK_PIN = 13;
+
+static const pin_map_t digitalPinMap[] = {
+  {&DDRD, &PINE, &PORTE, 0},  // D0 PE0
+  {&DDRD, &PINE, &PORTE, 1},  // D1 PE1
+  {&DDRD, &PIND, &PORTD, 2},  // D2 PD2
+  {&DDRD, &PIND, &PORTD, 3},  // D3 PD3
+  {&DDRB, &PINE, &PORTE, 3},  // D4 PE3
+  {&DDRB, &PINE, &PORTE, 4},  // D5 PE4
+  {&DDRB, &PINE, &PORTE, 5},  // D6 PE5
+  {&DDRB, &PINB, &PORTB, 7},  // D7 PB7
+  {&DDRD, &PINB, &PORTB, 6},  // D8 PB6
+  {&DDRD, &PINB, &PORTB, 5},  // D9 PB5
+  {&DDRB, &PINB, &PORTB, 4},  // D10 PB4
+  {&DDRB, &PINB, &PORTB, 2},  // D11 PB2
+  {&DDRB, &PINB, &PORTB, 3},  // D12 PB3
+  {&DDRB, &PINB, &PORTB, 1},  // D13 PB1
+  {&DDRF, &PINF, &PORTF, 7},  // D14 PF7
+  {&DDRF, &PINF, &PORTF, 6},  // D15 PF6
+  {&DDRF, &PINF, &PORTF, 5},  // D16 PF5
+  {&DDRF, &PINF, &PORTF, 4},  // D17 PF4
+  {&DDRD, &PIND, &PORTD, 1},  // D18 PD1
+  {&DDRD, &PIND, &PORTD, 0},  // D19 PD0
+  {&DDRF, &PINF, &PORTF, 3},  // D20 PF3
+  {&DDRF, &PINF, &PORTF, 2},  // D21 PF2
+};
+//------------------------------------------------------------------------------
+#elif defined(__AVR_ATmega32U4__) && defined(CORE_MICRODUINO)
+// Microduino Core USB
+
+// Two Wire (aka I2C) ports
+uint8_t const SDA_PIN = 18;
+uint8_t const SCL_PIN = 19;
+
+// SPI port
+uint8_t const SS_PIN = 10;
+uint8_t const MOSI_PIN = 11;
+uint8_t const MISO_PIN = 12;
+uint8_t const SCK_PIN = 13;
+
+static const pin_map_t digitalPinMap[] = {
+  {&DDRD, &PIND, &PORTD, 2},  // D0 - PD2
+  {&DDRD, &PIND, &PORTD, 3},  // D1 - PD3
+  {&DDRE, &PINE, &PORTE, 6},  // D2 - PE6
+  {&DDRD, &PIND, &PORTD, 6},  // D3 - PD6
+  {&DDRD, &PIND, &PORTD, 7},  // D4 - PD7
+  {&DDRC, &PINC, &PORTC, 6},  // D5 - PC6
+  {&DDRC, &PINC, &PORTC, 7},  // D6 - PC7
+  {&DDRE, &PINE, &PORTE, 7},  // D7 - PE7
+  {&DDRB, &PINB, &PORTB, 6},  // D8 - PB6
+  {&DDRB, &PINB, &PORTB, 5},  // D9 - PB5
+  {&DDRB, &PINB, &PORTB, 0},  // D10 - PB0
+  {&DDRB, &PINB, &PORTB, 2},  // D11 - MOSI - PB2
+  {&DDRB, &PINB, &PORTB, 3},  // D12 -MISO -  PB3
+  {&DDRB, &PINB, &PORTB, 1},  // D13 -SCK -  PB1
+  {&DDRF, &PINF, &PORTF, 7},  // D14 - A0 - PF7
+  {&DDRF, &PINF, &PORTF, 6},  // D15 - A1 - PF6
+  {&DDRF, &PINF, &PORTF, 5},  // D16 - A2 - PF5
+  {&DDRF, &PINF, &PORTF, 4},  // D17 - A3 - PF4
+  {&DDRD, &PIND, &PORTD, 1},  // D18 - PD1
+  {&DDRD, &PIND, &PORTD, 0},  // D19 - PD0
+  {&DDRF, &PINF, &PORTF, 1},  // D20 - A6 - PF1
+  {&DDRF, &PINF, &PORTF, 0},  // D21 - A7 - PF0
+};
+//------------------------------------------------------------------------------
+#elif defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644__)
+// Sanguino
+
+// Two Wire (aka I2C) ports
+uint8_t const SDA_PIN = 17;
+uint8_t const SCL_PIN = 18;
+
+// SPI port
+uint8_t const SS_PIN = 4;
+uint8_t const MOSI_PIN = 5;
+uint8_t const MISO_PIN = 6;
+uint8_t const SCK_PIN = 7;
+
+static const pin_map_t digitalPinMap[] = {
+  {&DDRB, &PINB, &PORTB, 0},  // B0  0
+  {&DDRB, &PINB, &PORTB, 1},  // B1  1
+  {&DDRB, &PINB, &PORTB, 2},  // B2  2
+  {&DDRB, &PINB, &PORTB, 3},  // B3  3
+  {&DDRB, &PINB, &PORTB, 4},  // B4  4
+  {&DDRB, &PINB, &PORTB, 5},  // B5  5
+  {&DDRB, &PINB, &PORTB, 6},  // B6  6
+  {&DDRB, &PINB, &PORTB, 7},  // B7  7
+  {&DDRD, &PIND, &PORTD, 0},  // D0  8
+  {&DDRD, &PIND, &PORTD, 1},  // D1  9
+  {&DDRD, &PIND, &PORTD, 2},  // D2 10
+  {&DDRD, &PIND, &PORTD, 3},  // D3 11
+  {&DDRD, &PIND, &PORTD, 4},  // D4 12
+  {&DDRD, &PIND, &PORTD, 5},  // D5 13
+  {&DDRD, &PIND, &PORTD, 6},  // D6 14
+  {&DDRD, &PIND, &PORTD, 7},  // D7 15
+  {&DDRC, &PINC, &PORTC, 0},  // C0 16
+  {&DDRC, &PINC, &PORTC, 1},  // C1 17
+  {&DDRC, &PINC, &PORTC, 2},  // C2 18
+  {&DDRC, &PINC, &PORTC, 3},  // C3 19
+  {&DDRC, &PINC, &PORTC, 4},  // C4 20
+  {&DDRC, &PINC, &PORTC, 5},  // C5 21
+  {&DDRC, &PINC, &PORTC, 6},  // C6 22
+  {&DDRC, &PINC, &PORTC, 7},  // C7 23
+  {&DDRA, &PINA, &PORTA, 7},  // A7 24
+  {&DDRA, &PINA, &PORTA, 6},  // A6 25
+  {&DDRA, &PINA, &PORTA, 5},  // A5 26
+  {&DDRA, &PINA, &PORTA, 4},  // A4 27
+  {&DDRA, &PINA, &PORTA, 3},  // A3 28
+  {&DDRA, &PINA, &PORTA, 2},  // A2 29
+  {&DDRA, &PINA, &PORTA, 1},  // A1 30
+  {&DDRA, &PINA, &PORTA, 0}   // A0 31
+};
+//------------------------------------------------------------------------------
+#elif defined(__AVR_ATmega32U4__)
+// Leonardo
+
+// Two Wire (aka I2C) ports
+uint8_t const SDA_PIN = 2;
+uint8_t const SCL_PIN = 3;
+
+// SPI port
+uint8_t const SS_PIN = 17;
+uint8_t const MOSI_PIN = 16;
+uint8_t const MISO_PIN = 14;
+uint8_t const SCK_PIN = 15;
+
+static const pin_map_t digitalPinMap[] = {
+  {&DDRD, &PIND, &PORTD, 2},  // D2  0
+  {&DDRD, &PIND, &PORTD, 3},  // D3  1
+  {&DDRD, &PIND, &PORTD, 1},  // D1  2
+  {&DDRD, &PIND, &PORTD, 0},  // D0  3
+  {&DDRD, &PIND, &PORTD, 4},  // D4  4
+  {&DDRC, &PINC, &PORTC, 6},  // C6  5
+  {&DDRD, &PIND, &PORTD, 7},  // D7  6
+  {&DDRE, &PINE, &PORTE, 6},  // E6  7
+  {&DDRB, &PINB, &PORTB, 4},  // B4  8
+  {&DDRB, &PINB, &PORTB, 5},  // B5  9
+  {&DDRB, &PINB, &PORTB, 6},  // B6 10
+  {&DDRB, &PINB, &PORTB, 7},  // B7 11
+  {&DDRD, &PIND, &PORTD, 6},  // D6 12
+  {&DDRC, &PINC, &PORTC, 7},  // C7 13
+  {&DDRB, &PINB, &PORTB, 3},  // B3 14
+  {&DDRB, &PINB, &PORTB, 1},  // B1 15
+  {&DDRB, &PINB, &PORTB, 2},  // B2 16
+  {&DDRB, &PINB, &PORTB, 0},  // B0 17
+  {&DDRF, &PINF, &PORTF, 7},  // F7 18
+  {&DDRF, &PINF, &PORTF, 6},  // F6 19
+  {&DDRF, &PINF, &PORTF, 5},  // F5 20
+  {&DDRF, &PINF, &PORTF, 4},  // F4 21
+  {&DDRF, &PINF, &PORTF, 1},  // F1 22
+  {&DDRF, &PINF, &PORTF, 0},  // F0 23
+};
+//------------------------------------------------------------------------------
+#elif defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB1286__)
+// Teensy++ 1.0 & 2.0
+
+// Two Wire (aka I2C) ports
+uint8_t const SDA_PIN = 1;
+uint8_t const SCL_PIN = 0;
+
+// SPI port
+uint8_t const SS_PIN = 20;
+uint8_t const MOSI_PIN = 22;
+uint8_t const MISO_PIN = 23;
+uint8_t const SCK_PIN = 21;
+
+static const pin_map_t digitalPinMap[] = {
+  {&DDRD, &PIND, &PORTD, 0},  // D0  0
+  {&DDRD, &PIND, &PORTD, 1},  // D1  1
+  {&DDRD, &PIND, &PORTD, 2},  // D2  2
+  {&DDRD, &PIND, &PORTD, 3},  // D3  3
+  {&DDRD, &PIND, &PORTD, 4},  // D4  4
+  {&DDRD, &PIND, &PORTD, 5},  // D5  5
+  {&DDRD, &PIND, &PORTD, 6},  // D6  6
+  {&DDRD, &PIND, &PORTD, 7},  // D7  7
+  {&DDRE, &PINE, &PORTE, 0},  // E0  8
+  {&DDRE, &PINE, &PORTE, 1},  // E1  9
+  {&DDRC, &PINC, &PORTC, 0},  // C0 10
+  {&DDRC, &PINC, &PORTC, 1},  // C1 11
+  {&DDRC, &PINC, &PORTC, 2},  // C2 12
+  {&DDRC, &PINC, &PORTC, 3},  // C3 13
+  {&DDRC, &PINC, &PORTC, 4},  // C4 14
+  {&DDRC, &PINC, &PORTC, 5},  // C5 15
+  {&DDRC, &PINC, &PORTC, 6},  // C6 16
+  {&DDRC, &PINC, &PORTC, 7},  // C7 17
+  {&DDRE, &PINE, &PORTE, 6},  // E6 18
+  {&DDRE, &PINE, &PORTE, 7},  // E7 19
+  {&DDRB, &PINB, &PORTB, 0},  // B0 20
+  {&DDRB, &PINB, &PORTB, 1},  // B1 21
+  {&DDRB, &PINB, &PORTB, 2},  // B2 22
+  {&DDRB, &PINB, &PORTB, 3},  // B3 23
+  {&DDRB, &PINB, &PORTB, 4},  // B4 24
+  {&DDRB, &PINB, &PORTB, 5},  // B5 25
+  {&DDRB, &PINB, &PORTB, 6},  // B6 26
+  {&DDRB, &PINB, &PORTB, 7},  // B7 27
+  {&DDRA, &PINA, &PORTA, 0},  // A0 28
+  {&DDRA, &PINA, &PORTA, 1},  // A1 29
+  {&DDRA, &PINA, &PORTA, 2},  // A2 30
+  {&DDRA, &PINA, &PORTA, 3},  // A3 31
+  {&DDRA, &PINA, &PORTA, 4},  // A4 32
+  {&DDRA, &PINA, &PORTA, 5},  // A5 33
+  {&DDRA, &PINA, &PORTA, 6},  // A6 34
+  {&DDRA, &PINA, &PORTA, 7},  // A7 35
+  {&DDRE, &PINE, &PORTE, 4},  // E4 36
+  {&DDRE, &PINE, &PORTE, 5},  // E5 37
+  {&DDRF, &PINF, &PORTF, 0},  // F0 38
+  {&DDRF, &PINF, &PORTF, 1},  // F1 39
+  {&DDRF, &PINF, &PORTF, 2},  // F2 40
+  {&DDRF, &PINF, &PORTF, 3},  // F3 41
+  {&DDRF, &PINF, &PORTF, 4},  // F4 42
+  {&DDRF, &PINF, &PORTF, 5},  // F5 43
+  {&DDRF, &PINF, &PORTF, 6},  // F6 44
+  {&DDRF, &PINF, &PORTF, 7}   // F7 45
+};
+//------------------------------------------------------------------------------
+#else  // defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
+// 168 and 328 Arduinos
+
+// Two Wire (aka I2C) ports
+uint8_t const SDA_PIN = 18;
+uint8_t const SCL_PIN = 19;
+
+// SPI port
+uint8_t const SS_PIN = 10;
+uint8_t const MOSI_PIN = 11;
+uint8_t const MISO_PIN = 12;
+uint8_t const SCK_PIN = 13;
+
+static const pin_map_t digitalPinMap[] = {
+  {&DDRD, &PIND, &PORTD, 0},  // D0  0
+  {&DDRD, &PIND, &PORTD, 1},  // D1  1
+  {&DDRD, &PIND, &PORTD, 2},  // D2  2
+  {&DDRD, &PIND, &PORTD, 3},  // D3  3
+  {&DDRD, &PIND, &PORTD, 4},  // D4  4
+  {&DDRD, &PIND, &PORTD, 5},  // D5  5
+  {&DDRD, &PIND, &PORTD, 6},  // D6  6
+  {&DDRD, &PIND, &PORTD, 7},  // D7  7
+  {&DDRB, &PINB, &PORTB, 0},  // B0  8
+  {&DDRB, &PINB, &PORTB, 1},  // B1  9
+  {&DDRB, &PINB, &PORTB, 2},  // B2 10
+  {&DDRB, &PINB, &PORTB, 3},  // B3 11
+  {&DDRB, &PINB, &PORTB, 4},  // B4 12
+  {&DDRB, &PINB, &PORTB, 5},  // B5 13
+  {&DDRC, &PINC, &PORTC, 0},  // C0 14
+  {&DDRC, &PINC, &PORTC, 1},  // C1 15
+  {&DDRC, &PINC, &PORTC, 2},  // C2 16
+  {&DDRC, &PINC, &PORTC, 3},  // C3 17
+  {&DDRC, &PINC, &PORTC, 4},  // C4 18
+  {&DDRC, &PINC, &PORTC, 5}   // C5 19
+};
+#endif  // defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
+//------------------------------------------------------------------------------
+static const uint8_t digitalPinCount = sizeof(digitalPinMap) / sizeof(pin_map_t);
+
+uint8_t badPinNumber(void)
+__attribute__((error("Pin number is too large or not a constant")));
+
+static inline __attribute__((always_inline))
+uint8_t getPinMode(uint8_t pin) {
+  if (__builtin_constant_p(pin) && pin < digitalPinCount) {
+    return (*digitalPinMap[pin].ddr >> digitalPinMap[pin].bit) & 1;
+  } else {
+    return badPinNumber();
+  }
+}
+static inline __attribute__((always_inline))
+void setPinMode(uint8_t pin, uint8_t mode) {
+  if (__builtin_constant_p(pin) && pin < digitalPinCount) {
+    if (mode) {
+      *digitalPinMap[pin].ddr |= 1 << digitalPinMap[pin].bit;
+    } else {
+      *digitalPinMap[pin].ddr &= ~(1 << digitalPinMap[pin].bit);
+    }
+  } else {
+    badPinNumber();
+  }
+}
+static inline __attribute__((always_inline))
+uint8_t fastDigitalRead(uint8_t pin) {
+  if (__builtin_constant_p(pin) && pin < digitalPinCount) {
+    return (*digitalPinMap[pin].pin >> digitalPinMap[pin].bit) & 1;
+  } else {
+    return badPinNumber();
+  }
+}
+static inline __attribute__((always_inline))
+void fastDigitalWrite(uint8_t pin, uint8_t value) {
+  if (__builtin_constant_p(pin) && pin < digitalPinCount) {
+    if (value) {
+      *digitalPinMap[pin].port |= 1 << digitalPinMap[pin].bit;
+    } else {
+      *digitalPinMap[pin].port &= ~(1 << digitalPinMap[pin].bit);
+    }
+  } else {
+    badPinNumber();
+  }
+}
+#endif  // Sd2PinMap_h
+
+#elif defined (__CPU_ARC__)
+
+#if defined (__ARDUINO_ARC__)
+  // Two Wire (aka I2C) ports
+  uint8_t const SDA_PIN = 18;
+  uint8_t const SCL_PIN = 19;
+
+  // SPI port
+  uint8_t const SS_PIN = 10;
+  uint8_t const MOSI_PIN = 11;
+  uint8_t const MISO_PIN = 12;
+  uint8_t const SCK_PIN = 13;
+
+#endif	// Arduino ARC
+
+#else
+#error Architecture or board not supported.
+#endif
diff --git a/libraries/SD/src/utility/SdFat.h b/libraries/SD/src/utility/SdFat.h
new file mode 100755
index 0000000..e57974d
--- /dev/null
+++ b/libraries/SD/src/utility/SdFat.h
@@ -0,0 +1,641 @@
+/* Arduino SdFat Library
+   Copyright (C) 2009 by William Greiman
+
+   This file is part of the Arduino SdFat Library
+
+   This Library is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with the Arduino SdFat Library.  If not, see
+   <http://www.gnu.org/licenses/>.
+*/
+#ifndef SdFat_h
+#define SdFat_h
+/**
+   \file
+   SdFile and SdVolume classes
+*/
+#if defined (__AVR__) || defined (__CPU_ARC__)
+  #include <avr/pgmspace.h>
+#endif
+#include "Sd2Card.h"
+#include "FatStructs.h"
+#include <Print.h>
+//------------------------------------------------------------------------------
+/**
+   Allow use of deprecated functions if non-zero
+*/
+#define ALLOW_DEPRECATED_FUNCTIONS 1
+//------------------------------------------------------------------------------
+// forward declaration since SdVolume is used in SdFile
+class SdVolume;
+//==============================================================================
+// SdFile class
+
+#ifdef O_RDONLY //ARDUINO_ARCH_MBED
+#undef O_READ
+#undef O_RDONLY
+#undef O_WRITE
+#undef O_WRONLY
+#undef O_RDWR
+#undef O_ACCMODE
+#undef O_APPEND
+#undef O_SYNC
+#undef O_CREAT
+#undef O_EXCL
+#undef O_TRUNC
+#endif
+
+// flags for ls()
+/** ls() flag to print modify date */
+uint8_t const LS_DATE = 1;
+/** ls() flag to print file size */
+uint8_t const LS_SIZE = 2;
+/** ls() flag for recursive list of subdirectories */
+uint8_t const LS_R = 4;
+
+// use the gnu style oflag in open()
+/** open() oflag for reading */
+uint8_t const O_READ = 0X01;
+/** open() oflag - same as O_READ */
+uint8_t const O_RDONLY = O_READ;
+/** open() oflag for write */
+uint8_t const O_WRITE = 0X02;
+/** open() oflag - same as O_WRITE */
+uint8_t const O_WRONLY = O_WRITE;
+/** open() oflag for reading and writing */
+uint8_t const O_RDWR = (O_READ | O_WRITE);
+/** open() oflag mask for access modes */
+uint8_t const O_ACCMODE = (O_READ | O_WRITE);
+/** The file offset shall be set to the end of the file prior to each write. */
+uint8_t const O_APPEND = 0X04;
+/** synchronous writes - call sync() after each write */
+uint8_t const O_SYNC = 0X08;
+/** create the file if nonexistent */
+uint8_t const O_CREAT = 0X10;
+/** If O_CREAT and O_EXCL are set, open() shall fail if the file exists */
+uint8_t const O_EXCL = 0X20;
+/** truncate the file to zero length */
+uint8_t const O_TRUNC = 0X40;
+
+// flags for timestamp
+/** set the file's last access date */
+uint8_t const T_ACCESS = 1;
+/** set the file's creation date and time */
+uint8_t const T_CREATE = 2;
+/** Set the file's write date and time */
+uint8_t const T_WRITE = 4;
+// values for type_
+/** This SdFile has not been opened. */
+uint8_t const FAT_FILE_TYPE_CLOSED = 0;
+/** SdFile for a file */
+uint8_t const FAT_FILE_TYPE_NORMAL = 1;
+/** SdFile for a FAT16 root directory */
+uint8_t const FAT_FILE_TYPE_ROOT16 = 2;
+/** SdFile for a FAT32 root directory */
+uint8_t const FAT_FILE_TYPE_ROOT32 = 3;
+/** SdFile for a subdirectory */
+uint8_t const FAT_FILE_TYPE_SUBDIR = 4;
+/** Test value for directory type */
+uint8_t const FAT_FILE_TYPE_MIN_DIR = FAT_FILE_TYPE_ROOT16;
+
+/** date field for FAT directory entry */
+static inline uint16_t FAT_DATE(uint16_t year, uint8_t month, uint8_t day) {
+  return (year - 1980) << 9 | month << 5 | day;
+}
+/** year part of FAT directory date field */
+static inline uint16_t FAT_YEAR(uint16_t fatDate) {
+  return 1980 + (fatDate >> 9);
+}
+/** month part of FAT directory date field */
+static inline uint8_t FAT_MONTH(uint16_t fatDate) {
+  return (fatDate >> 5) & 0XF;
+}
+/** day part of FAT directory date field */
+static inline uint8_t FAT_DAY(uint16_t fatDate) {
+  return fatDate & 0X1F;
+}
+/** time field for FAT directory entry */
+static inline uint16_t FAT_TIME(uint8_t hour, uint8_t minute, uint8_t second) {
+  return hour << 11 | minute << 5 | second >> 1;
+}
+/** hour part of FAT directory time field */
+static inline uint8_t FAT_HOUR(uint16_t fatTime) {
+  return fatTime >> 11;
+}
+/** minute part of FAT directory time field */
+static inline uint8_t FAT_MINUTE(uint16_t fatTime) {
+  return (fatTime >> 5) & 0X3F;
+}
+/** second part of FAT directory time field */
+static inline uint8_t FAT_SECOND(uint16_t fatTime) {
+  return 2 * (fatTime & 0X1F);
+}
+/** Default date for file timestamps is 1 Jan 2000 */
+uint16_t const FAT_DEFAULT_DATE = ((2000 - 1980) << 9) | (1 << 5) | 1;
+/** Default time for file timestamp is 1 am */
+uint16_t const FAT_DEFAULT_TIME = (1 << 11);
+//------------------------------------------------------------------------------
+/**
+   \class SdFile
+   \brief Access FAT16 and FAT32 files on SD and SDHC cards.
+*/
+class SdFile : public Print {
+  public:
+    /** Create an instance of SdFile. */
+    SdFile(void) : type_(FAT_FILE_TYPE_CLOSED) {}
+    /**
+       writeError is set to true if an error occurs during a write().
+       Set writeError to false before calling print() and/or write() and check
+       for true after calls to print() and/or write().
+    */
+    //bool writeError;
+    /**
+       Cancel unbuffered reads for this file.
+       See setUnbufferedRead()
+    */
+    void clearUnbufferedRead(void) {
+      flags_ &= ~F_FILE_UNBUFFERED_READ;
+    }
+    uint8_t close(void);
+    uint8_t contiguousRange(uint32_t* bgnBlock, uint32_t* endBlock);
+    uint8_t createContiguous(SdFile* dirFile,
+                             const char* fileName, uint32_t size);
+    /** \return The current cluster number for a file or directory. */
+    uint32_t curCluster(void) const {
+      return curCluster_;
+    }
+    /** \return The current position for a file or directory. */
+    uint32_t curPosition(void) const {
+      return curPosition_;
+    }
+    /**
+       Set the date/time callback function
+
+       \param[in] dateTime The user's call back function.  The callback
+       function is of the form:
+
+       \code
+       void dateTime(uint16_t* date, uint16_t* time) {
+         uint16_t year;
+         uint8_t month, day, hour, minute, second;
+
+         // User gets date and time from GPS or real-time clock here
+
+         // return date using FAT_DATE macro to format fields
+     *   *date = FAT_DATE(year, month, day);
+
+         // return time using FAT_TIME macro to format fields
+     *   *time = FAT_TIME(hour, minute, second);
+       }
+       \endcode
+
+       Sets the function that is called when a file is created or when
+       a file's directory entry is modified by sync(). All timestamps,
+       access, creation, and modify, are set when a file is created.
+       sync() maintains the last access date and last modify date/time.
+
+       See the timestamp() function.
+    */
+    static void dateTimeCallback(
+      void (*dateTime)(uint16_t* date, uint16_t* time)) {
+      dateTime_ = dateTime;
+    }
+    /**
+       Cancel the date/time callback function.
+    */
+    static void dateTimeCallbackCancel(void) {
+      // use explicit zero since NULL is not defined for Sanguino
+      dateTime_ = 0;
+    }
+    /** \return Address of the block that contains this file's directory. */
+    uint32_t dirBlock(void) const {
+      return dirBlock_;
+    }
+    uint8_t dirEntry(dir_t* dir);
+    /** \return Index of this file's directory in the block dirBlock. */
+    uint8_t dirIndex(void) const {
+      return dirIndex_;
+    }
+    static void dirName(const dir_t& dir, char* name);
+    /** \return The total number of bytes in a file or directory. */
+    uint32_t fileSize(void) const {
+      return fileSize_;
+    }
+    /** \return The first cluster number for a file or directory. */
+    uint32_t firstCluster(void) const {
+      return firstCluster_;
+    }
+    /** \return True if this is a SdFile for a directory else false. */
+    uint8_t isDir(void) const {
+      return type_ >= FAT_FILE_TYPE_MIN_DIR;
+    }
+    /** \return True if this is a SdFile for a file else false. */
+    uint8_t isFile(void) const {
+      return type_ == FAT_FILE_TYPE_NORMAL;
+    }
+    /** \return True if this is a SdFile for an open file/directory else false. */
+    uint8_t isOpen(void) const {
+      return type_ != FAT_FILE_TYPE_CLOSED;
+    }
+    /** \return True if this is a SdFile for a subdirectory else false. */
+    uint8_t isSubDir(void) const {
+      return type_ == FAT_FILE_TYPE_SUBDIR;
+    }
+    /** \return True if this is a SdFile for the root directory. */
+    uint8_t isRoot(void) const {
+      return type_ == FAT_FILE_TYPE_ROOT16 || type_ == FAT_FILE_TYPE_ROOT32;
+    }
+    void ls(uint8_t flags = 0, uint8_t indent = 0);
+    uint8_t makeDir(SdFile* dir, const char* dirName);
+    uint8_t open(SdFile* dirFile, uint16_t index, uint8_t oflag);
+    uint8_t open(SdFile* dirFile, const char* fileName, uint8_t oflag);
+
+    uint8_t openRoot(SdVolume* vol);
+    static void printDirName(const dir_t& dir, uint8_t width);
+    static void printFatDate(uint16_t fatDate);
+    static void printFatTime(uint16_t fatTime);
+    static void printTwoDigits(uint8_t v);
+    /**
+       Read the next byte from a file.
+
+       \return For success read returns the next byte in the file as an int.
+       If an error occurs or end of file is reached -1 is returned.
+    */
+    int16_t read(void) {
+      uint8_t b;
+      return read(&b, 1) == 1 ? b : -1;
+    }
+    int16_t read(void* buf, uint16_t nbyte);
+    int8_t readDir(dir_t* dir);
+    static uint8_t remove(SdFile* dirFile, const char* fileName);
+    uint8_t remove(void);
+    /** Set the file's current position to zero. */
+    void rewind(void) {
+      curPosition_ = curCluster_ = 0;
+    }
+    uint8_t rmDir(void);
+    uint8_t rmRfStar(void);
+    /** Set the files position to current position + \a pos. See seekSet(). */
+    uint8_t seekCur(uint32_t pos) {
+      return seekSet(curPosition_ + pos);
+    }
+    /**
+        Set the files current position to end of file.  Useful to position
+        a file for append. See seekSet().
+    */
+    uint8_t seekEnd(void) {
+      return seekSet(fileSize_);
+    }
+    uint8_t seekSet(uint32_t pos);
+    /**
+       Use unbuffered reads to access this file.  Used with Wave
+       Shield ISR.  Used with Sd2Card::partialBlockRead() in WaveRP.
+
+       Not recommended for normal applications.
+    */
+    void setUnbufferedRead(void) {
+      if (isFile()) {
+        flags_ |= F_FILE_UNBUFFERED_READ;
+      }
+    }
+    uint8_t timestamp(uint8_t flag, uint16_t year, uint8_t month, uint8_t day,
+                      uint8_t hour, uint8_t minute, uint8_t second);
+    uint8_t sync(uint8_t blocking = 1);
+    /** Type of this SdFile.  You should use isFile() or isDir() instead of type()
+       if possible.
+
+       \return The file or directory type.
+    */
+    uint8_t type(void) const {
+      return type_;
+    }
+    uint8_t truncate(uint32_t size);
+    /** \return Unbuffered read flag. */
+    uint8_t unbufferedRead(void) const {
+      return flags_ & F_FILE_UNBUFFERED_READ;
+    }
+    /** \return SdVolume that contains this file. */
+    SdVolume* volume(void) const {
+      return vol_;
+    }
+    size_t write(uint8_t b);
+    size_t write(const void* buf, uint16_t nbyte);
+    size_t write(const char* str);
+    #ifdef __AVR__
+    void write_P(PGM_P str);
+    void writeln_P(PGM_P str);
+    #endif
+    int availableForWrite(void);
+    //------------------------------------------------------------------------------
+    #if ALLOW_DEPRECATED_FUNCTIONS
+    // Deprecated functions  - suppress cpplint warnings with NOLINT comment
+    /** \deprecated Use:
+       uint8_t SdFile::contiguousRange(uint32_t* bgnBlock, uint32_t* endBlock);
+    */
+    uint8_t contiguousRange(uint32_t& bgnBlock, uint32_t& endBlock) {  // NOLINT
+      return contiguousRange(&bgnBlock, &endBlock);
+    }
+    /** \deprecated Use:
+        uint8_t SdFile::createContiguous(SdFile* dirFile,
+          const char* fileName, uint32_t size)
+    */
+    uint8_t createContiguous(SdFile& dirFile,  // NOLINT
+                             const char* fileName, uint32_t size) {
+      return createContiguous(&dirFile, fileName, size);
+    }
+
+    /**
+       \deprecated Use:
+       static void SdFile::dateTimeCallback(
+         void (*dateTime)(uint16_t* date, uint16_t* time));
+    */
+    static void dateTimeCallback(
+      void (*dateTime)(uint16_t& date, uint16_t& time)) {  // NOLINT
+      oldDateTime_ = dateTime;
+      dateTime_ = dateTime ? oldToNew : 0;
+    }
+    /** \deprecated Use: uint8_t SdFile::dirEntry(dir_t* dir); */
+    uint8_t dirEntry(dir_t& dir) {
+      return dirEntry(&dir); // NOLINT
+    }
+    /** \deprecated Use:
+       uint8_t SdFile::makeDir(SdFile* dir, const char* dirName);
+    */
+    uint8_t makeDir(SdFile& dir, const char* dirName) {  // NOLINT
+      return makeDir(&dir, dirName);
+    }
+    /** \deprecated Use:
+       uint8_t SdFile::open(SdFile* dirFile, const char* fileName, uint8_t oflag);
+    */
+    uint8_t open(SdFile& dirFile, // NOLINT
+                 const char* fileName, uint8_t oflag) {
+      return open(&dirFile, fileName, oflag);
+    }
+    /** \deprecated  Do not use in new apps */
+    uint8_t open(SdFile& dirFile, const char* fileName) {  // NOLINT
+      return open(dirFile, fileName, O_RDWR);
+    }
+    /** \deprecated Use:
+       uint8_t SdFile::open(SdFile* dirFile, uint16_t index, uint8_t oflag);
+    */
+    uint8_t open(SdFile& dirFile, uint16_t index, uint8_t oflag) {  // NOLINT
+      return open(&dirFile, index, oflag);
+    }
+    /** \deprecated Use: uint8_t SdFile::openRoot(SdVolume* vol); */
+    uint8_t openRoot(SdVolume& vol) {
+      return openRoot(&vol); // NOLINT
+    }
+
+    /** \deprecated Use: int8_t SdFile::readDir(dir_t* dir); */
+    int8_t readDir(dir_t& dir) {
+      return readDir(&dir); // NOLINT
+    }
+    /** \deprecated Use:
+       static uint8_t SdFile::remove(SdFile* dirFile, const char* fileName);
+    */
+    static uint8_t remove(SdFile& dirFile, const char* fileName) {  // NOLINT
+      return remove(&dirFile, fileName);
+    }
+    //------------------------------------------------------------------------------
+    // rest are private
+  private:
+    static void (*oldDateTime_)(uint16_t& date, uint16_t& time);  // NOLINT
+    static void oldToNew(uint16_t* date, uint16_t* time) {
+      uint16_t d;
+      uint16_t t;
+      oldDateTime_(d, t);
+      *date = d;
+      *time = t;
+    }
+    #endif  // ALLOW_DEPRECATED_FUNCTIONS
+  private:
+    // bits defined in flags_
+    // should be 0XF
+    static uint8_t const F_OFLAG = (O_ACCMODE | O_APPEND | O_SYNC);
+    // available bits
+    static uint8_t const F_FILE_NON_BLOCKING_WRITE = 0X10;
+    // a new cluster was added to the file
+    static uint8_t const F_FILE_CLUSTER_ADDED = 0X20;
+    // use unbuffered SD read
+    static uint8_t const F_FILE_UNBUFFERED_READ = 0X40;
+    // sync of directory entry required
+    static uint8_t const F_FILE_DIR_DIRTY = 0X80;
+
+    // make sure F_OFLAG is ok
+    #if ((F_FILE_NON_BLOCKING_WRITE | F_FILE_CLUSTER_ADDED | F_FILE_UNBUFFERED_READ | F_FILE_DIR_DIRTY) & F_OFLAG)
+#error flags_ bits conflict
+    #endif  // flags_ bits
+
+    // private data
+    uint8_t   flags_;         // See above for definition of flags_ bits
+    uint8_t   type_;          // type of file see above for values
+    uint32_t  curCluster_;    // cluster for current file position
+    uint32_t  curPosition_;   // current file position in bytes from beginning
+    uint32_t  dirBlock_;      // SD block that contains directory entry for file
+    uint8_t   dirIndex_;      // index of entry in dirBlock 0 <= dirIndex_ <= 0XF
+    uint32_t  fileSize_;      // file size in bytes
+    uint32_t  firstCluster_;  // first cluster of file
+    SdVolume* vol_;           // volume where file is located
+
+    // private functions
+    uint8_t addCluster(void);
+    uint8_t addDirCluster(void);
+    dir_t* cacheDirEntry(uint8_t action);
+    static void (*dateTime_)(uint16_t* date, uint16_t* time);
+    static uint8_t make83Name(const char* str, uint8_t* name);
+    uint8_t openCachedEntry(uint8_t cacheIndex, uint8_t oflags);
+    dir_t* readDirCache(void);
+};
+//==============================================================================
+// SdVolume class
+/**
+   \brief Cache for an SD data block
+*/
+union cache_t {
+  /** Used to access cached file data blocks. */
+  uint8_t  data[512];
+  /** Used to access cached FAT16 entries. */
+  uint16_t fat16[256];
+  /** Used to access cached FAT32 entries. */
+  uint32_t fat32[128];
+  /** Used to access cached directory entries. */
+  dir_t    dir[16];
+  /** Used to access a cached MasterBoot Record. */
+  mbr_t    mbr;
+  /** Used to access to a cached FAT boot sector. */
+  fbs_t    fbs;
+};
+//------------------------------------------------------------------------------
+/**
+   \class SdVolume
+   \brief Access FAT16 and FAT32 volumes on SD and SDHC cards.
+*/
+class SdVolume {
+  public:
+    /** Create an instance of SdVolume */
+    SdVolume(void) : allocSearchStart_(2), fatType_(0) {}
+    /** Clear the cache and returns a pointer to the cache.  Used by the WaveRP
+        recorder to do raw write to the SD card.  Not for normal apps.
+    */
+    static uint8_t* cacheClear(void) {
+      cacheFlush();
+      cacheBlockNumber_ = 0XFFFFFFFF;
+      return cacheBuffer_.data;
+    }
+    /**
+       Initialize a FAT volume.  Try partition one first then try super
+       floppy format.
+
+       \param[in] dev The Sd2Card where the volume is located.
+
+       \return The value one, true, is returned for success and
+       the value zero, false, is returned for failure.  Reasons for
+       failure include not finding a valid partition, not finding a valid
+       FAT file system or an I/O error.
+    */
+    uint8_t init(Sd2Card* dev) {
+      return init(dev, 1) ? true : init(dev, 0);
+    }
+    uint8_t init(Sd2Card* dev, uint8_t part);
+
+    // inline functions that return volume info
+    /** \return The volume's cluster size in blocks. */
+    uint8_t blocksPerCluster(void) const {
+      return blocksPerCluster_;
+    }
+    /** \return The number of blocks in one FAT. */
+    uint32_t blocksPerFat(void)  const {
+      return blocksPerFat_;
+    }
+    /** \return The total number of clusters in the volume. */
+    uint32_t clusterCount(void) const {
+      return clusterCount_;
+    }
+    /** \return The shift count required to multiply by blocksPerCluster. */
+    uint8_t clusterSizeShift(void) const {
+      return clusterSizeShift_;
+    }
+    /** \return The logical block number for the start of file data. */
+    uint32_t dataStartBlock(void) const {
+      return dataStartBlock_;
+    }
+    /** \return The number of FAT structures on the volume. */
+    uint8_t fatCount(void) const {
+      return fatCount_;
+    }
+    /** \return The logical block number for the start of the first FAT. */
+    uint32_t fatStartBlock(void) const {
+      return fatStartBlock_;
+    }
+    /** \return The FAT type of the volume. Values are 12, 16 or 32. */
+    uint8_t fatType(void) const {
+      return fatType_;
+    }
+    /** \return The number of entries in the root directory for FAT16 volumes. */
+    uint32_t rootDirEntryCount(void) const {
+      return rootDirEntryCount_;
+    }
+    /** \return The logical block number for the start of the root directory
+         on FAT16 volumes or the first cluster number on FAT32 volumes. */
+    uint32_t rootDirStart(void) const {
+      return rootDirStart_;
+    }
+    /** return a pointer to the Sd2Card object for this volume */
+    static Sd2Card* sdCard(void) {
+      return sdCard_;
+    }
+    //------------------------------------------------------------------------------
+    #if ALLOW_DEPRECATED_FUNCTIONS
+    // Deprecated functions  - suppress cpplint warnings with NOLINT comment
+    /** \deprecated Use: uint8_t SdVolume::init(Sd2Card* dev); */
+    uint8_t init(Sd2Card& dev) {
+      return init(&dev); // NOLINT
+    }
+
+    /** \deprecated Use: uint8_t SdVolume::init(Sd2Card* dev, uint8_t vol); */
+    uint8_t init(Sd2Card& dev, uint8_t part) {  // NOLINT
+      return init(&dev, part);
+    }
+    #endif  // ALLOW_DEPRECATED_FUNCTIONS
+    //------------------------------------------------------------------------------
+  private:
+    // Allow SdFile access to SdVolume private data.
+    friend class SdFile;
+
+    // value for action argument in cacheRawBlock to indicate read from cache
+    static uint8_t const CACHE_FOR_READ = 0;
+    // value for action argument in cacheRawBlock to indicate cache dirty
+    static uint8_t const CACHE_FOR_WRITE = 1;
+
+    static cache_t cacheBuffer_;        // 512 byte cache for device blocks
+    static uint32_t cacheBlockNumber_;  // Logical number of block in the cache
+    static Sd2Card* sdCard_;            // Sd2Card object for cache
+    static uint8_t cacheDirty_;         // cacheFlush() will write block if true
+    static uint32_t cacheMirrorBlock_;  // block number for mirror FAT
+    //
+    uint32_t allocSearchStart_;   // start cluster for alloc search
+    uint8_t blocksPerCluster_;    // cluster size in blocks
+    uint32_t blocksPerFat_;       // FAT size in blocks
+    uint32_t clusterCount_;       // clusters in one FAT
+    uint8_t clusterSizeShift_;    // shift to convert cluster count to block count
+    uint32_t dataStartBlock_;     // first data block number
+    uint8_t fatCount_;            // number of FATs on volume
+    uint32_t fatStartBlock_;      // start block for first FAT
+    uint8_t fatType_;             // volume type (12, 16, OR 32)
+    uint16_t rootDirEntryCount_;  // number of entries in FAT16 root dir
+    uint32_t rootDirStart_;       // root start block for FAT16, cluster for FAT32
+    //----------------------------------------------------------------------------
+    uint8_t allocContiguous(uint32_t count, uint32_t* curCluster);
+    uint8_t blockOfCluster(uint32_t position) const {
+      return (position >> 9) & (blocksPerCluster_ - 1);
+    }
+    uint32_t clusterStartBlock(uint32_t cluster) const {
+      return dataStartBlock_ + ((cluster - 2) << clusterSizeShift_);
+    }
+    uint32_t blockNumber(uint32_t cluster, uint32_t position) const {
+      return clusterStartBlock(cluster) + blockOfCluster(position);
+    }
+    static uint8_t cacheFlush(uint8_t blocking = 1);
+    static uint8_t cacheMirrorBlockFlush(uint8_t blocking);
+    static uint8_t cacheRawBlock(uint32_t blockNumber, uint8_t action);
+    static void cacheSetDirty(void) {
+      cacheDirty_ |= CACHE_FOR_WRITE;
+    }
+    static uint8_t cacheZeroBlock(uint32_t blockNumber);
+    uint8_t chainSize(uint32_t beginCluster, uint32_t* size) const;
+    uint8_t fatGet(uint32_t cluster, uint32_t* value) const;
+    uint8_t fatPut(uint32_t cluster, uint32_t value);
+    uint8_t fatPutEOC(uint32_t cluster) {
+      return fatPut(cluster, 0x0FFFFFFF);
+    }
+    uint8_t freeChain(uint32_t cluster);
+    uint8_t isEOC(uint32_t cluster) const {
+      return  cluster >= (fatType_ == 16 ? FAT16EOC_MIN : FAT32EOC_MIN);
+    }
+    uint8_t readBlock(uint32_t block, uint8_t* dst) {
+      return sdCard_->readBlock(block, dst);
+    }
+    uint8_t readData(uint32_t block, uint16_t offset,
+                     uint16_t count, uint8_t* dst) {
+      return sdCard_->readData(block, offset, count, dst);
+    }
+    uint8_t writeBlock(uint32_t block, const uint8_t* dst, uint8_t blocking = 1) {
+      return sdCard_->writeBlock(block, dst, blocking);
+    }
+    uint8_t isBusy(void) {
+      return sdCard_->isBusy();
+    }
+    uint8_t isCacheMirrorBlockDirty(void) {
+      return (cacheMirrorBlock_ != 0);
+    }
+};
+#endif  // SdFat_h
diff --git a/libraries/SD/src/utility/SdFatUtil.h b/libraries/SD/src/utility/SdFatUtil.h
new file mode 100755
index 0000000..4b93de8
--- /dev/null
+++ b/libraries/SD/src/utility/SdFatUtil.h
@@ -0,0 +1,77 @@
+/* Arduino SdFat Library
+   Copyright (C) 2008 by William Greiman
+
+   This file is part of the Arduino SdFat Library
+
+   This Library is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with the Arduino SdFat Library.  If not, see
+   <http://www.gnu.org/licenses/>.
+*/
+#ifndef SdFatUtil_h
+#define SdFatUtil_h
+/**
+   \file
+   Useful utility functions.
+*/
+#include <Arduino.h>
+#ifdef __AVR__
+  #include <avr/pgmspace.h>
+  /** Store and print a string in flash memory.*/
+  #define PgmPrint(x) SerialPrint_P(PSTR(x))
+  /** Store and print a string in flash memory followed by a CR/LF.*/
+  #define PgmPrintln(x) SerialPrintln_P(PSTR(x))
+  /** Defined so doxygen works for function definitions. */
+#endif
+#define NOINLINE __attribute__((noinline,unused))
+#define UNUSEDOK __attribute__((unused))
+//------------------------------------------------------------------------------
+/** Return the number of bytes currently free in RAM. */
+static UNUSEDOK int FreeRam(void) {
+  extern int  __bss_end;
+  extern int* __brkval;
+  int free_memory;
+  if (reinterpret_cast<int>(__brkval) == 0) {
+    // if no heap use from end of bss section
+    free_memory = reinterpret_cast<int>(&free_memory)
+                  - reinterpret_cast<int>(&__bss_end);
+  } else {
+    // use from top of stack to heap
+    free_memory = reinterpret_cast<int>(&free_memory)
+                  - reinterpret_cast<int>(__brkval);
+  }
+  return free_memory;
+}
+#ifdef __AVR__
+//------------------------------------------------------------------------------
+/**
+   %Print a string in flash memory to the serial port.
+
+   \param[in] str Pointer to string stored in flash memory.
+*/
+static NOINLINE void SerialPrint_P(PGM_P str) {
+  for (uint8_t c; (c = pgm_read_byte(str)); str++) {
+    Serial.write(c);
+  }
+}
+//------------------------------------------------------------------------------
+/**
+   %Print a string in flash memory followed by a CR/LF.
+
+   \param[in] str Pointer to string stored in flash memory.
+*/
+static NOINLINE void SerialPrintln_P(PGM_P str) {
+  SerialPrint_P(str);
+  Serial.println();
+}
+#endif  // __AVR__
+#endif  // #define SdFatUtil_h
diff --git a/libraries/SD/src/utility/SdFatmainpage.h b/libraries/SD/src/utility/SdFatmainpage.h
new file mode 100755
index 0000000..1e6d96f
--- /dev/null
+++ b/libraries/SD/src/utility/SdFatmainpage.h
@@ -0,0 +1,202 @@
+/* Arduino SdFat Library
+   Copyright (C) 2009 by William Greiman
+
+   This file is part of the Arduino SdFat Library
+
+   This Library is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with the Arduino SdFat Library.  If not, see
+   <http://www.gnu.org/licenses/>.
+*/
+
+/**
+  \mainpage Arduino SdFat Library
+  <CENTER>Copyright &copy; 2009 by William Greiman
+  </CENTER>
+
+  \section Intro Introduction
+  The Arduino SdFat Library is a minimal implementation of FAT16 and FAT32
+  file systems on SD flash memory cards.  Standard SD and high capacity
+  SDHC cards are supported.
+
+  The SdFat only supports short 8.3 names.
+
+  The main classes in SdFat are Sd2Card, SdVolume, and SdFile.
+
+  The Sd2Card class supports access to standard SD cards and SDHC cards.  Most
+  applications will only need to call the Sd2Card::init() member function.
+
+  The SdVolume class supports FAT16 and FAT32 partitions.  Most applications
+  will only need to call the SdVolume::init() member function.
+
+  The SdFile class provides file access functions such as open(), read(),
+  remove(), write(), close() and sync(). This class supports access to the root
+  directory and subdirectories.
+
+  A number of example are provided in the SdFat/examples folder.  These were
+  developed to test SdFat and illustrate its use.
+
+  SdFat was developed for high speed data recording.  SdFat was used to implement
+  an audio record/play class, WaveRP, for the Adafruit Wave Shield.  This
+  application uses special Sd2Card calls to write to contiguous files in raw mode.
+  These functions reduce write latency so that audio can be recorded with the
+  small amount of RAM in the Arduino.
+
+  \section SDcard SD\SDHC Cards
+
+  Arduinos access SD cards using the cards SPI protocol.  PCs, Macs, and
+  most consumer devices use the 4-bit parallel SD protocol.  A card that
+  functions well on A PC or Mac may not work well on the Arduino.
+
+  Most cards have good SPI read performance but cards vary widely in SPI
+  write performance.  Write performance is limited by how efficiently the
+  card manages internal erase/remapping operations.  The Arduino cannot
+  optimize writes to reduce erase operations because of its limit RAM.
+
+  SanDisk cards generally have good write performance.  They seem to have
+  more internal RAM buffering than other cards and therefore can limit
+  the number of flash erase operations that the Arduino forces due to its
+  limited RAM.
+
+  \section Hardware Hardware Configuration
+
+  SdFat was developed using an
+  <A HREF = "http://www.adafruit.com/"> Adafruit Industries</A>
+  <A HREF = "http://www.ladyada.net/make/waveshield/"> Wave Shield</A>.
+
+  The hardware interface to the SD card should not use a resistor based level
+  shifter.  SdFat sets the SPI bus frequency to 8 MHz which results in signal
+  rise times that are too slow for the edge detectors in many newer SD card
+  controllers when resistor voltage dividers are used.
+
+  The 5 to 3.3 V level shifter for 5 V Arduinos should be IC based like the
+  74HC4050N based circuit shown in the file SdLevel.png.  The Adafruit Wave Shield
+  uses a 74AHC125N.  Gravitech sells SD and MicroSD Card Adapters based on the
+  74LCX245.
+
+  If you are using a resistor based level shifter and are having problems try
+  setting the SPI bus frequency to 4 MHz.  This can be done by using
+  card.init(SPI_HALF_SPEED) to initialize the SD card.
+
+  \section comment Bugs and Comments
+
+  If you wish to report bugs or have comments, send email to fat16lib@sbcglobal.net.
+
+  \section SdFatClass SdFat Usage
+
+  SdFat uses a slightly restricted form of short names.
+  Only printable ASCII characters are supported. No characters with code point
+  values greater than 127 are allowed.  Space is not allowed even though space
+  was allowed in the API of early versions of DOS.
+
+  Short names are limited to 8 characters followed by an optional period (.)
+  and extension of up to 3 characters.  The characters may be any combination
+  of letters and digits.  The following special characters are also allowed:
+
+  $ % ' - _ @ ~ ` ! ( ) { } ^ # &
+
+  Short names are always converted to upper case and their original case
+  value is lost.
+
+  \note
+  The Arduino Print class uses character
+  at a time writes so it was necessary to use a \link SdFile::sync() sync() \endlink
+  function to control when data is written to the SD card.
+
+  \par
+  An application which writes to a file using \link Print::print() print()\endlink,
+  \link Print::println() println() \endlink
+  or \link SdFile::write write() \endlink must call \link SdFile::sync() sync() \endlink
+  at the appropriate time to force data and directory information to be written
+  to the SD Card.  Data and directory information are also written to the SD card
+  when \link SdFile::close() close() \endlink is called.
+
+  \par
+  Applications must use care calling \link SdFile::sync() sync() \endlink
+  since 2048 bytes of I/O is required to update file and
+  directory information.  This includes writing the current data block, reading
+  the block that contains the directory entry for update, writing the directory
+  block back and reading back the current data block.
+
+  It is possible to open a file with two or more instances of SdFile.  A file may
+  be corrupted if data is written to the file by more than one instance of SdFile.
+
+  \section HowTo How to format SD Cards as FAT Volumes
+
+  You should use a freshly formatted SD card for best performance.  FAT
+  file systems become slower if many files have been created and deleted.
+  This is because the directory entry for a deleted file is marked as deleted,
+  but is not deleted.  When a new file is created, these entries must be scanned
+  before creating the file, a flaw in the FAT design.  Also files can become
+  fragmented which causes reads and writes to be slower.
+
+  Microsoft operating systems support removable media formatted with a
+  Master Boot Record, MBR, or formatted as a super floppy with a FAT Boot Sector
+  in block zero.
+
+  Microsoft operating systems expect MBR formatted removable media
+  to have only one partition. The first partition should be used.
+
+  Microsoft operating systems do not support partitioning SD flash cards.
+  If you erase an SD card with a program like KillDisk, Most versions of
+  Windows will format the card as a super floppy.
+
+  The best way to restore an SD card's format is to use SDFormatter
+  which can be downloaded from:
+
+  http://www.sdcard.org/consumers/formatter/
+
+  SDFormatter aligns flash erase boundaries with file
+  system structures which reduces write latency and file system overhead.
+
+  SDFormatter does not have an option for FAT type so it may format
+  small cards as FAT12.
+
+  After the MBR is restored by SDFormatter you may need to reformat small
+  cards that have been formatted FAT12 to force the volume type to be FAT16.
+
+  If you reformat the SD card with an OS utility, choose a cluster size that
+  will result in:
+
+  4084 < CountOfClusters && CountOfClusters < 65525
+
+  The volume will then be FAT16.
+
+  If you are formatting an SD card on OS X or Linux, be sure to use the first
+  partition. Format this partition with a cluster count in above range.
+
+  \section  References References
+
+  Adafruit Industries:
+
+  http://www.adafruit.com/
+
+  http://www.ladyada.net/make/waveshield/
+
+  The Arduino site:
+
+  http://www.arduino.cc/
+
+  For more information about FAT file systems see:
+
+  http://www.microsoft.com/whdc/system/platform/firmware/fatgen.mspx
+
+  For information about using SD cards as SPI devices see:
+
+  http://www.sdcard.org/developers/tech/sdcard/pls/Simplified_Physical_Layer_Spec.pdf
+
+  The ATmega328 datasheet:
+
+  http://www.atmel.com/dyn/resources/prod_documents/doc8161.pdf
+
+
+*/
diff --git a/libraries/SD/src/utility/SdFile.cpp b/libraries/SD/src/utility/SdFile.cpp
new file mode 100755
index 0000000..18a1db6
--- /dev/null
+++ b/libraries/SD/src/utility/SdFile.cpp
@@ -0,0 +1,1527 @@
+/* Arduino SdFat Library
+   Copyright (C) 2009 by William Greiman
+
+   This file is part of the Arduino SdFat Library
+
+   This Library is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with the Arduino SdFat Library.  If not, see
+   <http://www.gnu.org/licenses/>.
+*/
+#include "SdFat.h"
+#ifdef __AVR__
+  #include <avr/pgmspace.h>
+#endif
+#include <Arduino.h>
+//------------------------------------------------------------------------------
+// callback function for date/time
+void (*SdFile::dateTime_)(uint16_t* date, uint16_t* time) = NULL;
+
+#if ALLOW_DEPRECATED_FUNCTIONS
+  // suppress cpplint warnings with NOLINT comment
+  void (*SdFile::oldDateTime_)(uint16_t& date, uint16_t& time) = NULL;  // NOLINT
+#endif  // ALLOW_DEPRECATED_FUNCTIONS
+//------------------------------------------------------------------------------
+// add a cluster to a file
+uint8_t SdFile::addCluster() {
+  if (!vol_->allocContiguous(1, &curCluster_)) {
+    return false;
+  }
+
+  // if first cluster of file link to directory entry
+  if (firstCluster_ == 0) {
+    firstCluster_ = curCluster_;
+    flags_ |= F_FILE_DIR_DIRTY;
+  }
+  flags_ |= F_FILE_CLUSTER_ADDED;
+  return true;
+}
+//------------------------------------------------------------------------------
+// Add a cluster to a directory file and zero the cluster.
+// return with first block of cluster in the cache
+uint8_t SdFile::addDirCluster(void) {
+  if (!addCluster()) {
+    return false;
+  }
+
+  // zero data in cluster insure first cluster is in cache
+  uint32_t block = vol_->clusterStartBlock(curCluster_);
+  for (uint8_t i = vol_->blocksPerCluster_; i != 0; i--) {
+    if (!SdVolume::cacheZeroBlock(block + i - 1)) {
+      return false;
+    }
+  }
+  // Increase directory file size by cluster size
+  fileSize_ += 512UL << vol_->clusterSizeShift_;
+  return true;
+}
+//------------------------------------------------------------------------------
+// cache a file's directory entry
+// return pointer to cached entry or null for failure
+dir_t* SdFile::cacheDirEntry(uint8_t action) {
+  if (!SdVolume::cacheRawBlock(dirBlock_, action)) {
+    return NULL;
+  }
+  return SdVolume::cacheBuffer_.dir + dirIndex_;
+}
+//------------------------------------------------------------------------------
+/**
+    Close a file and force cached data and directory information
+    to be written to the storage device.
+
+   \return The value one, true, is returned for success and
+   the value zero, false, is returned for failure.
+   Reasons for failure include no file is open or an I/O error.
+*/
+uint8_t SdFile::close(void) {
+  if (!sync()) {
+    return false;
+  }
+  type_ = FAT_FILE_TYPE_CLOSED;
+  return true;
+}
+//------------------------------------------------------------------------------
+/**
+   Check for contiguous file and return its raw block range.
+
+   \param[out] bgnBlock the first block address for the file.
+   \param[out] endBlock the last  block address for the file.
+
+   \return The value one, true, is returned for success and
+   the value zero, false, is returned for failure.
+   Reasons for failure include file is not contiguous, file has zero length
+   or an I/O error occurred.
+*/
+uint8_t SdFile::contiguousRange(uint32_t* bgnBlock, uint32_t* endBlock) {
+  // error if no blocks
+  if (firstCluster_ == 0) {
+    return false;
+  }
+
+  for (uint32_t c = firstCluster_; ; c++) {
+    uint32_t next;
+    if (!vol_->fatGet(c, &next)) {
+      return false;
+    }
+
+    // check for contiguous
+    if (next != (c + 1)) {
+      // error if not end of chain
+      if (!vol_->isEOC(next)) {
+        return false;
+      }
+      *bgnBlock = vol_->clusterStartBlock(firstCluster_);
+      *endBlock = vol_->clusterStartBlock(c)
+                  + vol_->blocksPerCluster_ - 1;
+      return true;
+    }
+  }
+}
+//------------------------------------------------------------------------------
+/**
+   Create and open a new contiguous file of a specified size.
+
+   \note This function only supports short DOS 8.3 names.
+   See open() for more information.
+
+   \param[in] dirFile The directory where the file will be created.
+   \param[in] fileName A valid DOS 8.3 file name.
+   \param[in] size The desired file size.
+
+   \return The value one, true, is returned for success and
+   the value zero, false, is returned for failure.
+   Reasons for failure include \a fileName contains
+   an invalid DOS 8.3 file name, the FAT volume has not been initialized,
+   a file is already open, the file already exists, the root
+   directory is full or an I/O error.
+
+*/
+uint8_t SdFile::createContiguous(SdFile* dirFile,
+                                 const char* fileName, uint32_t size) {
+  // don't allow zero length file
+  if (size == 0) {
+    return false;
+  }
+  if (!open(dirFile, fileName, O_CREAT | O_EXCL | O_RDWR)) {
+    return false;
+  }
+
+  // calculate number of clusters needed
+  uint32_t count = ((size - 1) >> (vol_->clusterSizeShift_ + 9)) + 1;
+
+  // allocate clusters
+  if (!vol_->allocContiguous(count, &firstCluster_)) {
+    remove();
+    return false;
+  }
+  fileSize_ = size;
+
+  // insure sync() will update dir entry
+  flags_ |= F_FILE_DIR_DIRTY;
+  return sync();
+}
+//------------------------------------------------------------------------------
+/**
+   Return a files directory entry
+
+   \param[out] dir Location for return of the files directory entry.
+
+   \return The value one, true, is returned for success and
+   the value zero, false, is returned for failure.
+*/
+uint8_t SdFile::dirEntry(dir_t* dir) {
+  // make sure fields on SD are correct
+  if (!sync()) {
+    return false;
+  }
+
+  // read entry
+  dir_t* p = cacheDirEntry(SdVolume::CACHE_FOR_READ);
+  if (!p) {
+    return false;
+  }
+
+  // copy to caller's struct
+  memcpy(dir, p, sizeof(dir_t));
+  return true;
+}
+//------------------------------------------------------------------------------
+/**
+   Format the name field of \a dir into the 13 byte array
+   \a name in standard 8.3 short name format.
+
+   \param[in] dir The directory structure containing the name.
+   \param[out] name A 13 byte char array for the formatted name.
+*/
+void SdFile::dirName(const dir_t& dir, char* name) {
+  uint8_t j = 0;
+  for (uint8_t i = 0; i < 11; i++) {
+    if (dir.name[i] == ' ') {
+      continue;
+    }
+    if (i == 8) {
+      name[j++] = '.';
+    }
+    name[j++] = dir.name[i];
+  }
+  name[j] = 0;
+}
+//------------------------------------------------------------------------------
+/** List directory contents to Serial.
+
+   \param[in] flags The inclusive OR of
+
+   LS_DATE - %Print file modification date
+
+   LS_SIZE - %Print file size.
+
+   LS_R - Recursive list of subdirectories.
+
+   \param[in] indent Amount of space before file name. Used for recursive
+   list to indicate subdirectory level.
+*/
+void SdFile::ls(uint8_t flags, uint8_t indent) {
+  dir_t* p;
+
+  rewind();
+  while ((p = readDirCache())) {
+    // done if past last used entry
+    if (p->name[0] == DIR_NAME_FREE) {
+      break;
+    }
+
+    // skip deleted entry and entries for . and  ..
+    if (p->name[0] == DIR_NAME_DELETED || p->name[0] == '.') {
+      continue;
+    }
+
+    // only list subdirectories and files
+    if (!DIR_IS_FILE_OR_SUBDIR(p)) {
+      continue;
+    }
+
+    // print any indent spaces
+    for (int8_t i = 0; i < indent; i++) {
+      Serial.print(' ');
+    }
+
+    // print file name with possible blank fill
+    printDirName(*p, flags & (LS_DATE | LS_SIZE) ? 14 : 0);
+
+    // print modify date/time if requested
+    if (flags & LS_DATE) {
+      printFatDate(p->lastWriteDate);
+      Serial.print(' ');
+      printFatTime(p->lastWriteTime);
+    }
+    // print size if requested
+    if (!DIR_IS_SUBDIR(p) && (flags & LS_SIZE)) {
+      Serial.print(' ');
+      Serial.print(p->fileSize);
+    }
+    Serial.println();
+
+    // list subdirectory content if requested
+    if ((flags & LS_R) && DIR_IS_SUBDIR(p)) {
+      uint16_t index = curPosition() / 32 - 1;
+      SdFile s;
+      if (s.open(this, index, O_READ)) {
+        s.ls(flags, indent + 2);
+      }
+      seekSet(32 * (index + 1));
+    }
+  }
+}
+//------------------------------------------------------------------------------
+// format directory name field from a 8.3 name string
+uint8_t SdFile::make83Name(const char* str, uint8_t* name) {
+  uint8_t c;
+  uint8_t n = 7;  // max index for part before dot
+  uint8_t i = 0;
+  // blank fill name and extension
+  while (i < 11) {
+    name[i++] = ' ';
+  }
+  i = 0;
+  while ((c = *str++) != '\0') {
+    if (c == '.') {
+      if (n == 10) {
+        return false;  // only one dot allowed
+      }
+      n = 10;  // max index for full 8.3 name
+      i = 8;   // place for extension
+    } else {
+      // illegal FAT characters
+      uint8_t b;
+      #if defined(__AVR__)
+      PGM_P p = PSTR("|<>^+=?/[];,*\"\\");
+      while ((b = pgm_read_byte(p++))) if (b == c) {
+          return false;
+        }
+      #elif defined(__arm__)
+      const uint8_t valid[] = "|<>^+=?/[];,*\"\\";
+      const uint8_t *p = valid;
+      while ((b = *p++)) if (b == c) {
+          return false;
+        }
+      #endif
+      // check size and only allow ASCII printable characters
+      if (i > n || c < 0X21 || c > 0X7E) {
+        return false;
+      }
+      // only upper case allowed in 8.3 names - convert lower to upper
+      name[i++] = c < 'a' || c > 'z' ?  c : c + ('A' - 'a');
+    }
+  }
+  // must have a file name, extension is optional
+  return name[0] != ' ';
+}
+//------------------------------------------------------------------------------
+/** Make a new directory.
+
+   \param[in] dir An open SdFat instance for the directory that will containing
+   the new directory.
+
+   \param[in] dirName A valid 8.3 DOS name for the new directory.
+
+   \return The value one, true, is returned for success and
+   the value zero, false, is returned for failure.
+   Reasons for failure include this SdFile is already open, \a dir is not a
+   directory, \a dirName is invalid or already exists in \a dir.
+*/
+uint8_t SdFile::makeDir(SdFile* dir, const char* dirName) {
+  dir_t d;
+
+  // create a normal file
+  if (!open(dir, dirName, O_CREAT | O_EXCL | O_RDWR)) {
+    return false;
+  }
+
+  // convert SdFile to directory
+  flags_ = O_READ;
+  type_ = FAT_FILE_TYPE_SUBDIR;
+
+  // allocate and zero first cluster
+  if (!addDirCluster()) {
+    return false;
+  }
+
+  // force entry to SD
+  if (!sync()) {
+    return false;
+  }
+
+  // cache entry - should already be in cache due to sync() call
+  dir_t* p = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
+  if (!p) {
+    return false;
+  }
+
+  // change directory entry  attribute
+  p->attributes = DIR_ATT_DIRECTORY;
+
+  // make entry for '.'
+  memcpy(&d, p, sizeof(d));
+  for (uint8_t i = 1; i < 11; i++) {
+    d.name[i] = ' ';
+  }
+  d.name[0] = '.';
+
+  // cache block for '.'  and '..'
+  uint32_t block = vol_->clusterStartBlock(firstCluster_);
+  if (!SdVolume::cacheRawBlock(block, SdVolume::CACHE_FOR_WRITE)) {
+    return false;
+  }
+
+  // copy '.' to block
+  memcpy(&SdVolume::cacheBuffer_.dir[0], &d, sizeof(d));
+
+  // make entry for '..'
+  d.name[1] = '.';
+  if (dir->isRoot()) {
+    d.firstClusterLow = 0;
+    d.firstClusterHigh = 0;
+  } else {
+    d.firstClusterLow = dir->firstCluster_ & 0XFFFF;
+    d.firstClusterHigh = dir->firstCluster_ >> 16;
+  }
+  // copy '..' to block
+  memcpy(&SdVolume::cacheBuffer_.dir[1], &d, sizeof(d));
+
+  // set position after '..'
+  curPosition_ = 2 * sizeof(d);
+
+  // write first block
+  return SdVolume::cacheFlush();
+}
+//------------------------------------------------------------------------------
+/**
+   Open a file or directory by name.
+
+   \param[in] dirFile An open SdFat instance for the directory containing the
+   file to be opened.
+
+   \param[in] fileName A valid 8.3 DOS name for a file to be opened.
+
+   \param[in] oflag Values for \a oflag are constructed by a bitwise-inclusive
+   OR of flags from the following list
+
+   O_READ - Open for reading.
+
+   O_RDONLY - Same as O_READ.
+
+   O_WRITE - Open for writing.
+
+   O_WRONLY - Same as O_WRITE.
+
+   O_RDWR - Open for reading and writing.
+
+   O_APPEND - If set, the file offset shall be set to the end of the
+   file prior to each write.
+
+   O_CREAT - If the file exists, this flag has no effect except as noted
+   under O_EXCL below. Otherwise, the file shall be created
+
+   O_EXCL - If O_CREAT and O_EXCL are set, open() shall fail if the file exists.
+
+   O_SYNC - Call sync() after each write.  This flag should not be used with
+   write(uint8_t), write_P(PGM_P), writeln_P(PGM_P), or the Arduino Print class.
+   These functions do character at a time writes so sync() will be called
+   after each byte.
+
+   O_TRUNC - If the file exists and is a regular file, and the file is
+   successfully opened and is not read only, its length shall be truncated to 0.
+
+   \note Directory files must be opened read only.  Write and truncation is
+   not allowed for directory files.
+
+   \return The value one, true, is returned for success and
+   the value zero, false, is returned for failure.
+   Reasons for failure include this SdFile is already open, \a difFile is not
+   a directory, \a fileName is invalid, the file does not exist
+   or can't be opened in the access mode specified by oflag.
+*/
+uint8_t SdFile::open(SdFile* dirFile, const char* fileName, uint8_t oflag) {
+  uint8_t dname[11];
+  dir_t* p;
+
+  // error if already open
+  if (isOpen()) {
+    return false;
+  }
+
+  if (!make83Name(fileName, dname)) {
+    return false;
+  }
+  vol_ = dirFile->vol_;
+  dirFile->rewind();
+
+  // bool for empty entry found
+  uint8_t emptyFound = false;
+
+  // search for file
+  while (dirFile->curPosition_ < dirFile->fileSize_) {
+    uint8_t index = 0XF & (dirFile->curPosition_ >> 5);
+    p = dirFile->readDirCache();
+    if (p == NULL) {
+      return false;
+    }
+
+    if (p->name[0] == DIR_NAME_FREE || p->name[0] == DIR_NAME_DELETED) {
+      // remember first empty slot
+      if (!emptyFound) {
+        emptyFound = true;
+        dirIndex_ = index;
+        dirBlock_ = SdVolume::cacheBlockNumber_;
+      }
+      // done if no entries follow
+      if (p->name[0] == DIR_NAME_FREE) {
+        break;
+      }
+    } else if (!memcmp(dname, p->name, 11)) {
+      // don't open existing file if O_CREAT and O_EXCL
+      if ((oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL)) {
+        return false;
+      }
+
+      // open found file
+      return openCachedEntry(0XF & index, oflag);
+    }
+  }
+  // only create file if O_CREAT and O_WRITE
+  if ((oflag & (O_CREAT | O_WRITE)) != (O_CREAT | O_WRITE)) {
+    return false;
+  }
+
+  // cache found slot or add cluster if end of file
+  if (emptyFound) {
+    p = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
+    if (!p) {
+      return false;
+    }
+  } else {
+    if (dirFile->type_ == FAT_FILE_TYPE_ROOT16) {
+      return false;
+    }
+
+    // add and zero cluster for dirFile - first cluster is in cache for write
+    if (!dirFile->addDirCluster()) {
+      return false;
+    }
+
+    // use first entry in cluster
+    dirIndex_ = 0;
+    p = SdVolume::cacheBuffer_.dir;
+  }
+  // initialize as empty file
+  memset(p, 0, sizeof(dir_t));
+  memcpy(p->name, dname, 11);
+
+  // set timestamps
+  if (dateTime_) {
+    // call user function
+    dateTime_(&p->creationDate, &p->creationTime);
+  } else {
+    // use default date/time
+    p->creationDate = FAT_DEFAULT_DATE;
+    p->creationTime = FAT_DEFAULT_TIME;
+  }
+  p->lastAccessDate = p->creationDate;
+  p->lastWriteDate = p->creationDate;
+  p->lastWriteTime = p->creationTime;
+
+  // force write of entry to SD
+  if (!SdVolume::cacheFlush()) {
+    return false;
+  }
+
+  // open entry in cache
+  return openCachedEntry(dirIndex_, oflag);
+}
+//------------------------------------------------------------------------------
+/**
+   Open a file by index.
+
+   \param[in] dirFile An open SdFat instance for the directory.
+
+   \param[in] index The \a index of the directory entry for the file to be
+   opened.  The value for \a index is (directory file position)/32.
+
+   \param[in] oflag Values for \a oflag are constructed by a bitwise-inclusive
+   OR of flags O_READ, O_WRITE, O_TRUNC, and O_SYNC.
+
+   See open() by fileName for definition of flags and return values.
+
+*/
+uint8_t SdFile::open(SdFile* dirFile, uint16_t index, uint8_t oflag) {
+  // error if already open
+  if (isOpen()) {
+    return false;
+  }
+
+  // don't open existing file if O_CREAT and O_EXCL - user call error
+  if ((oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL)) {
+    return false;
+  }
+
+  vol_ = dirFile->vol_;
+
+  // seek to location of entry
+  if (!dirFile->seekSet(32 * index)) {
+    return false;
+  }
+
+  // read entry into cache
+  dir_t* p = dirFile->readDirCache();
+  if (p == NULL) {
+    return false;
+  }
+
+  // error if empty slot or '.' or '..'
+  if (p->name[0] == DIR_NAME_FREE ||
+      p->name[0] == DIR_NAME_DELETED || p->name[0] == '.') {
+    return false;
+  }
+  // open cached entry
+  return openCachedEntry(index & 0XF, oflag);
+}
+//------------------------------------------------------------------------------
+// open a cached directory entry. Assumes vol_ is initializes
+uint8_t SdFile::openCachedEntry(uint8_t dirIndex, uint8_t oflag) {
+  // location of entry in cache
+  dir_t* p = SdVolume::cacheBuffer_.dir + dirIndex;
+
+  // write or truncate is an error for a directory or read-only file
+  if (p->attributes & (DIR_ATT_READ_ONLY | DIR_ATT_DIRECTORY)) {
+    if (oflag & (O_WRITE | O_TRUNC)) {
+      return false;
+    }
+  }
+  // remember location of directory entry on SD
+  dirIndex_ = dirIndex;
+  dirBlock_ = SdVolume::cacheBlockNumber_;
+
+  // copy first cluster number for directory fields
+  firstCluster_ = (uint32_t)p->firstClusterHigh << 16;
+  firstCluster_ |= p->firstClusterLow;
+
+  // make sure it is a normal file or subdirectory
+  if (DIR_IS_FILE(p)) {
+    fileSize_ = p->fileSize;
+    type_ = FAT_FILE_TYPE_NORMAL;
+  } else if (DIR_IS_SUBDIR(p)) {
+    if (!vol_->chainSize(firstCluster_, &fileSize_)) {
+      return false;
+    }
+    type_ = FAT_FILE_TYPE_SUBDIR;
+  } else {
+    return false;
+  }
+  // save open flags for read/write
+  flags_ = oflag & (O_ACCMODE | O_SYNC | O_APPEND);
+
+  // set to start of file
+  curCluster_ = 0;
+  curPosition_ = 0;
+
+  // truncate file to zero length if requested
+  if (oflag & O_TRUNC) {
+    return truncate(0);
+  }
+  return true;
+}
+//------------------------------------------------------------------------------
+/**
+   Open a volume's root directory.
+
+   \param[in] vol The FAT volume containing the root directory to be opened.
+
+   \return The value one, true, is returned for success and
+   the value zero, false, is returned for failure.
+   Reasons for failure include the FAT volume has not been initialized
+   or it a FAT12 volume.
+*/
+uint8_t SdFile::openRoot(SdVolume* vol) {
+  // error if file is already open
+  if (isOpen()) {
+    return false;
+  }
+
+  if (vol->fatType() == 16) {
+    type_ = FAT_FILE_TYPE_ROOT16;
+    firstCluster_ = 0;
+    fileSize_ = 32 * vol->rootDirEntryCount();
+  } else if (vol->fatType() == 32) {
+    type_ = FAT_FILE_TYPE_ROOT32;
+    firstCluster_ = vol->rootDirStart();
+    if (!vol->chainSize(firstCluster_, &fileSize_)) {
+      return false;
+    }
+  } else {
+    // volume is not initialized or FAT12
+    return false;
+  }
+  vol_ = vol;
+  // read only
+  flags_ = O_READ;
+
+  // set to start of file
+  curCluster_ = 0;
+  curPosition_ = 0;
+
+  // root has no directory entry
+  dirBlock_ = 0;
+  dirIndex_ = 0;
+  return true;
+}
+//------------------------------------------------------------------------------
+/** %Print the name field of a directory entry in 8.3 format to Serial.
+
+   \param[in] dir The directory structure containing the name.
+   \param[in] width Blank fill name if length is less than \a width.
+*/
+void SdFile::printDirName(const dir_t& dir, uint8_t width) {
+  uint8_t w = 0;
+  for (uint8_t i = 0; i < 11; i++) {
+    if (dir.name[i] == ' ') {
+      continue;
+    }
+    if (i == 8) {
+      Serial.print('.');
+      w++;
+    }
+    Serial.write(dir.name[i]);
+    w++;
+  }
+  if (DIR_IS_SUBDIR(&dir)) {
+    Serial.print('/');
+    w++;
+  }
+  while (w < width) {
+    Serial.print(' ');
+    w++;
+  }
+}
+//------------------------------------------------------------------------------
+/** %Print a directory date field to Serial.
+
+    Format is yyyy-mm-dd.
+
+   \param[in] fatDate The date field from a directory entry.
+*/
+void SdFile::printFatDate(uint16_t fatDate) {
+  Serial.print(FAT_YEAR(fatDate));
+  Serial.print('-');
+  printTwoDigits(FAT_MONTH(fatDate));
+  Serial.print('-');
+  printTwoDigits(FAT_DAY(fatDate));
+}
+//------------------------------------------------------------------------------
+/** %Print a directory time field to Serial.
+
+   Format is hh:mm:ss.
+
+   \param[in] fatTime The time field from a directory entry.
+*/
+void SdFile::printFatTime(uint16_t fatTime) {
+  printTwoDigits(FAT_HOUR(fatTime));
+  Serial.print(':');
+  printTwoDigits(FAT_MINUTE(fatTime));
+  Serial.print(':');
+  printTwoDigits(FAT_SECOND(fatTime));
+}
+//------------------------------------------------------------------------------
+/** %Print a value as two digits to Serial.
+
+   \param[in] v Value to be printed, 0 <= \a v <= 99
+*/
+void SdFile::printTwoDigits(uint8_t v) {
+  char str[3];
+  str[0] = '0' + v / 10;
+  str[1] = '0' + v % 10;
+  str[2] = 0;
+  Serial.print(str);
+}
+//------------------------------------------------------------------------------
+/**
+   Read data from a file starting at the current position.
+
+   \param[out] buf Pointer to the location that will receive the data.
+
+   \param[in] nbyte Maximum number of bytes to read.
+
+   \return For success read() returns the number of bytes read.
+   A value less than \a nbyte, including zero, will be returned
+   if end of file is reached.
+   If an error occurs, read() returns -1.  Possible errors include
+   read() called before a file has been opened, corrupt file system
+   or an I/O error occurred.
+*/
+int16_t SdFile::read(void* buf, uint16_t nbyte) {
+  uint8_t* dst = reinterpret_cast<uint8_t*>(buf);
+
+  // error if not open or write only
+  if (!isOpen() || !(flags_ & O_READ)) {
+    return -1;
+  }
+
+  // max bytes left in file
+  if (nbyte > (fileSize_ - curPosition_)) {
+    nbyte = fileSize_ - curPosition_;
+  }
+
+  // amount left to read
+  uint16_t toRead = nbyte;
+  while (toRead > 0) {
+    uint32_t block;  // raw device block number
+    uint16_t offset = curPosition_ & 0X1FF;  // offset in block
+    if (type_ == FAT_FILE_TYPE_ROOT16) {
+      block = vol_->rootDirStart() + (curPosition_ >> 9);
+    } else {
+      uint8_t blockOfCluster = vol_->blockOfCluster(curPosition_);
+      if (offset == 0 && blockOfCluster == 0) {
+        // start of new cluster
+        if (curPosition_ == 0) {
+          // use first cluster in file
+          curCluster_ = firstCluster_;
+        } else {
+          // get next cluster from FAT
+          if (!vol_->fatGet(curCluster_, &curCluster_)) {
+            return -1;
+          }
+        }
+      }
+      block = vol_->clusterStartBlock(curCluster_) + blockOfCluster;
+    }
+    uint16_t n = toRead;
+
+    // amount to be read from current block
+    if (n > (512 - offset)) {
+      n = 512 - offset;
+    }
+
+    // no buffering needed if n == 512 or user requests no buffering
+    if ((unbufferedRead() || n == 512) &&
+        block != SdVolume::cacheBlockNumber_) {
+      if (!vol_->readData(block, offset, n, dst)) {
+        return -1;
+      }
+      dst += n;
+    } else {
+      // read block to cache and copy data to caller
+      if (!SdVolume::cacheRawBlock(block, SdVolume::CACHE_FOR_READ)) {
+        return -1;
+      }
+      uint8_t* src = SdVolume::cacheBuffer_.data + offset;
+      uint8_t* end = src + n;
+      while (src != end) {
+        *dst++ = *src++;
+      }
+    }
+    curPosition_ += n;
+    toRead -= n;
+  }
+  return nbyte;
+}
+//------------------------------------------------------------------------------
+/**
+   Read the next directory entry from a directory file.
+
+   \param[out] dir The dir_t struct that will receive the data.
+
+   \return For success readDir() returns the number of bytes read.
+   A value of zero will be returned if end of file is reached.
+   If an error occurs, readDir() returns -1.  Possible errors include
+   readDir() called before a directory has been opened, this is not
+   a directory file or an I/O error occurred.
+*/
+int8_t SdFile::readDir(dir_t* dir) {
+  int8_t n;
+  // if not a directory file or miss-positioned return an error
+  if (!isDir() || (0X1F & curPosition_)) {
+    return -1;
+  }
+
+  while ((n = read(dir, sizeof(dir_t))) == sizeof(dir_t)) {
+    // last entry if DIR_NAME_FREE
+    if (dir->name[0] == DIR_NAME_FREE) {
+      break;
+    }
+    // skip empty entries and entry for .  and ..
+    if (dir->name[0] == DIR_NAME_DELETED || dir->name[0] == '.') {
+      continue;
+    }
+    // return if normal file or subdirectory
+    if (DIR_IS_FILE_OR_SUBDIR(dir)) {
+      return n;
+    }
+  }
+  // error, end of file, or past last entry
+  return n < 0 ? -1 : 0;
+}
+//------------------------------------------------------------------------------
+// Read next directory entry into the cache
+// Assumes file is correctly positioned
+dir_t* SdFile::readDirCache(void) {
+  // error if not directory
+  if (!isDir()) {
+    return NULL;
+  }
+
+  // index of entry in cache
+  uint8_t i = (curPosition_ >> 5) & 0XF;
+
+  // use read to locate and cache block
+  if (read() < 0) {
+    return NULL;
+  }
+
+  // advance to next entry
+  curPosition_ += 31;
+
+  // return pointer to entry
+  return (SdVolume::cacheBuffer_.dir + i);
+}
+//------------------------------------------------------------------------------
+/**
+   Remove a file.
+
+   The directory entry and all data for the file are deleted.
+
+   \note This function should not be used to delete the 8.3 version of a
+   file that has a long name. For example if a file has the long name
+   "New Text Document.txt" you should not delete the 8.3 name "NEWTEX~1.TXT".
+
+   \return The value one, true, is returned for success and
+   the value zero, false, is returned for failure.
+   Reasons for failure include the file read-only, is a directory,
+   or an I/O error occurred.
+*/
+uint8_t SdFile::remove(void) {
+  // free any clusters - will fail if read-only or directory
+  if (!truncate(0)) {
+    return false;
+  }
+
+  // cache directory entry
+  dir_t* d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
+  if (!d) {
+    return false;
+  }
+
+  // mark entry deleted
+  d->name[0] = DIR_NAME_DELETED;
+
+  // set this SdFile closed
+  type_ = FAT_FILE_TYPE_CLOSED;
+
+  // write entry to SD
+  return SdVolume::cacheFlush();
+}
+//------------------------------------------------------------------------------
+/**
+   Remove a file.
+
+   The directory entry and all data for the file are deleted.
+
+   \param[in] dirFile The directory that contains the file.
+   \param[in] fileName The name of the file to be removed.
+
+   \note This function should not be used to delete the 8.3 version of a
+   file that has a long name. For example if a file has the long name
+   "New Text Document.txt" you should not delete the 8.3 name "NEWTEX~1.TXT".
+
+   \return The value one, true, is returned for success and
+   the value zero, false, is returned for failure.
+   Reasons for failure include the file is a directory, is read only,
+   \a dirFile is not a directory, \a fileName is not found
+   or an I/O error occurred.
+*/
+uint8_t SdFile::remove(SdFile* dirFile, const char* fileName) {
+  SdFile file;
+  if (!file.open(dirFile, fileName, O_WRITE)) {
+    return false;
+  }
+  return file.remove();
+}
+//------------------------------------------------------------------------------
+/** Remove a directory file.
+
+   The directory file will be removed only if it is empty and is not the
+   root directory.  rmDir() follows DOS and Windows and ignores the
+   read-only attribute for the directory.
+
+   \note This function should not be used to delete the 8.3 version of a
+   directory that has a long name. For example if a directory has the
+   long name "New folder" you should not delete the 8.3 name "NEWFOL~1".
+
+   \return The value one, true, is returned for success and
+   the value zero, false, is returned for failure.
+   Reasons for failure include the file is not a directory, is the root
+   directory, is not empty, or an I/O error occurred.
+*/
+uint8_t SdFile::rmDir(void) {
+  // must be open subdirectory
+  if (!isSubDir()) {
+    return false;
+  }
+
+  rewind();
+
+  // make sure directory is empty
+  while (curPosition_ < fileSize_) {
+    dir_t* p = readDirCache();
+    if (p == NULL) {
+      return false;
+    }
+    // done if past last used entry
+    if (p->name[0] == DIR_NAME_FREE) {
+      break;
+    }
+    // skip empty slot or '.' or '..'
+    if (p->name[0] == DIR_NAME_DELETED || p->name[0] == '.') {
+      continue;
+    }
+    // error not empty
+    if (DIR_IS_FILE_OR_SUBDIR(p)) {
+      return false;
+    }
+  }
+  // convert empty directory to normal file for remove
+  type_ = FAT_FILE_TYPE_NORMAL;
+  flags_ |= O_WRITE;
+  return remove();
+}
+//------------------------------------------------------------------------------
+/** Recursively delete a directory and all contained files.
+
+   This is like the Unix/Linux 'rm -rf *' if called with the root directory
+   hence the name.
+
+   Warning - This will remove all contents of the directory including
+   subdirectories.  The directory will then be removed if it is not root.
+   The read-only attribute for files will be ignored.
+
+   \note This function should not be used to delete the 8.3 version of
+   a directory that has a long name.  See remove() and rmDir().
+
+   \return The value one, true, is returned for success and
+   the value zero, false, is returned for failure.
+*/
+uint8_t SdFile::rmRfStar(void) {
+  rewind();
+  while (curPosition_ < fileSize_) {
+    SdFile f;
+
+    // remember position
+    uint16_t index = curPosition_ / 32;
+
+    dir_t* p = readDirCache();
+    if (!p) {
+      return false;
+    }
+
+    // done if past last entry
+    if (p->name[0] == DIR_NAME_FREE) {
+      break;
+    }
+
+    // skip empty slot or '.' or '..'
+    if (p->name[0] == DIR_NAME_DELETED || p->name[0] == '.') {
+      continue;
+    }
+
+    // skip if part of long file name or volume label in root
+    if (!DIR_IS_FILE_OR_SUBDIR(p)) {
+      continue;
+    }
+
+    if (!f.open(this, index, O_READ)) {
+      return false;
+    }
+    if (f.isSubDir()) {
+      // recursively delete
+      if (!f.rmRfStar()) {
+        return false;
+      }
+    } else {
+      // ignore read-only
+      f.flags_ |= O_WRITE;
+      if (!f.remove()) {
+        return false;
+      }
+    }
+    // position to next entry if required
+    if (curPosition_ != (32u * (index + 1))) {
+      if (!seekSet(32u * (index + 1))) {
+        return false;
+      }
+    }
+  }
+  // don't try to delete root
+  if (isRoot()) {
+    return true;
+  }
+  return rmDir();
+}
+//------------------------------------------------------------------------------
+/**
+   Sets a file's position.
+
+   \param[in] pos The new position in bytes from the beginning of the file.
+
+   \return The value one, true, is returned for success and
+   the value zero, false, is returned for failure.
+*/
+uint8_t SdFile::seekSet(uint32_t pos) {
+  // error if file not open or seek past end of file
+  if (!isOpen() || pos > fileSize_) {
+    return false;
+  }
+
+  if (type_ == FAT_FILE_TYPE_ROOT16) {
+    curPosition_ = pos;
+    return true;
+  }
+  if (pos == 0) {
+    // set position to start of file
+    curCluster_ = 0;
+    curPosition_ = 0;
+    return true;
+  }
+  // calculate cluster index for cur and new position
+  uint32_t nCur = (curPosition_ - 1) >> (vol_->clusterSizeShift_ + 9);
+  uint32_t nNew = (pos - 1) >> (vol_->clusterSizeShift_ + 9);
+
+  if (nNew < nCur || curPosition_ == 0) {
+    // must follow chain from first cluster
+    curCluster_ = firstCluster_;
+  } else {
+    // advance from curPosition
+    nNew -= nCur;
+  }
+  while (nNew--) {
+    if (!vol_->fatGet(curCluster_, &curCluster_)) {
+      return false;
+    }
+  }
+  curPosition_ = pos;
+  return true;
+}
+//------------------------------------------------------------------------------
+/**
+   The sync() call causes all modified data and directory fields
+   to be written to the storage device.
+
+   \param[in] blocking If the sync should block until fully complete.
+
+   \return The value one, true, is returned for success and
+   the value zero, false, is returned for failure.
+   Reasons for failure include a call to sync() before a file has been
+   opened or an I/O error.
+*/
+uint8_t SdFile::sync(uint8_t blocking) {
+  // only allow open files and directories
+  if (!isOpen()) {
+    return false;
+  }
+
+  if (flags_ & F_FILE_DIR_DIRTY) {
+    dir_t* d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
+    if (!d) {
+      return false;
+    }
+
+    // do not set filesize for dir files
+    if (!isDir()) {
+      d->fileSize = fileSize_;
+    }
+
+    // update first cluster fields
+    d->firstClusterLow = firstCluster_ & 0XFFFF;
+    d->firstClusterHigh = firstCluster_ >> 16;
+
+    // set modify time if user supplied a callback date/time function
+    if (dateTime_) {
+      dateTime_(&d->lastWriteDate, &d->lastWriteTime);
+      d->lastAccessDate = d->lastWriteDate;
+    }
+    // clear directory dirty
+    flags_ &= ~F_FILE_DIR_DIRTY;
+  }
+
+  if (!blocking) {
+    flags_ &= ~F_FILE_NON_BLOCKING_WRITE;
+  }
+
+  return SdVolume::cacheFlush(blocking);
+}
+//------------------------------------------------------------------------------
+/**
+   Set a file's timestamps in its directory entry.
+
+   \param[in] flags Values for \a flags are constructed by a bitwise-inclusive
+   OR of flags from the following list
+
+   T_ACCESS - Set the file's last access date.
+
+   T_CREATE - Set the file's creation date and time.
+
+   T_WRITE - Set the file's last write/modification date and time.
+
+   \param[in] year Valid range 1980 - 2107 inclusive.
+
+   \param[in] month Valid range 1 - 12 inclusive.
+
+   \param[in] day Valid range 1 - 31 inclusive.
+
+   \param[in] hour Valid range 0 - 23 inclusive.
+
+   \param[in] minute Valid range 0 - 59 inclusive.
+
+   \param[in] second Valid range 0 - 59 inclusive
+
+   \note It is possible to set an invalid date since there is no check for
+   the number of days in a month.
+
+   \note
+   Modify and access timestamps may be overwritten if a date time callback
+   function has been set by dateTimeCallback().
+
+   \return The value one, true, is returned for success and
+   the value zero, false, is returned for failure.
+*/
+uint8_t SdFile::timestamp(uint8_t flags, uint16_t year, uint8_t month,
+                          uint8_t day, uint8_t hour, uint8_t minute, uint8_t second) {
+  if (!isOpen()
+      || year < 1980
+      || year > 2107
+      || month < 1
+      || month > 12
+      || day < 1
+      || day > 31
+      || hour > 23
+      || minute > 59
+      || second > 59) {
+    return false;
+  }
+  dir_t* d = cacheDirEntry(SdVolume::CACHE_FOR_WRITE);
+  if (!d) {
+    return false;
+  }
+
+  uint16_t dirDate = FAT_DATE(year, month, day);
+  uint16_t dirTime = FAT_TIME(hour, minute, second);
+  if (flags & T_ACCESS) {
+    d->lastAccessDate = dirDate;
+  }
+  if (flags & T_CREATE) {
+    d->creationDate = dirDate;
+    d->creationTime = dirTime;
+    // seems to be units of 1/100 second not 1/10 as Microsoft states
+    d->creationTimeTenths = second & 1 ? 100 : 0;
+  }
+  if (flags & T_WRITE) {
+    d->lastWriteDate = dirDate;
+    d->lastWriteTime = dirTime;
+  }
+  SdVolume::cacheSetDirty();
+  return sync();
+}
+//------------------------------------------------------------------------------
+/**
+   Truncate a file to a specified length.  The current file position
+   will be maintained if it is less than or equal to \a length otherwise
+   it will be set to end of file.
+
+   \param[in] length The desired length for the file.
+
+   \return The value one, true, is returned for success and
+   the value zero, false, is returned for failure.
+   Reasons for failure include file is read only, file is a directory,
+   \a length is greater than the current file size or an I/O error occurs.
+*/
+uint8_t SdFile::truncate(uint32_t length) {
+  // error if not a normal file or read-only
+  if (!isFile() || !(flags_ & O_WRITE)) {
+    return false;
+  }
+
+  // error if length is greater than current size
+  if (length > fileSize_) {
+    return false;
+  }
+
+  // fileSize and length are zero - nothing to do
+  if (fileSize_ == 0) {
+    return true;
+  }
+
+  // remember position for seek after truncation
+  uint32_t newPos = curPosition_ > length ? length : curPosition_;
+
+  // position to last cluster in truncated file
+  if (!seekSet(length)) {
+    return false;
+  }
+
+  if (length == 0) {
+    // free all clusters
+    if (!vol_->freeChain(firstCluster_)) {
+      return false;
+    }
+    firstCluster_ = 0;
+  } else {
+    uint32_t toFree;
+    if (!vol_->fatGet(curCluster_, &toFree)) {
+      return false;
+    }
+
+    if (!vol_->isEOC(toFree)) {
+      // free extra clusters
+      if (!vol_->freeChain(toFree)) {
+        return false;
+      }
+
+      // current cluster is end of chain
+      if (!vol_->fatPutEOC(curCluster_)) {
+        return false;
+      }
+    }
+  }
+  fileSize_ = length;
+
+  // need to update directory entry
+  flags_ |= F_FILE_DIR_DIRTY;
+
+  if (!sync()) {
+    return false;
+  }
+
+  // set file to correct position
+  return seekSet(newPos);
+}
+//------------------------------------------------------------------------------
+/**
+   Write data to an open file.
+
+   \note Data is moved to the cache but may not be written to the
+   storage device until sync() is called.
+
+   \param[in] buf Pointer to the location of the data to be written.
+
+   \param[in] nbyte Number of bytes to write.
+
+   \return For success write() returns the number of bytes written, always
+   \a nbyte.  If an error occurs, write() returns 0.  Possible errors
+   include write() is called before a file has been opened, write is called
+   for a read-only file, device is full, a corrupt file system or an I/O error.
+
+*/
+size_t SdFile::write(const void* buf, uint16_t nbyte) {
+  // convert void* to uint8_t*  -  must be before goto statements
+  const uint8_t* src = reinterpret_cast<const uint8_t*>(buf);
+
+  // number of bytes left to write  -  must be before goto statements
+  uint16_t nToWrite = nbyte;
+  // if blocking writes should be used
+  uint8_t blocking = (flags_ & F_FILE_NON_BLOCKING_WRITE) == 0x00;
+
+  // error if not a normal file or is read-only
+  if (!isFile() || !(flags_ & O_WRITE)) {
+    goto writeErrorReturn;
+  }
+
+  // seek to end of file if append flag
+  if ((flags_ & O_APPEND) && curPosition_ != fileSize_) {
+    if (!seekEnd()) {
+      goto writeErrorReturn;
+    }
+  }
+
+  while (nToWrite > 0) {
+    uint8_t blockOfCluster = vol_->blockOfCluster(curPosition_);
+    uint16_t blockOffset = curPosition_ & 0X1FF;
+    if (blockOfCluster == 0 && blockOffset == 0) {
+      // start of new cluster
+      if (curCluster_ == 0) {
+        if (firstCluster_ == 0) {
+          // allocate first cluster of file
+          if (!addCluster()) {
+            goto writeErrorReturn;
+          }
+        } else {
+          curCluster_ = firstCluster_;
+        }
+      } else {
+        uint32_t next;
+        if (!vol_->fatGet(curCluster_, &next)) {
+          return false;
+        }
+        if (vol_->isEOC(next)) {
+          // add cluster if at end of chain
+          if (!addCluster()) {
+            goto writeErrorReturn;
+          }
+        } else {
+          curCluster_ = next;
+        }
+      }
+    }
+    // max space in block
+    uint16_t n = 512 - blockOffset;
+
+    // lesser of space and amount to write
+    if (n > nToWrite) {
+      n = nToWrite;
+    }
+
+    // block for data write
+    uint32_t block = vol_->clusterStartBlock(curCluster_) + blockOfCluster;
+    if (n == 512) {
+      // full block - don't need to use cache
+      // invalidate cache if block is in cache
+      if (SdVolume::cacheBlockNumber_ == block) {
+        SdVolume::cacheBlockNumber_ = 0XFFFFFFFF;
+      }
+      if (!vol_->writeBlock(block, src, blocking)) {
+        goto writeErrorReturn;
+      }
+      src += 512;
+    } else {
+      if (blockOffset == 0 && curPosition_ >= fileSize_) {
+        // start of new block don't need to read into cache
+        if (!SdVolume::cacheFlush()) {
+          goto writeErrorReturn;
+        }
+        SdVolume::cacheBlockNumber_ = block;
+        SdVolume::cacheSetDirty();
+      } else {
+        // rewrite part of block
+        if (!SdVolume::cacheRawBlock(block, SdVolume::CACHE_FOR_WRITE)) {
+          goto writeErrorReturn;
+        }
+      }
+      uint8_t* dst = SdVolume::cacheBuffer_.data + blockOffset;
+      uint8_t* end = dst + n;
+      while (dst != end) {
+        *dst++ = *src++;
+      }
+    }
+    nToWrite -= n;
+    curPosition_ += n;
+  }
+  if (curPosition_ > fileSize_) {
+    // update fileSize and insure sync will update dir entry
+    fileSize_ = curPosition_;
+    flags_ |= F_FILE_DIR_DIRTY;
+  } else if (dateTime_ && nbyte) {
+    // insure sync will update modified date and time
+    flags_ |= F_FILE_DIR_DIRTY;
+  }
+
+  if (flags_ & O_SYNC) {
+    if (!sync()) {
+      goto writeErrorReturn;
+    }
+  }
+  return nbyte;
+
+writeErrorReturn:
+  // return for write error
+  //writeError = true;
+  setWriteError();
+  return 0;
+}
+//------------------------------------------------------------------------------
+/**
+   Write a byte to a file. Required by the Arduino Print class.
+
+   Use SdFile::writeError to check for errors.
+*/
+size_t SdFile::write(uint8_t b) {
+  return write(&b, 1);
+}
+//------------------------------------------------------------------------------
+/**
+   Write a string to a file. Used by the Arduino Print class.
+
+   Use SdFile::writeError to check for errors.
+*/
+size_t SdFile::write(const char* str) {
+  return write(str, strlen(str));
+}
+#ifdef __AVR__
+//------------------------------------------------------------------------------
+/**
+   Write a PROGMEM string to a file.
+
+   Use SdFile::writeError to check for errors.
+*/
+void SdFile::write_P(PGM_P str) {
+  for (uint8_t c; (c = pgm_read_byte(str)); str++) {
+    write(c);
+  }
+}
+//------------------------------------------------------------------------------
+/**
+   Write a PROGMEM string followed by CR/LF to a file.
+
+   Use SdFile::writeError to check for errors.
+*/
+void SdFile::writeln_P(PGM_P str) {
+  write_P(str);
+  println();
+}
+#endif
+//------------------------------------------------------------------------------
+/**
+   Check how many bytes can be written without blocking.
+
+   \return The number of bytes that can be written without blocking.
+*/
+int SdFile::availableForWrite() {
+  if (!isFile() || !(flags_ & O_WRITE)) {
+    return 0;
+  }
+
+  // seek to end of file if append flag
+  if ((flags_ & O_APPEND) && curPosition_ != fileSize_) {
+    if (!seekEnd()) {
+      return 0;
+    }
+  }
+
+  if (vol_->isBusy()) {
+    return 0;
+  }
+
+  if (flags_ & F_FILE_CLUSTER_ADDED) {
+    // new cluster added, trigger a non-blocking sync
+    sync(0);
+    flags_ &= ~F_FILE_CLUSTER_ADDED;
+    return 0;
+  }
+
+  if (vol_->isCacheMirrorBlockDirty()) {
+    // cache mirror block is dirty, trigger a non-blocking sync
+    vol_->cacheMirrorBlockFlush(0);
+    return 0;
+  }
+
+  flags_ |= F_FILE_NON_BLOCKING_WRITE;
+
+  uint16_t blockOffset = curPosition_ & 0X1FF;
+  uint16_t n = 512 - blockOffset;
+
+  return n;
+}
diff --git a/libraries/SD/src/utility/SdInfo.h b/libraries/SD/src/utility/SdInfo.h
new file mode 100755
index 0000000..6a0e087
--- /dev/null
+++ b/libraries/SD/src/utility/SdInfo.h
@@ -0,0 +1,232 @@
+/* Arduino Sd2Card Library
+   Copyright (C) 2009 by William Greiman
+
+   This file is part of the Arduino Sd2Card Library
+
+   This Library is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with the Arduino Sd2Card Library.  If not, see
+   <http://www.gnu.org/licenses/>.
+*/
+#ifndef SdInfo_h
+#define SdInfo_h
+#include <stdint.h>
+// Based on the document:
+//
+// SD Specifications
+// Part 1
+// Physical Layer
+// Simplified Specification
+// Version 2.00
+// September 25, 2006
+//
+// www.sdcard.org/developers/tech/sdcard/pls/Simplified_Physical_Layer_Spec.pdf
+//------------------------------------------------------------------------------
+// SD card commands
+/** GO_IDLE_STATE - init card in spi mode if CS low */
+uint8_t const CMD0 = 0X00;
+/** SEND_IF_COND - verify SD Memory Card interface operating condition.*/
+uint8_t const CMD8 = 0X08;
+/** SEND_CSD - read the Card Specific Data (CSD register) */
+uint8_t const CMD9 = 0X09;
+/** SEND_CID - read the card identification information (CID register) */
+uint8_t const CMD10 = 0X0A;
+/** SEND_STATUS - read the card status register */
+uint8_t const CMD13 = 0X0D;
+/** READ_BLOCK - read a single data block from the card */
+uint8_t const CMD17 = 0X11;
+/** WRITE_BLOCK - write a single data block to the card */
+uint8_t const CMD24 = 0X18;
+/** WRITE_MULTIPLE_BLOCK - write blocks of data until a STOP_TRANSMISSION */
+uint8_t const CMD25 = 0X19;
+/** ERASE_WR_BLK_START - sets the address of the first block to be erased */
+uint8_t const CMD32 = 0X20;
+/** ERASE_WR_BLK_END - sets the address of the last block of the continuous
+    range to be erased*/
+uint8_t const CMD33 = 0X21;
+/** ERASE - erase all previously selected blocks */
+uint8_t const CMD38 = 0X26;
+/** APP_CMD - escape for application specific command */
+uint8_t const CMD55 = 0X37;
+/** READ_OCR - read the OCR register of a card */
+uint8_t const CMD58 = 0X3A;
+/** SET_WR_BLK_ERASE_COUNT - Set the number of write blocks to be
+     pre-erased before writing */
+uint8_t const ACMD23 = 0X17;
+/** SD_SEND_OP_COMD - Sends host capacity support information and
+    activates the card's initialization process */
+uint8_t const ACMD41 = 0X29;
+//------------------------------------------------------------------------------
+/** status for card in the ready state */
+uint8_t const R1_READY_STATE = 0X00;
+/** status for card in the idle state */
+uint8_t const R1_IDLE_STATE = 0X01;
+/** status bit for illegal command */
+uint8_t const R1_ILLEGAL_COMMAND = 0X04;
+/** start data token for read or write single block*/
+uint8_t const DATA_START_BLOCK = 0XFE;
+/** stop token for write multiple blocks*/
+uint8_t const STOP_TRAN_TOKEN = 0XFD;
+/** start data token for write multiple blocks*/
+uint8_t const WRITE_MULTIPLE_TOKEN = 0XFC;
+/** mask for data response tokens after a write block operation */
+uint8_t const DATA_RES_MASK = 0X1F;
+/** write data accepted token */
+uint8_t const DATA_RES_ACCEPTED = 0X05;
+//------------------------------------------------------------------------------
+typedef struct CID {
+  // byte 0
+  uint8_t mid;  // Manufacturer ID
+  // byte 1-2
+  char oid[2];  // OEM/Application ID
+  // byte 3-7
+  char pnm[5];  // Product name
+  // byte 8
+  unsigned prv_m : 4;  // Product revision n.m
+  unsigned prv_n : 4;
+  // byte 9-12
+  uint32_t psn;  // Product serial number
+  // byte 13
+  unsigned mdt_year_high : 4;  // Manufacturing date
+  unsigned reserved : 4;
+  // byte 14
+  unsigned mdt_month : 4;
+  unsigned mdt_year_low : 4;
+  // byte 15
+  unsigned always1 : 1;
+  unsigned crc : 7;
+} cid_t;
+//------------------------------------------------------------------------------
+// CSD for version 1.00 cards
+typedef struct CSDV1 {
+  // byte 0
+  unsigned reserved1 : 6;
+  unsigned csd_ver : 2;
+  // byte 1
+  uint8_t taac;
+  // byte 2
+  uint8_t nsac;
+  // byte 3
+  uint8_t tran_speed;
+  // byte 4
+  uint8_t ccc_high;
+  // byte 5
+  unsigned read_bl_len : 4;
+  unsigned ccc_low : 4;
+  // byte 6
+  unsigned c_size_high : 2;
+  unsigned reserved2 : 2;
+  unsigned dsr_imp : 1;
+  unsigned read_blk_misalign : 1;
+  unsigned write_blk_misalign : 1;
+  unsigned read_bl_partial : 1;
+  // byte 7
+  uint8_t c_size_mid;
+  // byte 8
+  unsigned vdd_r_curr_max : 3;
+  unsigned vdd_r_curr_min : 3;
+  unsigned c_size_low : 2;
+  // byte 9
+  unsigned c_size_mult_high : 2;
+  unsigned vdd_w_cur_max : 3;
+  unsigned vdd_w_curr_min : 3;
+  // byte 10
+  unsigned sector_size_high : 6;
+  unsigned erase_blk_en : 1;
+  unsigned c_size_mult_low : 1;
+  // byte 11
+  unsigned wp_grp_size : 7;
+  unsigned sector_size_low : 1;
+  // byte 12
+  unsigned write_bl_len_high : 2;
+  unsigned r2w_factor : 3;
+  unsigned reserved3 : 2;
+  unsigned wp_grp_enable : 1;
+  // byte 13
+  unsigned reserved4 : 5;
+  unsigned write_partial : 1;
+  unsigned write_bl_len_low : 2;
+  // byte 14
+  unsigned reserved5: 2;
+  unsigned file_format : 2;
+  unsigned tmp_write_protect : 1;
+  unsigned perm_write_protect : 1;
+  unsigned copy : 1;
+  unsigned file_format_grp : 1;
+  // byte 15
+  unsigned always1 : 1;
+  unsigned crc : 7;
+} csd1_t;
+//------------------------------------------------------------------------------
+// CSD for version 2.00 cards
+typedef struct CSDV2 {
+  // byte 0
+  unsigned reserved1 : 6;
+  unsigned csd_ver : 2;
+  // byte 1
+  uint8_t taac;
+  // byte 2
+  uint8_t nsac;
+  // byte 3
+  uint8_t tran_speed;
+  // byte 4
+  uint8_t ccc_high;
+  // byte 5
+  unsigned read_bl_len : 4;
+  unsigned ccc_low : 4;
+  // byte 6
+  unsigned reserved2 : 4;
+  unsigned dsr_imp : 1;
+  unsigned read_blk_misalign : 1;
+  unsigned write_blk_misalign : 1;
+  unsigned read_bl_partial : 1;
+  // byte 7
+  unsigned reserved3 : 2;
+  unsigned c_size_high : 6;
+  // byte 8
+  uint8_t c_size_mid;
+  // byte 9
+  uint8_t c_size_low;
+  // byte 10
+  unsigned sector_size_high : 6;
+  unsigned erase_blk_en : 1;
+  unsigned reserved4 : 1;
+  // byte 11
+  unsigned wp_grp_size : 7;
+  unsigned sector_size_low : 1;
+  // byte 12
+  unsigned write_bl_len_high : 2;
+  unsigned r2w_factor : 3;
+  unsigned reserved5 : 2;
+  unsigned wp_grp_enable : 1;
+  // byte 13
+  unsigned reserved6 : 5;
+  unsigned write_partial : 1;
+  unsigned write_bl_len_low : 2;
+  // byte 14
+  unsigned reserved7: 2;
+  unsigned file_format : 2;
+  unsigned tmp_write_protect : 1;
+  unsigned perm_write_protect : 1;
+  unsigned copy : 1;
+  unsigned file_format_grp : 1;
+  // byte 15
+  unsigned always1 : 1;
+  unsigned crc : 7;
+} csd2_t;
+//------------------------------------------------------------------------------
+// union of old and new style CSD register
+union csd_t {
+  csd1_t v1;
+  csd2_t v2;
+};
+#endif  // SdInfo_h
diff --git a/libraries/SD/src/utility/SdVolume.cpp b/libraries/SD/src/utility/SdVolume.cpp
new file mode 100755
index 0000000..60375c4
--- /dev/null
+++ b/libraries/SD/src/utility/SdVolume.cpp
@@ -0,0 +1,351 @@
+/* Arduino SdFat Library
+   Copyright (C) 2009 by William Greiman
+
+   This file is part of the Arduino SdFat Library
+
+   This Library is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with the Arduino SdFat Library.  If not, see
+   <http://www.gnu.org/licenses/>.
+*/
+#include "SdFat.h"
+//------------------------------------------------------------------------------
+// raw block cache
+// init cacheBlockNumber_to invalid SD block number
+uint32_t SdVolume::cacheBlockNumber_ = 0XFFFFFFFF;
+cache_t  SdVolume::cacheBuffer_;     // 512 byte cache for Sd2Card
+Sd2Card* SdVolume::sdCard_;          // pointer to SD card object
+uint8_t  SdVolume::cacheDirty_ = 0;  // cacheFlush() will write block if true
+uint32_t SdVolume::cacheMirrorBlock_ = 0;  // mirror  block for second FAT
+//------------------------------------------------------------------------------
+// find a contiguous group of clusters
+uint8_t SdVolume::allocContiguous(uint32_t count, uint32_t* curCluster) {
+  // start of group
+  uint32_t bgnCluster;
+
+  // flag to save place to start next search
+  uint8_t setStart;
+
+  // set search start cluster
+  if (*curCluster) {
+    // try to make file contiguous
+    bgnCluster = *curCluster + 1;
+
+    // don't save new start location
+    setStart = false;
+  } else {
+    // start at likely place for free cluster
+    bgnCluster = allocSearchStart_;
+
+    // save next search start if one cluster
+    setStart = 1 == count;
+  }
+  // end of group
+  uint32_t endCluster = bgnCluster;
+
+  // last cluster of FAT
+  uint32_t fatEnd = clusterCount_ + 1;
+
+  // search the FAT for free clusters
+  for (uint32_t n = 0;; n++, endCluster++) {
+    // can't find space checked all clusters
+    if (n >= clusterCount_) {
+      return false;
+    }
+
+    // past end - start from beginning of FAT
+    if (endCluster > fatEnd) {
+      bgnCluster = endCluster = 2;
+    }
+    uint32_t f;
+    if (!fatGet(endCluster, &f)) {
+      return false;
+    }
+
+    if (f != 0) {
+      // cluster in use try next cluster as bgnCluster
+      bgnCluster = endCluster + 1;
+    } else if ((endCluster - bgnCluster + 1) == count) {
+      // done - found space
+      break;
+    }
+  }
+  // mark end of chain
+  if (!fatPutEOC(endCluster)) {
+    return false;
+  }
+
+  // link clusters
+  while (endCluster > bgnCluster) {
+    if (!fatPut(endCluster - 1, endCluster)) {
+      return false;
+    }
+    endCluster--;
+  }
+  if (*curCluster != 0) {
+    // connect chains
+    if (!fatPut(*curCluster, bgnCluster)) {
+      return false;
+    }
+  }
+  // return first cluster number to caller
+  *curCluster = bgnCluster;
+
+  // remember possible next free cluster
+  if (setStart) {
+    allocSearchStart_ = bgnCluster + 1;
+  }
+
+  return true;
+}
+//------------------------------------------------------------------------------
+uint8_t SdVolume::cacheFlush(uint8_t blocking) {
+  if (cacheDirty_) {
+    if (!sdCard_->writeBlock(cacheBlockNumber_, cacheBuffer_.data, blocking)) {
+      return false;
+    }
+
+    if (!blocking) {
+      return true;
+    }
+
+    // mirror FAT tables
+    if (!cacheMirrorBlockFlush(blocking)) {
+      return false;
+    }
+    cacheDirty_ = 0;
+  }
+  return true;
+}
+//------------------------------------------------------------------------------
+uint8_t SdVolume::cacheMirrorBlockFlush(uint8_t blocking) {
+  if (cacheMirrorBlock_) {
+    if (!sdCard_->writeBlock(cacheMirrorBlock_, cacheBuffer_.data, blocking)) {
+      return false;
+    }
+    cacheMirrorBlock_ = 0;
+  }
+  return true;
+}
+//------------------------------------------------------------------------------
+uint8_t SdVolume::cacheRawBlock(uint32_t blockNumber, uint8_t action) {
+  if (cacheBlockNumber_ != blockNumber) {
+    if (!cacheFlush()) {
+      return false;
+    }
+    if (!sdCard_->readBlock(blockNumber, cacheBuffer_.data)) {
+      return false;
+    }
+    cacheBlockNumber_ = blockNumber;
+  }
+  cacheDirty_ |= action;
+  return true;
+}
+//------------------------------------------------------------------------------
+// cache a zero block for blockNumber
+uint8_t SdVolume::cacheZeroBlock(uint32_t blockNumber) {
+  if (!cacheFlush()) {
+    return false;
+  }
+
+  // loop take less flash than memset(cacheBuffer_.data, 0, 512);
+  for (uint16_t i = 0; i < 512; i++) {
+    cacheBuffer_.data[i] = 0;
+  }
+  cacheBlockNumber_ = blockNumber;
+  cacheSetDirty();
+  return true;
+}
+//------------------------------------------------------------------------------
+// return the size in bytes of a cluster chain
+uint8_t SdVolume::chainSize(uint32_t cluster, uint32_t* size) const {
+  uint32_t s = 0;
+  do {
+    if (!fatGet(cluster, &cluster)) {
+      return false;
+    }
+    s += 512UL << clusterSizeShift_;
+  } while (!isEOC(cluster));
+  *size = s;
+  return true;
+}
+//------------------------------------------------------------------------------
+// Fetch a FAT entry
+uint8_t SdVolume::fatGet(uint32_t cluster, uint32_t* value) const {
+  if (cluster > (clusterCount_ + 1)) {
+    return false;
+  }
+  uint32_t lba = fatStartBlock_;
+  lba += fatType_ == 16 ? cluster >> 8 : cluster >> 7;
+  if (lba != cacheBlockNumber_) {
+    if (!cacheRawBlock(lba, CACHE_FOR_READ)) {
+      return false;
+    }
+  }
+  if (fatType_ == 16) {
+    *value = cacheBuffer_.fat16[cluster & 0XFF];
+  } else {
+    *value = cacheBuffer_.fat32[cluster & 0X7F] & FAT32MASK;
+  }
+  return true;
+}
+//------------------------------------------------------------------------------
+// Store a FAT entry
+uint8_t SdVolume::fatPut(uint32_t cluster, uint32_t value) {
+  // error if reserved cluster
+  if (cluster < 2) {
+    return false;
+  }
+
+  // error if not in FAT
+  if (cluster > (clusterCount_ + 1)) {
+    return false;
+  }
+
+  // calculate block address for entry
+  uint32_t lba = fatStartBlock_;
+  lba += fatType_ == 16 ? cluster >> 8 : cluster >> 7;
+
+  if (lba != cacheBlockNumber_) {
+    if (!cacheRawBlock(lba, CACHE_FOR_READ)) {
+      return false;
+    }
+  }
+  // store entry
+  if (fatType_ == 16) {
+    cacheBuffer_.fat16[cluster & 0XFF] = value;
+  } else {
+    cacheBuffer_.fat32[cluster & 0X7F] = value;
+  }
+  cacheSetDirty();
+
+  // mirror second FAT
+  if (fatCount_ > 1) {
+    cacheMirrorBlock_ = lba + blocksPerFat_;
+  }
+  return true;
+}
+//------------------------------------------------------------------------------
+// free a cluster chain
+uint8_t SdVolume::freeChain(uint32_t cluster) {
+  // clear free cluster location
+  allocSearchStart_ = 2;
+
+  do {
+    uint32_t next;
+    if (!fatGet(cluster, &next)) {
+      return false;
+    }
+
+    // free cluster
+    if (!fatPut(cluster, 0)) {
+      return false;
+    }
+
+    cluster = next;
+  } while (!isEOC(cluster));
+
+  return true;
+}
+//------------------------------------------------------------------------------
+/**
+   Initialize a FAT volume.
+
+   \param[in] dev The SD card where the volume is located.
+
+   \param[in] part The partition to be used.  Legal values for \a part are
+   1-4 to use the corresponding partition on a device formatted with
+   a MBR, Master Boot Record, or zero if the device is formatted as
+   a super floppy with the FAT boot sector in block zero.
+
+   \return The value one, true, is returned for success and
+   the value zero, false, is returned for failure.  Reasons for
+   failure include not finding a valid partition, not finding a valid
+   FAT file system in the specified partition or an I/O error.
+*/
+uint8_t SdVolume::init(Sd2Card* dev, uint8_t part) {
+  uint32_t volumeStartBlock = 0;
+  sdCard_ = dev;
+  // if part == 0 assume super floppy with FAT boot sector in block zero
+  // if part > 0 assume mbr volume with partition table
+  if (part) {
+    if (part > 4) {
+      return false;
+    }
+    if (!cacheRawBlock(volumeStartBlock, CACHE_FOR_READ)) {
+      return false;
+    }
+    part_t* p = &cacheBuffer_.mbr.part[part - 1];
+    if ((p->boot & 0X7F) != 0  ||
+        p->totalSectors < 100 ||
+        p->firstSector == 0) {
+      // not a valid partition
+      return false;
+    }
+    volumeStartBlock = p->firstSector;
+  }
+  if (!cacheRawBlock(volumeStartBlock, CACHE_FOR_READ)) {
+    return false;
+  }
+  bpb_t* bpb = &cacheBuffer_.fbs.bpb;
+  if (bpb->bytesPerSector != 512 ||
+      bpb->fatCount == 0 ||
+      bpb->reservedSectorCount == 0 ||
+      bpb->sectorsPerCluster == 0) {
+    // not valid FAT volume
+    return false;
+  }
+  fatCount_ = bpb->fatCount;
+  blocksPerCluster_ = bpb->sectorsPerCluster;
+
+  // determine shift that is same as multiply by blocksPerCluster_
+  clusterSizeShift_ = 0;
+  while (blocksPerCluster_ != (1 << clusterSizeShift_)) {
+    // error if not power of 2
+    if (clusterSizeShift_++ > 7) {
+      return false;
+    }
+  }
+  blocksPerFat_ = bpb->sectorsPerFat16 ?
+                  bpb->sectorsPerFat16 : bpb->sectorsPerFat32;
+
+  fatStartBlock_ = volumeStartBlock + bpb->reservedSectorCount;
+
+  // count for FAT16 zero for FAT32
+  rootDirEntryCount_ = bpb->rootDirEntryCount;
+
+  // directory start for FAT16 dataStart for FAT32
+  rootDirStart_ = fatStartBlock_ + bpb->fatCount * blocksPerFat_;
+
+  // data start for FAT16 and FAT32
+  dataStartBlock_ = rootDirStart_ + ((32 * bpb->rootDirEntryCount + 511) / 512);
+
+  // total blocks for FAT16 or FAT32
+  uint32_t totalBlocks = bpb->totalSectors16 ?
+                         bpb->totalSectors16 : bpb->totalSectors32;
+  // total data blocks
+  clusterCount_ = totalBlocks - (dataStartBlock_ - volumeStartBlock);
+
+  // divide by cluster size to get cluster count
+  clusterCount_ >>= clusterSizeShift_;
+
+  // FAT type is determined by cluster count
+  if (clusterCount_ < 4085) {
+    fatType_ = 12;
+  } else if (clusterCount_ < 65525) {
+    fatType_ = 16;
+  } else {
+    rootDirStart_ = bpb->fat32RootCluster;
+    fatType_ = 32;
+  }
+  return true;
+}
diff --git a/libraries/SX1278FSK/SX1278FSK.cpp b/libraries/SX1278FSK/SX1278FSK.cpp
new file mode 100755
index 0000000..fa25d87
--- /dev/null
+++ b/libraries/SX1278FSK/SX1278FSK.cpp
@@ -0,0 +1,861 @@
+/*
+ * Functions for using SX127x in FSK mode (mainly receive)
+ * Copyright (C) 2019 Hansi Reiser, dl9rdz
+ *
+ * Partially based on the SX1278 libraray for managing Semtech modules
+ *  Copyright (C) 2015 Wireless Open Source
+ *  http://wirelessopensource.com
+ *
+ *  SPDX-License-Identifier:    LGPL-2.1+
+ */
+
+#include "SX1278FSK.h"
+#include "SPI.h"
+#include <Sonde.h>
+#include <Display.h>
+
+SX1278FSK::SX1278FSK()
+{
+	// Initialize class variables
+};
+
+
+static SPISettings spiset = SPISettings(40000000L, MSBFIRST, SPI_MODE0);
+
+/*
+Function: Turns the module ON.
+Returns: 0 on success, 1 otherwise
+*/
+uint8_t SX1278FSK::ON()
+{
+	uint8_t state = 2;
+#if (SX1278FSK_debug_mode > 1)
+	Serial.println();
+	Serial.println(F("Starting 'ON'"));
+#endif
+
+	// Powering the module
+	pinMode(SX1278_SS, OUTPUT);
+	digitalWrite(SX1278_SS, HIGH);
+
+	//Configure the MISO, MOSI, CS, SPCR.
+	SPI.begin();
+	//Set most significant bit first
+	SPI.setBitOrder(MSBFIRST);
+	//Divide the clock frequency
+	SPI.setClockDivider(SPI_CLOCK_DIV2);
+	//Set data mode
+	SPI.setDataMode(SPI_MODE0);
+
+	// Set Maximum Over Current Protection
+	state = setMaxCurrent(0x1B);
+	if( state == 0 )
+	{
+#if (SX1278FSK_debug_mode > 1)
+		Serial.println(F("## Setting ON with maximum current supply ##"));
+		Serial.println();
+#endif
+	}
+	else
+	{
+		return 1;
+	}
+
+	// set FSK mode
+	state = setFSK();
+	return state;
+}
+
+/*
+Function: Turn the module OFF.
+Returns: Nothing
+*/
+void SX1278FSK::OFF()
+{
+#if (SX1278FSK_debug_mode > 1)
+	Serial.println();
+	Serial.println(F("Starting 'OFF'"));
+#endif
+
+	SPI.end();
+	// Powering the module
+	pinMode(SX1278_SS,OUTPUT);
+	digitalWrite(SX1278_SS,LOW);
+
+#if (SX1278FSK_debug_mode > 1)
+	Serial.println(F("## Setting OFF ##"));
+	Serial.println();
+#endif
+}
+
+/*
+Function: Reads the indicated register.
+Returns: The content of the register
+Parameters:
+	address: address register to read from
+*/
+byte SX1278FSK::readRegister(byte address)
+{
+	byte value = 0x00;
+
+	SPI.beginTransaction(spiset);
+	digitalWrite(SX1278_SS,LOW);
+
+	//delay(1);
+	bitClear(address, 7);		// Bit 7 cleared to write in registers
+	SPI.transfer(address);
+	value = SPI.transfer(0x00);
+	digitalWrite(SX1278_SS,HIGH);
+	SPI.endTransaction();
+
+#if (SX1278FSK_debug_mode > 1)
+	if(address!=0x3F) {
+		Serial.print(F("## Reading:  ##\t"));
+		Serial.print(F("Register "));
+		Serial.print(address, HEX);
+		Serial.print(F(":  "));
+		Serial.print(value, HEX);
+		Serial.println();
+	}
+#endif
+
+	return value;
+}
+
+/*
+Function: Writes on the indicated register.
+Returns: Nothing
+Parameters:
+	address: address register to write in
+	data: value to write in the register
+*/
+void SX1278FSK::writeRegister(byte address, byte data)
+{
+	SPI.beginTransaction(spiset);
+	digitalWrite(SX1278_SS,LOW);
+
+	//delay(1);
+	bitSet(address, 7);			// Bit 7 set to read from registers
+	SPI.transfer(address);
+	SPI.transfer(data);
+	digitalWrite(SX1278_SS,HIGH);
+	SPI.endTransaction();
+
+#if (SX1278FSK_debug_mode > 1)
+	Serial.print(F("## Writing:  ##\t"));
+	Serial.print(F("Register "));
+	bitClear(address, 7);
+	Serial.print(address, HEX);
+	Serial.print(F(":  "));
+	Serial.print(data, HEX);
+	Serial.println();
+#endif
+
+}
+
+/*
+ * Function: Clears the IRQ flags
+ * 
+ * Configuration registers are accessed through the SPI interface. 
+ * Registers are readable in all device mode including Sleep. However, they 
+ * should be written only in Sleep and Stand-by modes.
+ * 
+ * Returns: Nothing
+ */
+void SX1278FSK::clearIRQFlags()
+{
+	byte st0;
+
+	// Save the previous status
+	st0 = readRegister(REG_OP_MODE);		
+	// Stdby mode to write in registers
+	writeRegister(REG_OP_MODE, FSK_STANDBY_MODE);	
+	// FSK mode flags1 register
+	writeRegister(REG_IRQ_FLAGS1, 0xFF);
+	// FSK mode flags2 register 
+	writeRegister(REG_IRQ_FLAGS2, 0xFF);
+	// Getting back to previous status
+	if(st0 != FSK_STANDBY_MODE)  {
+		writeRegister(REG_OP_MODE, st0);
+	}
+#if (SX1278FSK_debug_mode > 1)
+	Serial.println(F("## FSK flags cleared ##"));
+#endif
+}
+
+/*
+Function: Sets the module in FSK mode.
+Returns:   Integer that determines if there has been any error
+	state = 2  --> The command has not been executed
+	state = 1  --> There has been an error while executing the command
+	state = 0  --> The command has been executed with no errors
+*/
+uint8_t SX1278FSK::setFSK()
+{
+	uint8_t state = 2;
+	byte st0;
+	byte config1;
+
+#if (SX1278FSK_debug_mode > 1)
+	Serial.println();
+	Serial.println(F("Starting 'setFSK'"));
+#endif
+
+	writeRegister(REG_OP_MODE, FSK_SLEEP_MODE);	// Sleep mode (mandatory to change mode)
+	// If we are in LORA mode, above line activate Sleep mode, but does not change mode to FSK
+	// as mode change is only allowed in sleep mode. Next line changes to FSK
+	writeRegister(REG_OP_MODE, FSK_SLEEP_MODE);
+
+	writeRegister(REG_OP_MODE, FSK_STANDBY_MODE);	// FSK standby mode
+
+	//writeRegister(REG_FIFO_THRESH, 0x80);	// condition to start packet tx
+	//config1 = readRegister(REG_SYNC_CONFIG);
+	//config1 = config1 & B00111111;
+	//writeRegister(REG_SYNC_CONFIG,config1);
+
+	delay(100);
+
+	st0 = readRegister(REG_OP_MODE);	// Reading config mode
+	if( st0 == FSK_STANDBY_MODE )
+	{ // FSK mode
+		state = 0;
+#if (SX1278FSK_debug_mode > 1)
+		Serial.println(F("## FSK set with success ##"));
+		Serial.println();
+#endif
+	} else { // LoRa mode
+		state = 1;
+		Serial.println( st0 );
+#if (SX1278FSK_debug_mode > 1)
+		Serial.println(F("** There has been an error while setting FSK **"));
+		Serial.println();
+#endif
+	}
+	return state;
+}
+
+
+/* Function: Sets FSK bitrate
+ * Returns: 0 for success, >0 in case of error
+ * Parameters: bps: requested bitrate
+ * (raw data rate, for Mancester encoding, the effective bitrate is bps/2)
+*/
+
+uint8_t SX1278FSK::setBitrate(float bps)
+{
+	// TODO: Check if FSK mode is active
+
+	// check if bitrate is allowed allowed bitrate
+	if((bps < 1200) || (bps > 300000)) {
+	  return 1;
+	}
+
+	// set mode to FSK STANDBY
+	writeRegister(REG_OP_MODE, FSK_STANDBY_MODE); 
+
+	// set bit rate
+	uint16_t bitRate = (SX127X_CRYSTAL_FREQ * 1.0) / bps;
+	writeRegister(REG_BITRATE_MSB, (bitRate & 0xFF00) >> 8);
+	writeRegister(REG_BITRATE_LSB, (bitRate & 0x00FF));
+
+	// also set fractional part
+	uint16_t fracRate = (SX127X_CRYSTAL_FREQ * 16.0) / bps - bitRate * 16 + 0.5;
+	writeRegister(REG_BIT_RATE_FRAC, fracRate&0x0F);
+	return 0;
+}
+/* Function: Gets configured bitrate 
+ * Returns bitrate in bit/second
+ */
+float SX1278FSK::getBitrate()
+{
+	uint8_t fmsb = readRegister(REG_BITRATE_MSB);
+	uint8_t flsb = readRegister(REG_BITRATE_LSB);
+	uint8_t ffrac = readRegister(REG_BIT_RATE_FRAC) & 0x0F;
+	return SX127X_CRYSTAL_FREQ / ( (fmsb<<8) + flsb + ffrac / 16.0 );
+}
+
+//typedef struct rxbwset { float bw; uint8_t mant; uint8_t rxp; } st_rxbwsettings;
+
+uint8_t SX1278FSK::setRxBandwidth(float bw)
+{
+	// TODO: Check if in FSK mode
+	//
+	if(bw<2600 || bw>250000) { return 1; /* invalid */ }
+
+	uint8_t rxbwexp = 1;
+	bw = SX127X_CRYSTAL_FREQ / bw / 8;
+	while(bw>31) { rxbwexp++; bw/=2.0; }
+	uint8_t rxbwmant = bw<17?0 : bw<21? 1:2;
+
+	// set mode to FSK STANDBY
+	writeRegister(REG_OP_MODE, FSK_STANDBY_MODE); 
+
+	writeRegister(REG_RX_BW, rxbwexp | (rxbwmant<<3));
+	return 0;
+}
+
+float SX1278FSK::getRxBandwidth()
+{
+	uint8_t rxbw = readRegister(REG_RX_BW);
+	uint8_t rxbwexp = rxbw&0x07;
+	uint8_t rxbwmant = (rxbw>>3)&0x03;
+	rxbwmant = 16 + 4*rxbwmant;
+	return SX127X_CRYSTAL_FREQ / ( rxbwmant << (rxbwexp+2));
+}
+
+uint8_t SX1278FSK::setAFCBandwidth(float bw)
+{
+	// TODO: Check if in FSK mode
+	//
+	if(bw<2600 || bw>250000) { return 1; /* invalid */ }
+
+	uint8_t rxbwexp = 1;
+	bw = SX127X_CRYSTAL_FREQ / bw / 8;
+	while(bw>31) { rxbwexp++; bw/=2.0; }
+	uint8_t rxbwmant = bw<17?0 : bw<21? 1:2;
+
+	// set mode to FSK STANDBY
+	writeRegister(REG_OP_MODE, FSK_STANDBY_MODE); 
+
+	writeRegister(REG_AFC_BW, rxbwexp | (rxbwmant<<3));
+	return 0;
+}
+
+float SX1278FSK::getAFCBandwidth()
+{
+	uint8_t rxbw = readRegister(REG_AFC_BW);
+	uint8_t rxbwexp = rxbw&0x07;
+	uint8_t rxbwmant = (rxbw>>3)&0x03;
+	rxbwmant = 16 + 4*rxbwmant;
+	return SX127X_CRYSTAL_FREQ / ( rxbwmant << (rxbwexp+2));
+}
+
+
+uint8_t SX1278FSK::setFrequency(float freq) {
+
+	// set mode to FSK STANDBY 
+	writeRegister(REG_OP_MODE, FSK_STANDBY_MODE);
+	freq += sonde.config.freqofs;  // manual frequency correction
+
+	uint32_t frf = freq * 1.0 * (1<<19) / SX127X_CRYSTAL_FREQ;
+	writeRegister(REG_FRF_MSB, (frf&0xff0000)>>16);
+	writeRegister(REG_FRF_MID, (frf&0x00ff00)>>8);
+	writeRegister(REG_FRF_LSB, (frf&0x0000ff));
+	return 0;
+}
+
+float SX1278FSK::getFrequency() {
+	uint8_t fmsb = readRegister(REG_FRF_MSB);
+	uint8_t fmid = readRegister(REG_FRF_MID);
+	uint8_t flsb = readRegister(REG_FRF_LSB);
+	return ((fmsb<<16)|(fmid<<8)|flsb) * 1.0 / (1<<19) * SX127X_CRYSTAL_FREQ;
+}
+
+
+static int gaintab[]={-999,0,-6,-12,-24,-36,-48,-999};
+int SX1278FSK::getLNAGain() {
+	int gain = (readRegister(REG_LNA)>>5)&0x07;
+	return gaintab[gain];
+}
+uint8_t SX1278FSK::setLNAGain(int gain) {
+	uint8_t g=1;
+	while(gain<gaintab[g] && g<6) {g++; }
+	writeRegister(REG_LNA, g<<5);
+	return 0;
+}
+
+uint8_t SX1278FSK::getRxConf() {
+	return readRegister(REG_RX_CONFIG);
+}
+uint8_t SX1278FSK::setRxConf(uint8_t conf) {
+	writeRegister(REG_RX_CONFIG, conf);
+	return 0;
+}
+
+uint8_t SX1278FSK::setSyncConf(uint8_t conf, int len, const uint8_t *syncpattern) {
+	int res=0;
+	writeRegister(REG_SYNC_CONFIG, conf);
+	if(len>8) return 1;
+	for(int i=0; i<len; i++) {
+		writeRegister(REG_SYNC_VALUE1+i, syncpattern[i]);
+	}
+	return res;
+}
+
+uint8_t SX1278FSK::getSyncConf() {
+	return sx1278.readRegister(REG_SYNC_CONFIG);
+}
+
+uint8_t SX1278FSK::setPreambleDetect(uint8_t conf) {
+	sx1278.writeRegister(REG_PREAMBLE_DETECT, conf);
+	return 0;
+}
+
+uint8_t SX1278FSK::getPreambleDetect() {
+	return sx1278.readRegister(REG_PREAMBLE_DETECT);
+}
+
+uint8_t SX1278FSK::setPacketConfig(uint8_t conf1, uint8_t conf2)
+{
+	uint8_t ret=0;
+	sx1278.writeRegister(REG_PACKET_CONFIG1, conf1);
+	sx1278.writeRegister(REG_PACKET_CONFIG2, conf2);
+	return ret;
+};
+uint16_t SX1278FSK::getPacketConfig() {
+	uint8_t c1 = sx1278.readRegister(REG_PACKET_CONFIG1);
+	uint8_t c2 = sx1278.readRegister(REG_PACKET_CONFIG2);
+	return (c2<<8)|c1;
+}
+
+/*
+Function: Gets the preamble length from the module.
+Returns: preamble length
+*/
+uint16_t SX1278FSK::getPreambleLength()
+{
+	uint16_t p_length;
+
+#if (SX1278FSK_debug_mode > 1)
+	Serial.println();
+	Serial.println(F("Starting 'getPreambleLength'"));
+#endif
+
+	p_length = readRegister(REG_PREAMBLE_MSB_FSK);
+	p_length = (p_length<<8) | readRegister(REG_PREAMBLE_LSB_FSK);
+#if (SX1278FSK_debug_mode > 1)
+		Serial.print(F("## Preamble length configured is "));
+		Serial.print(p_length, HEX);
+		Serial.print(F(" ##"));
+		Serial.println();
+#endif
+	return p_length;
+}
+
+/*
+Function: Sets the preamble length in the module
+Returns: Integer that determines if there has been any error
+state = 2  --> The command has not been executed
+state = 1  --> There has been an error while executing the command
+state = 0  --> The command has been executed with no errors
+Parameters:
+l: length value to set as preamble length.
+*/
+uint8_t SX1278FSK::setPreambleLength(uint16_t l)
+{
+	byte st0;
+	int8_t state = 2;
+
+#if (SX1278FSK_debug_mode > 1)
+	Serial.println();
+	Serial.println(F("Starting 'setPreambleLength'"));
+#endif
+
+	st0 = readRegister(REG_OP_MODE);	// Save the previous status
+
+	writeRegister(REG_OP_MODE, FSK_STANDBY_MODE);    // Set Standby mode to write in registers
+	// Storing MSB preamble length in FSK mode
+	writeRegister(REG_PREAMBLE_MSB_FSK, l>>8);
+	writeRegister(REG_PREAMBLE_LSB_FSK, l&0xFF);
+
+	state = 0;
+#if (SX1278FSK_debug_mode > 1)
+	Serial.print(F("## Preamble length "));
+	Serial.print(l, HEX);
+	Serial.println(F(" has been successfully set ##"));
+	Serial.println();
+#endif
+
+	if(st0 != FSK_STANDBY_MODE) {
+		writeRegister(REG_OP_MODE, st0);	// Getting back to previous status
+	}
+	return state;
+}
+
+/*
+Function: Gets the payload length from the module.
+Returns: configured length; -1 on error
+*/
+int SX1278FSK::getPayloadLength()
+{	
+	int length;
+#if (SX1278FSK_debug_mode > 1)
+	Serial.println();
+	Serial.println(F("Starting 'getPayloadLength'"));
+#endif
+	length = readRegister(REG_PAYLOAD_LENGTH_FSK);
+
+#if (SX1278FSK_debug_mode > 1)
+	Serial.print(F("## Payload length configured is "));
+	Serial.print(length);
+	Serial.println(F(" ##"));
+#endif
+	return length;
+}
+
+/*
+Function: Sets the payload length from the module.
+Returns: 0 for ok, otherwise error
+// TODO: Larger than 255 bytes?
+*/
+uint8_t SX1278FSK::setPayloadLength(int len)
+{	
+#if (SX1278FSK_debug_mode > 1)
+	Serial.print(F("Starting 'setPayloadLength'"));
+	Serial.println(len);
+#endif
+	uint8_t conf2 = readRegister(REG_PACKET_CONFIG2);
+	conf2 = (conf2 & 0xF8) | ( (len>>8)&0x7 );
+	writeRegister(REG_PACKET_CONFIG2, conf2);
+	writeRegister(REG_PAYLOAD_LENGTH_FSK, len&0xFF);
+	return 0;
+}
+
+/*
+Function: Gets the current value of RSSI.
+Returns: RSSI value
+*/
+int16_t SX1278FSK::getRSSI()
+{
+	int16_t RSSI;
+	//int rssi_mean = 0;
+	int total = 1;
+
+	/// FSK mode
+	// get mean value of RSSI
+	for(int i = 0; i < total; i++)
+	{
+		RSSI = readRegister(REG_RSSI_VALUE_FSK);
+		//rssi_mean += _RSSI;
+	}
+	//rssi_mean = rssi_mean / total;	
+	//RSSI = rssi_mean;
+
+#if (SX1278FSK_debug_mode > 0)
+	Serial.print(F("## RSSI value is "));
+	Serial.print(RSSI);
+	Serial.println(F(" ##"));
+#endif
+	return RSSI;
+}
+
+/*
+Function: Gets the current value of FEI (frequency error indication)
+Returns: FEI value in Hz
+*/
+int32_t SX1278FSK::getFEI()
+{
+	int32_t FEI;
+	int16_t regval = (readRegister(REG_FEI_MSB)<<8) | readRegister(REG_FEI_LSB);
+	//Serial.printf("feireg: %04x\n", regval);
+	FEI = (int32_t)(regval * SX127X_FSTEP);
+	return FEI;
+}
+/*
+Function: Gets the current value of AFC (automated frequency correction)
+Returns: AFC value in Hz
+*/
+int32_t SX1278FSK::getAFC()
+{
+	int32_t AFC;
+	int16_t regval = (readRegister(REG_AFC_MSB)<<8) | readRegister(REG_AFC_LSB);
+	//Serial.printf("afcreg: %04x\n", regval);
+	AFC = (int32_t)(regval * SX127X_FSTEP);
+	return AFC;
+}
+
+/*
+Function: Gets the current supply limit of the power amplifier, protecting battery chemistries.
+Returns: Integer that determines if there has been any error
+state = 2  --> The command has not been executed
+state = 1  --> There has been an error while executing the command
+state = 0  --> The command has been executed with no errors
+Parameters:
+rate: value to compute the maximum current supply. Maximum current is 45+5*'rate' [mA]
+*/
+int SX1278FSK::getMaxCurrent()
+{
+	int value;
+
+#if (SX1278FSK_debug_mode > 1)
+	Serial.println();
+	Serial.println(F("Starting 'getMaxCurrent'"));
+#endif
+
+	value = readRegister(REG_OCP);
+
+	// extract only the OcpTrim value from the OCP register
+	value &= B00011111;
+
+	if( value <= 15 ) {
+		value = (45 + (5 * value));
+	} else if( value <= 27 ) {
+		value = (-30 + (10 * value));
+	} else {
+		value = 240;		
+	}
+#if (SX1278FSK_debug_mode > 1)
+	Serial.print(F("## Maximum current supply configured is "));
+	Serial.print(value, DEC);
+	Serial.println(F(" mA ##"));
+	Serial.println();
+#endif
+	return value;
+}
+
+/*
+Function: Limits the current supply of the power amplifier, protecting battery chemistries.
+Returns: Integer that determines if there has been any error
+state = 2  --> The command has not been executed
+state = 1  --> There has been an error while executing the command
+state = 0  --> The command has been executed with no errors
+state = -1 --> Forbidden parameter value for this function
+Parameters:
+rate: value to compute the maximum current supply. Range: 0x00 to 0x1B. The 
+Maximum current is:
+Imax = 45+5*OcpTrim [mA] 	if OcpTrim <= 15 (120 mA) /
+Imax = -30+10*OcpTrim [mA] 	if 15 < OcpTrim <= 27 (130 to 240 mA)
+Imax = 240mA 				for higher settings
+*/
+int8_t SX1278FSK::setMaxCurrent(uint8_t rate)
+{
+	int8_t state = 2;
+	byte st0;
+
+#if (SX1278FSK_debug_mode > 1)
+	Serial.println();
+	Serial.println(F("Starting 'setMaxCurrent'"));
+#endif
+
+	// Maximum rate value = 0x1B, because maximum current supply = 240 mA
+	if (rate > 0x1B)
+	{
+		state = -1;
+#if (SX1278FSK_debug_mode > 1)
+		Serial.print(F("** Maximum current supply is 240 mA, "));
+		Serial.println(F("so maximum parameter value must be 27 (DEC) or 0x1B (HEX) **"));
+		Serial.println();
+#endif
+	}
+	else
+	{
+		// Enable Over Current Protection
+		rate |= B00100000;
+
+		state = 1;
+		st0 = readRegister(REG_OP_MODE);	// Save the previous status
+		writeRegister(REG_OP_MODE, FSK_STANDBY_MODE);	// Set FSK Standby mode to write in registers
+		writeRegister(REG_OCP, rate);		// Modifying maximum current supply
+		if(st0 != FSK_STANDBY_MODE) {
+			writeRegister(REG_OP_MODE, st0);		// Getting back to previous status
+		}
+		state = 0;
+	}
+	return state;
+}
+
+
+/*
+Function: Configures the module to receive information.
+Returns: Integer that determines if there has been any error
+state = 2  --> The command has not been executed
+state = 1  --> There has been an error while executing the command
+state = 0  --> The command has been executed with no errors
+*/
+uint8_t SX1278FSK::receive()
+{
+	uint8_t state = 1;
+#if (SX1278FSK_debug_mode > 1)
+	Serial.println();
+	Serial.println(F("Starting 'receive'"));
+#endif
+	// TODO: Is there anything else to be done?
+	//
+	writeRegister(REG_OP_MODE, FSK_RX_MODE);  
+	state = 0;
+#if (SX1278FSK_debug_mode > 1)
+		Serial.println(F("## Receiving FSK mode activated with success ##"));
+#endif
+	return state;
+}
+
+/*
+Function: Configures the module to receive a packet
+Returns: Integer that determines if there has been any error
+state = 2  --> The command has not been executed
+state = 1  --> There has been an error while executing the command
+state = 0  --> The command has been executed with no errors
+Parameters:
+	wait: timeout in ms
+	data: memory where to place received data
+*/
+uint8_t SX1278FSK::receivePacketTimeout(uint32_t wait, byte *data)
+{
+	int di=0;
+	uint8_t state = 2;
+	unsigned long previous;
+	byte value = 0x00;
+#if (SX1278FSK_debug_mode > 1)
+	Serial.println();
+	Serial.println(F("Starting 'receivePacketTimeout'"));
+#endif
+	// set RX mode
+	state = receive();
+	if(state != 0) { return state; }
+
+#if (SX1278FSK_debug_mode > 0)
+	Serial.println(F("RX mode sucessfully activated"));
+#endif
+	previous = millis();
+	/// FSK mode
+	value = readRegister(REG_IRQ_FLAGS2);
+	byte ready=0;
+	// while not yet done or FIFO not yet empty
+	while( (!ready || bitRead(value,6)==0) && (millis() - previous < wait) )
+	{
+		if( bitRead(value,2)==1 ) ready=1;
+		if( bitRead(value, 6) == 0 ) { // FIFO not empty
+			data[di++] = readRegister(REG_FIFO);
+			// It's a bit of a hack.... get RSSI and AFC (a) at beginning of packet and
+			// for RS41 after about 0.5 sec. It might be more logical to put this decoder-specific
+			// code into RS41.cpp instead of this file... (maybe TODO?)
+			
+			if(di==1 || di==290 ) {
+				int rssi=getRSSI();
+				int afc=getAFC();
+#if 0
+				Serial.printf("Test(%d): RSSI=%d", rxtask.currentSonde, rssi/2);
+				Serial.print("Test: AFC="); Serial.println(afc);
+#endif
+				sonde.sondeList[rxtask.currentSonde].rssi = rssi;
+				sonde.sondeList[rxtask.currentSonde].afc = afc;
+				if(rxtask.receiveResult==0xFFFF)
+					rxtask.receiveResult = RX_UPDATERSSI;
+				//sonde.si()->rssi = rssi;
+				//sonde.si()->afc = afc;
+			}
+			if(di>520) {
+				// TODO
+				Serial.println("TOO MUCH DATA");
+				break;
+			}
+			previous = millis(); // reset timeout after receiving data
+		} else {
+			delay(10);
+		}
+		value = readRegister(REG_IRQ_FLAGS2);
+	}
+	if( !ready || bitRead(value, 6)==0) {
+#if 1&&(SX1278FSK_debug_mode > 0)
+		Serial.println(F("** The timeout has expired **"));
+		Serial.println();
+#endif
+		sonde.si()->rssi = getRSSI();
+		writeRegister(REG_OP_MODE, FSK_STANDBY_MODE);	// Setting standby FSK mode
+		return 1;  // TIMEOUT
+	}
+
+#if (SX1278FSK_debug_mode > 0)
+	Serial.println(F("## Packet received:"));
+	for(unsigned int i = 0; i < di; i++)
+	{
+		Serial.print(data[i], HEX);		// Printing payload
+		Serial.print("|");
+	}
+	Serial.println(F(" ##"));
+#endif
+	state = 0;
+	// Initializing flags	
+	clearIRQFlags();	
+
+	return state;
+}
+
+
+#if 0
+/*
+Function: It gets the temperature from the measurement block module.
+Returns: Integer that determines if there has been any error
+state = 2  --> The command has not been executed
+state = 1  --> There has been an error while executing the command
+state = 0  --> The command has been executed with no errors
+*/
+uint8_t SX1278FSK::getTemp()
+{
+	byte st0;
+	uint8_t state = 2;
+
+#if (SX1278FSK_debug_mode > 1)
+	Serial.println();
+	Serial.println(F("Starting 'getTemp'"));
+#endif
+
+	st0 = readRegister(REG_OP_MODE);	// Save the previous status
+
+	if( _modem == LORA )
+	{ // Allowing access to FSK registers while in LoRa standby mode
+		writeRegister(REG_OP_MODE, LORA_STANDBY_FSK_REGS_MODE);
+	}
+
+	state = 1;
+	// Saving temperature value
+	_temp = readRegister(REG_TEMP);
+	if( _temp & 0x80 ) // The SNR sign bit is 1
+	{
+		// Invert and divide by 4
+		_temp = ( ( ~_temp + 1 ) & 0xFF );
+	}
+	else
+	{
+		// Divide by 4
+		_temp = ( _temp & 0xFF );
+	}
+
+
+#if (SX1278FSK_debug_mode > 1)
+	Serial.print(F("## Temperature is: "));
+	Serial.print(_temp);
+	Serial.println(F(" ##"));
+	Serial.println();
+#endif
+
+	if( _modem == LORA )
+	{
+		writeRegister(REG_OP_MODE, st0);	// Getting back to previous status
+	}
+
+	state = 0;
+	return state;
+}
+
+/*
+Function: It prints the registers related to RX
+Returns: Integer that determines if there has been any error
+state = 2  --> The command has not been executed
+state = 1  --> There has been an error while executing the command
+state = 0  --> The command has been executed with no errors
+*/
+void SX1278FSK::showRxRegisters()
+{	
+	Serial.println(F("\n--- Show RX register ---"));
+
+	// variable
+	byte reg;	
+
+	for(int i = 0x00; i < 0x80; i++)
+	{
+		reg = readRegister(i);	
+		Serial.print(F("Reg 0x"));
+		Serial.print(i, HEX);
+		Serial.print(F(":"));
+		Serial.print(reg, HEX);
+		Serial.println();
+		delay(100);
+	}
+
+	Serial.println(F("------------------------"));
+
+}
+#endif
+
+SX1278FSK sx1278 = SX1278FSK();
diff --git a/libraries/SX1278FSK/SX1278FSK.h b/libraries/SX1278FSK/SX1278FSK.h
new file mode 100755
index 0000000..3cb358a
--- /dev/null
+++ b/libraries/SX1278FSK/SX1278FSK.h
@@ -0,0 +1,278 @@
+/*
+ * Functions for using SX127x in FSK mode (mainly receive)
+ * Copyright (C) 2019 Hansi Reiser, dl9rdz
+ *
+ * Partially based on the SX1278 libraray for managing Semtech modules
+ *  Copyright (C) 2015 Wireless Open Source
+ *  http://wirelessopensource.com
+ *
+ *  SPDX-License-Identifier:	LGPL-2.1+
+ */
+
+#ifndef SX1278FSK_h
+#define SX1278FSK_h
+
+/******************************************************************************
+ * Includes
+ ******************************************************************************/
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <Arduino.h>
+#include <SPI.h>
+
+#ifndef inttypes_h
+	#include <inttypes.h>
+#endif
+
+
+/******************************************************************************
+ * Definitions & Declarations
+ *****************************************************************************/
+
+#define SX127X_CRYSTAL_FREQ 32000000
+#define SX127X_FSTEP (SX127X_CRYSTAL_FREQ*1.0/(1<<19))
+
+#define SX1278FSK_debug_mode 0
+
+#define SX1278_SS SS
+
+//! MACROS //
+#define bitRead(value, bit) (((value) >> (bit)) & 0x01)  // read a bit
+#define bitSet(value, bit) ((value) |= (1UL << (bit)))    // set bit to '1'
+#define bitClear(value, bit) ((value) &= ~(1UL << (bit))) // set bit to '0'
+
+
+//! REGISTERS //
+//							FSK	Commun	LORA
+#define        REG_FIFO        					0x00
+#define        REG_OP_MODE        				0x01
+#define        REG_BITRATE_MSB    			0x02
+#define        REG_BITRATE_LSB    			0x03
+#define        REG_FDEV_MSB   				0x04
+#define        REG_FDEV_LSB    				0x05
+#define        REG_FRF_MSB    					0x06
+#define        REG_FRF_MID    					0x07
+#define        REG_FRF_LSB    					0x08
+#define        REG_PA_CONFIG    				0x09
+#define        REG_PA_RAMP    					0x0A
+#define        REG_OCP    					0x0B
+#define        REG_LNA    					0x0C
+#define        REG_RX_CONFIG    			0x0D
+#define        REG_FIFO_ADDR_PTR  					0x0D
+#define        REG_RSSI_CONFIG   			0x0E
+#define        REG_FIFO_TX_BASE_ADDR 		    			0x0E
+#define        REG_RSSI_COLLISION    			0x0F
+#define        REG_FIFO_RX_BASE_ADDR   					0x0F
+#define        REG_RSSI_THRESH    			0x10
+#define        REG_FIFO_RX_CURRENT_ADDR   				0x10
+#define        REG_RSSI_VALUE_FSK	    		0x11
+#define        REG_IRQ_FLAGS_MASK    					0x11
+#define        REG_RX_BW		    		0x12
+#define        REG_IRQ_FLAGS	    					0x12
+#define        REG_AFC_BW		    		0x13
+#define        REG_RX_NB_BYTES	    					0x13
+#define        REG_OOK_PEAK	    			0x14
+#define        REG_RX_HEADER_CNT_VALUE_MSB  				0x14
+#define        REG_OOK_FIX	    			0x15
+#define        REG_RX_HEADER_CNT_VALUE_LSB  				0x15
+#define        REG_OOK_AVG	 			0x16
+#define        REG_RX_PACKET_CNT_VALUE_MSB  				0x16
+#define        REG_RX_PACKET_CNT_VALUE_LSB  				0x17
+#define        REG_MODEM_STAT	  					0x18
+#define        REG_PKT_SNR_VALUE	  				0x19
+#define        REG_AFC_FEI	  			0x1A
+#define        REG_PKT_RSSI_VALUE	  				0x1A
+#define        REG_AFC_MSB	  			0x1B
+#define        REG_RSSI_VALUE_LORA	  				0x1B
+#define        REG_AFC_LSB	  			0x1C
+#define        REG_HOP_CHANNEL	  					0x1C
+#define        REG_FEI_MSB	  			0x1D
+#define        REG_MODEM_CONFIG1	 		 		0x1D
+#define        REG_FEI_LSB	  			0x1E
+#define        REG_MODEM_CONFIG2	  				0x1E
+#define        REG_PREAMBLE_DETECT  			0x1F
+#define        REG_SYMB_TIMEOUT_LSB  					0x1F
+#define        REG_RX_TIMEOUT1	  			0x20
+#define        REG_PREAMBLE_MSB_LORA  					0x20
+#define        REG_RX_TIMEOUT2	  			0x21
+#define        REG_PREAMBLE_LSB_LORA  					0x21
+#define        REG_RX_TIMEOUT3	 			0x22
+#define        REG_PAYLOAD_LENGTH_LORA			 		0x22
+#define        REG_RX_DELAY	 			0x23
+#define        REG_MAX_PAYLOAD_LENGTH 					0x23
+#define        REG_OSC		 			0x24
+#define        REG_HOP_PERIOD	  					0x24
+#define        REG_PREAMBLE_MSB_FSK 			0x25
+#define        REG_FIFO_RX_BYTE_ADDR 					0x25
+#define        REG_PREAMBLE_LSB_FSK 			0x26
+#define        REG_MODEM_CONFIG3	 		 		0x26
+#define        REG_SYNC_CONFIG	  			0x27
+#define        REG_SYNC_VALUE1	 			0x28
+#define	       REG_LORA_FEI_MSB						0x28
+#define        REG_SYNC_VALUE2	  			0x29
+#define	       REG_LORA_FEI_MID						0x29
+#define        REG_SYNC_VALUE3	  			0x2A
+#define	       REG_LORA_FEI_LSB						0x2A
+#define        REG_SYNC_VALUE4	  			0x2B
+#define        REG_SYNC_VALUE5	  			0x2C
+#define	       REG_RSSI_WIDEBAND					0x2C
+#define        REG_SYNC_VALUE6	  			0x2D
+#define        REG_SYNC_VALUE7	  			0x2E
+#define        REG_SYNC_VALUE8	  			0x2F
+#define        REG_PACKET_CONFIG1	  		0x30
+#define        REG_PACKET_CONFIG2	  		0x31
+#define        REG_DETECT_OPTIMIZE	  				0x31
+#define        REG_PAYLOAD_LENGTH_FSK			0x32
+#define        REG_NODE_ADRS	  			0x33
+#define        REG_INVERT_IQ						0x33
+#define        REG_BROADCAST_ADRS	 		0x34
+#define        REG_FIFO_THRESH	  			0x35
+#define        REG_SEQ_CONFIG1	  			0x36
+#define        REG_SEQ_CONFIG2	  			0x37
+#define        REG_DETECTION_THRESHOLD 					0x37
+#define        REG_TIMER_RESOL	  			0x38
+#define        REG_TIMER1_COEF	  			0x39
+#define        REG_SYNC_WORD						0x39
+#define        REG_TIMER2_COEF	  			0x3A
+#define        REG_IMAGE_CAL	  			0x3B
+#define        REG_TEMP		  			0x3C
+#define        REG_LOW_BAT	  			0x3D
+#define        REG_IRQ_FLAGS1	  			0x3E
+#define        REG_IRQ_FLAGS2	  			0x3F
+#define        REG_DIO_MAPPING1	  				0x40
+#define        REG_DIO_MAPPING2	  				0x41
+#define        REG_VERSION	  				0x42
+#define        REG_PLL_HOP	  			0x44
+#define        REG_TCXO		  				0x4B
+#define        REG_PA_DAC	  				0x4D
+#define        REG_FORMER_TEMP	  				0x5B
+#define        REG_BIT_RATE_FRAC			0x5D
+#define        REG_AGC_REF	  				0x61
+#define        REG_AGC_THRESH1		  			0x62
+#define        REG_AGC_THRESH2		  			0x63
+#define        REG_AGC_THRESH3	  				0x64
+#define        REG_PLL			  			0x70
+
+
+//FSK MODES:
+const uint8_t FSK_SLEEP_MODE = 0x00;
+const uint8_t FSK_STANDBY_MODE = 0x01;
+const uint8_t FSK_TX_MODE = 0x03;
+const uint8_t FSK_RX_MODE = 0x05;
+
+
+/******************************************************************************
+ * SX1278FSK Class
+ * Functions and variables for managing SX127x transceiver chips in FSK mode,
+ * mainly for receiving radiosonde transmissions
+ ******************************************************************************/
+class SX1278FSK
+{
+public:
+	// class constructor
+   	SX1278FSK();
+   	
+	// Turn on SX1278 module (return 0 on sucess, 1 otherwise)
+	uint8_t ON();
+
+	// Turn off SX1278 module
+	void OFF();
+
+	// Read internal register
+	byte readRegister(byte address);
+
+	// Write internal register
+	void writeRegister(byte address, byte data);
+
+	// Clear IRQ flags
+	void clearIRQFlags();
+
+	// Activate FSK mode (return 0 on success, 1 otherwise)
+	uint8_t setFSK();
+
+	// Configures bitrate register (closest approximation to requested bitrate)
+ 	uint8_t setBitrate(float bps);
+ 	float getBitrate();
+
+	// Configures RX bandwidth (next largest supported bandwith if exact value not possible)
+ 	uint8_t setRxBandwidth(float bps);
+ 	float getRxBandwidth();
+
+	// Configures AFC bandwidth (next largest supported bandwith if exact value not possible)
+ 	uint8_t setAFCBandwidth(float bps);
+ 	float getAFCBandwidth();
+
+	// Configures RX frequency (closest approximation to requested frequency)
+ 	uint8_t setFrequency(float freq);
+ 	float getFrequency();
+	
+	int getLNAGain();
+	uint8_t setLNAGain(int gain);
+
+	uint8_t getRxConf();
+	uint8_t setRxConf(uint8_t conf);
+
+	uint8_t setSyncConf(uint8_t conf, int len, const uint8_t *syncpattern);
+	uint8_t getSyncConf();
+
+	uint8_t setPreambleDetect(uint8_t conf);
+	uint8_t getPreambleDetect();
+
+	uint8_t setPacketConfig(uint8_t conf1, uint8_t conf2);
+	uint16_t getPacketConfig();
+
+	// Get configured preamble length (used for TX only?)
+	uint16_t getPreambleLength();
+
+	// Sets the preamble length.
+	uint8_t setPreambleLength(uint16_t l);
+
+	// Gets the payload length (expected length for receive)
+	int getPayloadLength();
+	uint8_t setPayloadLength(int len);
+
+	// Get current RSSI value
+	int16_t getRSSI();
+
+	// Get current FEI (frequency error indication) value
+	int32_t getFEI();
+
+	// Get current AFC value
+	int32_t getAFC();
+
+	// Get the maximum current supply by the module.
+	int getMaxCurrent();
+
+	// Set the maximum current supply by the module.
+	int8_t setMaxCurrent(uint8_t rate);
+
+	// Put the module in reception mode.
+	//return '0' on success, '1' otherwise
+	uint8_t receive();
+
+	// Receive a packet
+        uint8_t receivePacketTimeout(uint32_t wait, byte *data);
+
+
+
+#if 0
+	//! It gets the internal temperature of the module.
+	/*!
+	It stores in global '_temp' variable the module temperature.
+	\return '0' on success, '1' otherwise
+	*/
+	uint8_t getTemp();
+	
+	//! It prints the registers related to RX via USB
+	/*!
+	 * \return void
+	*/
+	void showRxRegisters();	
+#endif
+
+};
+
+extern SX1278FSK	sx1278;
+
+#endif
diff --git a/libraries/SondeLib/DFM.cpp b/libraries/SondeLib/DFM.cpp
new file mode 100755
index 0000000..9e6467a
--- /dev/null
+++ b/libraries/SondeLib/DFM.cpp
@@ -0,0 +1,347 @@
+
+/* DFM decoder functions */
+#include "DFM.h"
+#include "SX1278FSK.h"
+#include "Sonde.h"
+
+#define DFM_DEBUG 1
+
+#if DFM_DEBUG
+#define DFM_DBG(x) x
+#else
+#define DFM_DBG(x)
+#endif
+
+int DFM::setup(float frequency, int inv) 
+{
+	inverse = inv;
+#if DFM_DEBUG
+	Serial.printf("Setup sx1278 for DFM sonde (inv=%d)\n",inv);
+#endif
+	if(sx1278.ON()!=0) {
+		DFM_DBG(Serial.println("Setting SX1278 power on FAILED"));
+		return 1;
+	}
+	if(sx1278.setFSK()!=0) {
+		DFM_DBG(Serial.println("Setting FSM mode FAILED"));
+		return 1;
+	}
+	if(sx1278.setBitrate(2500)!=0) {
+		DFM_DBG(Serial.println("Setting bitrate 2500bit/s FAILED"));
+		return 1;
+	}
+#if DFM_DEBUG
+	float br = sx1278.getBitrate();
+	Serial.print("Exact bitrate is ");
+	Serial.println(br);
+#endif
+
+        if(sx1278.setAFCBandwidth(sonde.config.dfm.agcbw)!=0) {
+                DFM_DBG(Serial.printf("Setting AFC bandwidth %d Hz FAILED", sonde.config.dfm.agcbw));
+                return 1;
+        }
+        if(sx1278.setRxBandwidth(sonde.config.dfm.rxbw)!=0) {
+                DFM_DBG(Serial.printf("Setting RX bandwidth to %d Hz FAILED", sonde.config.dfm.rxbw));
+                return 1;
+        }
+	// Enable auto-AFC, auto-AGC, RX Trigger by preamble
+	if(sx1278.setRxConf(0x1E)!=0) {
+		DFM_DBG(Serial.println("Setting RX Config FAILED"));
+		return 1;
+	}
+	// Set autostart_RX to 01, preamble 0, SYNC detect==on, syncsize=3 (==4 byte
+	//char header[] = "0110.0101 0110.0110 1010.0101 1010.1010";
+
+	const char *SYNC=inverse?"\x9A\x99\x5A\x55":"\x65\x66\xA5\xAA";
+	if(sx1278.setSyncConf(0x53, 4, (const uint8_t *)SYNC)!=0) {
+		DFM_DBG(Serial.println("Setting SYNC Config FAILED"));
+		return 1;
+	}
+	if(sx1278.setPreambleDetect(0xA8)!=0) {
+		DFM_DBG(Serial.println("Setting PreambleDetect FAILED"));
+		return 1;
+	}
+
+	// Packet config 1: fixed len, mancecer, no crc, no address filter
+	// Packet config 2: packet mode, no home ctrl, no beackn, msb(packetlen)=0)
+	if(sx1278.setPacketConfig(0x28, 0x40)!=0) {
+		DFM_DBG(Serial.println("Setting Packet config FAILED"));
+		return 1;
+	}
+        Serial.print("DFM: setting RX frequency to ");
+        Serial.println(frequency);
+
+	int retval = sx1278.setFrequency(frequency);
+        sx1278.clearIRQFlags();
+	DFM_DBG(Serial.println("Setting SX1278 config for DFM finished\n"); Serial.println());
+	return retval;
+}
+
+
+#define bitpick(value,bitpos) (((value)>>(7-(bitpos)))&0x01)
+// Input: str: packed data, MSB first
+void DFM::deinterleave(uint8_t *str, int L, uint8_t *block) {
+	int i, j;
+	for (j = 0; j < B; j++) {  // L = 7 (CFG), 13 (DAT1, DAT2)
+		for (i = 0; i < L; i++) {
+			block[B*i+j] = bitpick( str[(L*j+i)/8], (L*j+i)&7 )?0:1;
+		}
+	}
+}
+        
+uint32_t DFM::bits2val(const uint8_t *bits, int len) {
+	uint32_t val = 0;
+	for (int j = 0; j < len; j++) {
+		val |= (bits[j] << (len-1-j));
+	}
+	return val;
+}
+
+// Error correction for hamming code
+// returns 0: ok   >0: 1 error was corrected -1: uncorrectable error
+int DFM::check(uint8_t code[8]) {
+	int i, j;            
+	uint32_t synval = 0;  
+	uint8_t syndrom[4];   
+	int ret=0;
+
+	for (i = 0; i < 4; i++) { 
+		syndrom[i] = 0;
+		for (j = 0; j < 8; j++) { 
+			syndrom[i] ^= H[i][j] & code[j];
+		}
+	}
+	synval = bits2val(syndrom, 4);
+	if (synval) {
+		ret = -1;
+		for (j = 0; j < 8; j++) {   // 1-bit-error
+			if (synval == He[j]) {  // reicht auf databits zu pruefen, d.h.
+				ret = j+1;          // (systematischer Code) He[0..3]
+				break;
+			}
+		}
+	}
+	else ret = 0;
+	if (ret > 0) code[ret-1] ^= 0x1;
+
+	return ret;
+}
+
+// Extended (8,4) Hamming code
+// Return number of corrected bits, -1 if uncorrectable error
+int DFM::hamming(uint8_t *ham, int L, uint8_t *sym) {
+	int i, j;
+	int ret = 0;               // DFM: length L = 7 or 13
+	for (i = 0; i < L; i++) {  // L bytes (4bit data, 4bit parity)
+		if (use_ecc) {
+			int res = check(ham+8*i);
+			if(ret>=0 && res>=0) ret += res; else ret=-1;
+		}
+		// systematic Hamming code: copy bits 0..3
+		for (j = 0; j < 4; j++) {
+			sym[4*i+j] = ham[8*i+j];
+		}
+	}
+	return ret;
+}
+
+DFM::DFM() {
+}
+
+void DFM::printRaw(const char *label, int len, int ret, const uint8_t *data)
+{
+	Serial.print(label); Serial.print("(");
+	Serial.print(ret);
+	Serial.print("):");
+	int i;
+	for(i=0; i<len/2; i++) {
+		char str[10];
+		snprintf(str, 10, "%02X", data[i]);
+		Serial.print(str);
+	}
+	Serial.print(data[i]&0x0F, HEX);
+	Serial.print(" ");
+}
+
+void DFM::decodeCFG(uint8_t *cfg)
+{
+	static int lowid, highid, idgood=0, type=0;
+	if((cfg[0]>>4)==0x06 && type==0) {   // DFM-6 ID
+		lowid = ((cfg[0]&0x0F)<<20) | (cfg[1]<<12) | (cfg[2]<<4) | (cfg[3]&0x0f);
+		Serial.print("DFM-06 ID: "); Serial.print(lowid, HEX);
+		snprintf(sonde.si()->id, 10, "%x", lowid);
+		sonde.si()->validID = true;
+	}
+	if((cfg[0]>>4)==0x0A) {  // DMF-9 ID
+		type=9;
+		if(cfg[3]==1) {
+			lowid = (cfg[1]<<8) | cfg[2];
+			idgood |= 1;
+		} else {
+			highid = (cfg[1]<<8) | cfg[2];
+			idgood |= 2;
+		}
+		if(idgood==3) {
+			uint32_t dfmid = (highid<<16) | lowid;
+			Serial.print("DFM-09 ID: "); Serial.print(dfmid); 
+			snprintf(sonde.si()->ser, 10, "%d", dfmid);
+	                // dxlAPRS sonde number (DF6 (why??) and 5 last digits of serial number as hex number
+			snprintf(sonde.si()->id, 9, "DF6%05X", dfmid&0xfffff);
+			sonde.si()->validID = true;
+		}
+	}
+}
+
+static int bitCount(int x) {
+    int m4 = 0x1 | (0x1<<8) | (0x1<<16) | (0x1<<24);
+    int m1 = 0xFF; 
+    int s4 = (x&m4) + ((x>>1)&m4) + ((x>>2)&m4) + ((x>>3)&m4) + ((x>>4)&m4) + ((x>>5)&m4) + ((x>>6)&m4) + ((x>>7)&m4);
+    int s1 = (s4&m1) + ((s4>>8)&m1) + ((s4>>16)&m1) + ((s4>>24)&m1);
+    return s1;
+}
+
+static uint16_t MON[]={0,0,31,59,90,120,151,181,212,243,273,304,334};
+
+void DFM::decodeDAT(uint8_t *dat)
+{
+	Serial.print(" DAT["); Serial.print(dat[6]); Serial.print("]: ");
+	switch(dat[6]) {
+	case 0:
+		Serial.print("Packet counter: "); Serial.print(dat[3]);	
+		sonde.si()->frame = dat[3];
+		break;
+	case 1:
+		{
+		int val = (((uint16_t)dat[4])<<8) + (uint16_t)dat[5];
+		Serial.print("UTC-msec: "); Serial.print(val);
+		sonde.si()->sec = val/1000;
+		uint32_t tmp = ((uint32_t)dat[0]<<24) + ((uint32_t)dat[1]<<16) + ((uint32_t)dat[2]<<8) + ((uint32_t)dat[3]);
+		sonde.si()->sats = bitCount(tmp); // maybe!?!?!?
+		}
+		break;
+	case 2:
+		{
+		float lat, vh;
+		lat = ((uint32_t)dat[0]<<24) + ((uint32_t)dat[1]<<16) + ((uint32_t)dat[2]<<8) + ((uint32_t)dat[3]);
+		vh = ((uint16_t)dat[4]<<8) + dat[5];
+		Serial.print("GPS-lat: "); Serial.print(lat*0.0000001);
+		Serial.print(", hor-V: "); Serial.print(vh*0.01);
+		sonde.si()->lat = lat*0.0000001;
+		sonde.si()->hs = vh*0.01;
+		sonde.si()->validPos |= 0x11; 
+		}
+		break;
+	case 3:
+		{
+		float lon, dir;
+		lon = ((uint32_t)dat[0]<<24) + ((uint32_t)dat[1]<<16) + ((uint32_t)dat[2]<<8) + (uint32_t)dat[3];
+		dir = ((uint16_t)dat[4]<<8) + dat[5];
+		Serial.print("GPS-lon: "); Serial.print(lon*0.0000001);
+		Serial.print(", dir: "); Serial.print(dir*0.01);
+		sonde.si()->lon = lon*0.0000001;
+		sonde.si()->dir = dir*0.01;
+		sonde.si()->validPos |= 0x42;
+		}
+		break;
+	case 4:
+		{
+		float alt, vv;
+		alt = ((uint32_t)dat[0]<<24) + ((uint32_t)dat[1]<<16) + ((uint32_t)dat[2]<<8) + dat[3];
+		vv = (int16_t)( ((int16_t)dat[4]<<8) | dat[5] );
+		Serial.print("GPS-height: "); Serial.print(alt*0.01);
+		Serial.print(", vv: "); Serial.print(vv*0.01);
+		sonde.si()->alt = alt*0.01;
+		sonde.si()->vs = vv*0.01;
+		sonde.si()->validPos |= 0x0C;
+		}
+		break;
+	case 8:
+		{
+		int y = (dat[0]<<4) + (dat[1]>>4);
+		int m = dat[1]&0x0F;
+		int d = dat[2]>>3;
+		int h = ((dat[2]&0x07)<<2) + (dat[3]>>6);
+		int mi = (dat[3]&0x3F);
+		char buf[100];
+		snprintf(buf, 100, "%04d-%02d-%02d %02d:%02dz", y, m, d, h, mi);
+		Serial.print("Date: "); Serial.print(buf);
+		// convert to unix time
+		int tt = (y-1970)*365 + (y-1969)/4; // days since 1970
+		if(m<=12) { tt += MON[m]; if((y%4)==0 && m>2) tt++; }
+		tt = (tt+d-1)*(60*60*24) + h*3600 + mi*60;
+		sonde.si()->time = tt;
+		}
+		break;
+	default:
+		Serial.print("(?)");
+		break;
+	}
+}
+
+void DFM::bitsToBytes(uint8_t *bits, uint8_t *bytes, int len)
+{
+	int i;
+	for(i=0; i<len*4; i++) {
+		//Serial.print(bits[i]?"1":"0");
+	       	bytes[i/8] = (bytes[i/8]<<1) | (bits[i]?1:0);
+	}
+	bytes[(i-1)/8] &= 0x0F;
+}
+
+int DFM::receive() {
+	byte data[1000];  // pending data from previous mode may write more than 33 bytes. TODO. 
+	for(int i=0; i<2; i++) {
+	sx1278.setPayloadLength(33);    // Expect 33 bytes (7+13+13 bytes)
+
+	sx1278.writeRegister(REG_OP_MODE, FSK_RX_MODE);
+	int e = sx1278.receivePacketTimeout(1000, data);
+	if(e) { return RX_TIMEOUT; } //if timeout... return 1
+
+	Serial.printf("inverse is %d\b", inverse);
+	if(!inverse) { for(int i=0; i<33; i++) { data[i]^=0xFF; } }
+	deinterleave(data, 7, hamming_conf);
+	deinterleave(data+7, 13, hamming_dat1);
+	deinterleave(data+20, 13, hamming_dat2);
+  
+	int ret0 = hamming(hamming_conf,  7, block_conf);
+	int ret1 = hamming(hamming_dat1, 13, block_dat1);
+	int ret2 = hamming(hamming_dat2, 13, block_dat2);
+
+	byte byte_conf[4], byte_dat1[7], byte_dat2[7];
+	bitsToBytes(block_conf, byte_conf, 7);
+	bitsToBytes(block_dat1, byte_dat1, 13);
+	bitsToBytes(block_dat2, byte_dat2, 13);
+
+	printRaw("CFG", 7, ret0, byte_conf);
+	printRaw("DAT", 13, ret1, byte_dat1);
+	printRaw("DAT", 13, ret2, byte_dat2);
+	decodeCFG(byte_conf);
+	decodeDAT(byte_dat1);
+	decodeDAT(byte_dat2);
+	}
+	return RX_OK;
+}
+
+// moved to a single function in Sonde(). This function can be used for additional
+// processing here, that takes too long for doing in the RX task loop
+int DFM::waitRXcomplete() {
+#if 0
+	int res=0;
+	uint32_t t0 = millis();
+	while( rxtask.receiveResult < 0 && millis()-t0 < 2000) { delay(50); }
+
+	if( rxtask.receiveResult<0 || rxtask.receiveResult==RX_TIMEOUT) { 
+                res = RX_TIMEOUT;
+        } else if ( rxtask.receiveResult ==0) {
+                res = RX_OK;
+        } else {
+                res = RX_ERROR;
+        }
+        rxtask.receiveResult = -1;
+        Serial.printf("waitRXcomplete returning %d\n", res);
+        return res;
+#endif
+	return 0;
+}
+
+DFM dfm = DFM();
diff --git a/libraries/SondeLib/DFM.h b/libraries/SondeLib/DFM.h
new file mode 100755
index 0000000..aef7b87
--- /dev/null
+++ b/libraries/SondeLib/DFM.h
@@ -0,0 +1,67 @@
+/*
+ * DFM.h
+ * Functions for decoding DFM sondes with SX127x chips
+ * Copyright (C) 2019 Hansi Reiser, dl9rdz
+ *
+ * SPDX-License-Identifier:	GPL-2.0+
+ */
+
+#ifndef DFM_h
+#define DFM_h
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <Arduino.h>
+#ifndef inttypes_h
+        #include <inttypes.h>
+#endif
+
+#define DFM_NORMAL 0
+#define DFM_INVERSE 1
+
+/* Main class */
+class DFM
+{
+private:
+	int inverse=0;
+
+	void deinterleave(uint8_t *str, int L, uint8_t *block);
+	uint32_t bits2val(const uint8_t *bits, int len);
+	int check(uint8_t code[8]);
+	int hamming(uint8_t *ham, int L, uint8_t *sym);
+	void printRaw(const char *prefix, int len, int ret, const uint8_t* data);
+	void decodeCFG(uint8_t *cfg);
+	void decodeDAT(uint8_t *dat);
+	void bitsToBytes(uint8_t *bits, uint8_t *bytes, int len);
+
+#define B 8
+#define S 4
+	uint8_t hamming_conf[ 7*B];  //  7*8=56
+	uint8_t hamming_dat1[13*B];  // 13*8=104
+	uint8_t hamming_dat2[13*B];
+
+	uint8_t block_conf[ 7*S];  //  7*4=28
+	uint8_t block_dat1[13*S];  // 13*4=52
+	uint8_t block_dat2[13*S];
+
+	uint8_t H[4][8] =  // extended Hamming(8,4) particy check matrix
+             {{ 0, 1, 1, 1, 1, 0, 0, 0},
+              { 1, 0, 1, 1, 0, 1, 0, 0},
+              { 1, 1, 0, 1, 0, 0, 1, 0},
+              { 1, 1, 1, 0, 0, 0, 0, 1}};
+	uint8_t He[8] = { 0x7, 0xB, 0xD, 0xE, 0x8, 0x4, 0x2, 0x1};  // Spalten von H:
+                                                            // 1-bit-error-Syndrome
+
+public:
+	DFM();
+	// main decoder API
+	int setup(float frequency, int inverse);
+	int receive();
+	int waitRXcomplete();
+
+	int use_ecc = 1;
+};
+
+extern DFM dfm;
+
+#endif
diff --git a/libraries/SondeLib/DefaultFonts.c b/libraries/SondeLib/DefaultFonts.c
new file mode 100755
index 0000000..665c6ac
--- /dev/null
+++ b/libraries/SondeLib/DefaultFonts.c
@@ -0,0 +1,367 @@
+//        SPDX-License-Identifier:        GPL-3.0
+//      original source: https://github.com/Nkawu/TFT_22_ILI9225
+
+
+#ifdef __AVR__
+  #include <avr/pgmspace.h>
+#elif defined(ESP8266) || defined(ESP32)
+  #include <pgmspace.h>
+#endif
+
+#if defined(ARDUINO_ARCH_SAM) || defined(ARDUINO_ARCH_SAMD) || defined(ARDUINO_ARCH_STM32) || defined(ARDUINO_ARCH_STM32F1) || defined(STM32F1) || defined(ESP32)
+  #define PROGMEM
+  #define fontdatatype const char
+#else
+  #define fontdatatype const uint8_t
+#endif
+
+//Font Generated by MikroElektronika GLCD Font Creator 1.2.0.0
+//MikroElektronika 2011 
+//http://www.mikroe.com 
+
+//GLCD FontName : Terminal6x8
+//GLCD FontSize : 6 x 8
+
+fontdatatype Terminal6x8[] PROGMEM = {
+        0x06, 0x08, 0x20, 0x60,
+        0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char  
+        0x05, 0x00, 0x00, 0x06, 0x5F, 0x06, 0x00,  // Code for char !
+        0x06, 0x00, 0x07, 0x03, 0x00, 0x07, 0x03,  // Code for char "
+        0x06, 0x00, 0x24, 0x7E, 0x24, 0x7E, 0x24,  // Code for char #
+        0x05, 0x00, 0x24, 0x2B, 0x6A, 0x12, 0x00,  // Code for char $
+        0x06, 0x00, 0x63, 0x13, 0x08, 0x64, 0x63,  // Code for char %
+        0x06, 0x00, 0x36, 0x49, 0x56, 0x20, 0x50,  // Code for char &
+        0x04, 0x00, 0x00, 0x07, 0x03, 0x00, 0x00,  // Code for char '
+        0x04, 0x00, 0x00, 0x3E, 0x41, 0x00, 0x00,  // Code for char (
+        0x04, 0x00, 0x00, 0x41, 0x3E, 0x00, 0x00,  // Code for char )
+        0x06, 0x00, 0x08, 0x3E, 0x1C, 0x3E, 0x08,  // Code for char *
+        0x06, 0x00, 0x08, 0x08, 0x3E, 0x08, 0x08,  // Code for char +
+        0x04, 0x00, 0x00, 0xE0, 0x60, 0x00, 0x00,  // Code for char ,
+        0x06, 0x00, 0x08, 0x08, 0x08, 0x08, 0x08,  // Code for char -
+        0x04, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00,  // Code for char .
+        0x06, 0x00, 0x20, 0x10, 0x08, 0x04, 0x02,  // Code for char /
+        0x06, 0x00, 0x3E, 0x51, 0x49, 0x45, 0x3E,  // Code for char 0
+        0x05, 0x00, 0x00, 0x42, 0x7F, 0x40, 0x00,  // Code for char 1
+        0x06, 0x00, 0x62, 0x51, 0x49, 0x49, 0x46,  // Code for char 2
+        0x06, 0x00, 0x22, 0x49, 0x49, 0x49, 0x36,  // Code for char 3
+        0x06, 0x00, 0x18, 0x14, 0x12, 0x7F, 0x10,  // Code for char 4
+        0x06, 0x00, 0x2F, 0x49, 0x49, 0x49, 0x31,  // Code for char 5
+        0x06, 0x00, 0x3C, 0x4A, 0x49, 0x49, 0x30,  // Code for char 6
+        0x06, 0x00, 0x01, 0x71, 0x09, 0x05, 0x03,  // Code for char 7
+        0x06, 0x00, 0x36, 0x49, 0x49, 0x49, 0x36,  // Code for char 8
+        0x06, 0x00, 0x06, 0x49, 0x49, 0x29, 0x1E,  // Code for char 9
+        0x04, 0x00, 0x00, 0x6C, 0x6C, 0x00, 0x00,  // Code for char :
+        0x04, 0x00, 0x00, 0xEC, 0x6C, 0x00, 0x00,  // Code for char ;
+        0x05, 0x00, 0x08, 0x14, 0x22, 0x41, 0x00,  // Code for char <
+        0x06, 0x00, 0x24, 0x24, 0x24, 0x24, 0x24,  // Code for char =
+        0x06, 0x00, 0x00, 0x41, 0x22, 0x14, 0x08,  // Code for char >
+        0x06, 0x00, 0x02, 0x01, 0x59, 0x09, 0x06,  // Code for char ?
+        0x06, 0x00, 0x3E, 0x41, 0x5D, 0x55, 0x1E,  // Code for char @
+        0x06, 0x00, 0x7E, 0x11, 0x11, 0x11, 0x7E,  // Code for char A
+        0x06, 0x00, 0x7F, 0x49, 0x49, 0x49, 0x36,  // Code for char B
+        0x06, 0x00, 0x3E, 0x41, 0x41, 0x41, 0x22,  // Code for char C
+        0x06, 0x00, 0x7F, 0x41, 0x41, 0x41, 0x3E,  // Code for char D
+        0x06, 0x00, 0x7F, 0x49, 0x49, 0x49, 0x41,  // Code for char E
+        0x06, 0x00, 0x7F, 0x09, 0x09, 0x09, 0x01,  // Code for char F
+        0x06, 0x00, 0x3E, 0x41, 0x49, 0x49, 0x7A,  // Code for char G
+        0x06, 0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F,  // Code for char H
+        0x05, 0x00, 0x00, 0x41, 0x7F, 0x41, 0x00,  // Code for char I
+        0x06, 0x00, 0x30, 0x40, 0x40, 0x40, 0x3F,  // Code for char J
+        0x06, 0x00, 0x7F, 0x08, 0x14, 0x22, 0x41,  // Code for char K
+        0x06, 0x00, 0x7F, 0x40, 0x40, 0x40, 0x40,  // Code for char L
+        0x06, 0x00, 0x7F, 0x02, 0x04, 0x02, 0x7F,  // Code for char M
+        0x06, 0x00, 0x7F, 0x02, 0x04, 0x08, 0x7F,  // Code for char N
+        0x06, 0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E,  // Code for char O
+        0x06, 0x00, 0x7F, 0x09, 0x09, 0x09, 0x06,  // Code for char P
+        0x06, 0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E,  // Code for char Q
+        0x06, 0x00, 0x7F, 0x09, 0x09, 0x19, 0x66,  // Code for char R
+        0x06, 0x00, 0x26, 0x49, 0x49, 0x49, 0x32,  // Code for char S
+        0x06, 0x00, 0x01, 0x01, 0x7F, 0x01, 0x01,  // Code for char T
+        0x06, 0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F,  // Code for char U
+        0x06, 0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F,  // Code for char V
+        0x06, 0x00, 0x3F, 0x40, 0x3C, 0x40, 0x3F,  // Code for char W
+        0x06, 0x00, 0x63, 0x14, 0x08, 0x14, 0x63,  // Code for char X
+        0x06, 0x00, 0x07, 0x08, 0x70, 0x08, 0x07,  // Code for char Y
+        0x05, 0x00, 0x71, 0x49, 0x45, 0x43, 0x00,  // Code for char Z
+        0x05, 0x00, 0x00, 0x7F, 0x41, 0x41, 0x00,  // Code for char [
+        0x06, 0x00, 0x02, 0x04, 0x08, 0x10, 0x20,  // Code for char BackSlash
+        0x05, 0x00, 0x00, 0x41, 0x41, 0x7F, 0x00,  // Code for char ]
+        0x06, 0x00, 0x04, 0x02, 0x01, 0x02, 0x04,  // Code for char ^
+        0x06, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,  // Code for char _
+        0x04, 0x00, 0x00, 0x03, 0x07, 0x00, 0x00,  // Code for char `
+        0x06, 0x00, 0x20, 0x54, 0x54, 0x54, 0x78,  // Code for char a
+        0x06, 0x00, 0x7F, 0x44, 0x44, 0x44, 0x38,  // Code for char b
+        0x06, 0x00, 0x38, 0x44, 0x44, 0x44, 0x28,  // Code for char c
+        0x06, 0x00, 0x38, 0x44, 0x44, 0x44, 0x7F,  // Code for char d
+        0x06, 0x00, 0x38, 0x54, 0x54, 0x54, 0x08,  // Code for char e
+        0x05, 0x00, 0x08, 0x7E, 0x09, 0x09, 0x00,  // Code for char f
+        0x06, 0x00, 0x18, 0xA4, 0xA4, 0xA4, 0x7C,  // Code for char g
+        0x05, 0x00, 0x7F, 0x04, 0x04, 0x78, 0x00,  // Code for char h
+        0x05, 0x00, 0x00, 0x00, 0x7D, 0x40, 0x00,  // Code for char i
+        0x05, 0x00, 0x40, 0x80, 0x84, 0x7D, 0x00,  // Code for char j
+        0x05, 0x00, 0x7F, 0x10, 0x28, 0x44, 0x00,  // Code for char k
+        0x05, 0x00, 0x00, 0x00, 0x7F, 0x40, 0x00,  // Code for char l
+        0x06, 0x00, 0x7C, 0x04, 0x18, 0x04, 0x78,  // Code for char m
+        0x05, 0x00, 0x7C, 0x04, 0x04, 0x78, 0x00,  // Code for char n
+        0x06, 0x00, 0x38, 0x44, 0x44, 0x44, 0x38,  // Code for char o
+        0x06, 0x00, 0xFC, 0x44, 0x44, 0x44, 0x38,  // Code for char p
+        0x06, 0x00, 0x38, 0x44, 0x44, 0x44, 0xFC,  // Code for char q
+        0x06, 0x00, 0x44, 0x78, 0x44, 0x04, 0x08,  // Code for char r
+        0x06, 0x00, 0x08, 0x54, 0x54, 0x54, 0x20,  // Code for char s
+        0x05, 0x00, 0x04, 0x3E, 0x44, 0x24, 0x00,  // Code for char t
+        0x05, 0x00, 0x3C, 0x40, 0x20, 0x7C, 0x00,  // Code for char u
+        0x06, 0x00, 0x1C, 0x20, 0x40, 0x20, 0x1C,  // Code for char v
+        0x06, 0x00, 0x3C, 0x60, 0x30, 0x60, 0x3C,  // Code for char w
+        0x05, 0x00, 0x6C, 0x10, 0x10, 0x6C, 0x00,  // Code for char x
+        0x05, 0x00, 0x9C, 0xA0, 0x60, 0x3C, 0x00,  // Code for char y
+        0x05, 0x00, 0x64, 0x54, 0x54, 0x4C, 0x00,  // Code for char z
+        0x05, 0x00, 0x08, 0x3E, 0x41, 0x41, 0x00,  // Code for char {
+        0x04, 0x00, 0x00, 0x00, 0x77, 0x00, 0x00,  // Code for char |
+        0x06, 0x00, 0x00, 0x41, 0x41, 0x3E, 0x08,  // Code for char }
+        0x05, 0x00, 0x02, 0x01, 0x02, 0x01, 0x00,  // Code for char ~
+        0x06, 0x00, 0x3C, 0x26, 0x23, 0x26, 0x3C   // Code for char 
+        };
+
+
+//Font Generated by MikroElektronika GLCD Font Creator 1.2.0.0
+//MikroElektronika 2011 
+//http://www.mikroe.com 
+
+//GLCD FontName : Terminal11x16
+//GLCD FontSize : 11 x 16
+
+fontdatatype Terminal11x16[] PROGMEM = {
+        0x0B, 0x10, 0x20, 0x60,
+        0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char  
+        0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7C, 0x00, 0xFF, 0x33, 0xFF, 0x33, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char !
+        0x08, 0x00, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char "
+        0x0B, 0x00, 0x02, 0x10, 0x1E, 0x90, 0x1F, 0xF0, 0x03, 0x7E, 0x02, 0x1E, 0x1E, 0x90, 0x1F, 0xF0, 0x03, 0x7E, 0x02, 0x1E, 0x00, 0x10, 0x00,  // Code for char #
+        0x09, 0x00, 0x00, 0x78, 0x04, 0xFC, 0x0C, 0xCC, 0x0C, 0xFF, 0x3F, 0xFF, 0x3F, 0xCC, 0x0C, 0xCC, 0x0F, 0x88, 0x07, 0x00, 0x00, 0x00, 0x00,  // Code for char $
+        0x0B, 0x00, 0x30, 0x38, 0x38, 0x38, 0x1C, 0x38, 0x0E, 0x00, 0x07, 0x80, 0x03, 0xC0, 0x01, 0xE0, 0x38, 0x70, 0x38, 0x38, 0x38, 0x1C, 0x00,  // Code for char %
+        0x0A, 0x00, 0x00, 0x00, 0x1F, 0xB8, 0x3F, 0xFC, 0x31, 0xC6, 0x21, 0xE2, 0x37, 0x3E, 0x1E, 0x1C, 0x1C, 0x00, 0x36, 0x00, 0x22, 0x00, 0x00,  // Code for char &
+        0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x27, 0x00, 0x3F, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char '
+        0x08, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x03, 0xFC, 0x0F, 0xFE, 0x1F, 0x07, 0x38, 0x01, 0x20, 0x01, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char (
+        0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x01, 0x20, 0x07, 0x38, 0xFE, 0x1F, 0xFC, 0x0F, 0xF0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char )
+        0x09, 0x00, 0x00, 0x98, 0x0C, 0xB8, 0x0E, 0xE0, 0x03, 0xF8, 0x0F, 0xF8, 0x0F, 0xE0, 0x03, 0xB8, 0x0E, 0x98, 0x0C, 0x00, 0x00, 0x00, 0x00,  // Code for char *
+        0x09, 0x00, 0x00, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0xF0, 0x0F, 0xF0, 0x0F, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00,  // Code for char +
+        0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB8, 0x00, 0xF8, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ,
+        0x09, 0x00, 0x00, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00,  // Code for char -
+        0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char .
+        0x0B, 0x00, 0x18, 0x00, 0x1C, 0x00, 0x0E, 0x00, 0x07, 0x80, 0x03, 0xC0, 0x01, 0xE0, 0x00, 0x70, 0x00, 0x38, 0x00, 0x1C, 0x00, 0x0E, 0x00,  // Code for char /
+        0x0B, 0xF8, 0x07, 0xFE, 0x1F, 0x06, 0x1E, 0x03, 0x33, 0x83, 0x31, 0xC3, 0x30, 0x63, 0x30, 0x33, 0x30, 0x1E, 0x18, 0xFE, 0x1F, 0xF8, 0x07,  // Code for char 0
+        0x0A, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x30, 0x0C, 0x30, 0x0E, 0x30, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00,  // Code for char 1
+        0x0B, 0x1C, 0x30, 0x1E, 0x38, 0x07, 0x3C, 0x03, 0x3E, 0x03, 0x37, 0x83, 0x33, 0xC3, 0x31, 0xE3, 0x30, 0x77, 0x30, 0x3E, 0x30, 0x1C, 0x30,  // Code for char 2
+        0x0B, 0x0C, 0x0C, 0x0E, 0x1C, 0x07, 0x38, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xE7, 0x39, 0x7E, 0x1F, 0x3C, 0x0E,  // Code for char 3
+        0x0B, 0xC0, 0x03, 0xE0, 0x03, 0x70, 0x03, 0x38, 0x03, 0x1C, 0x03, 0x0E, 0x03, 0x07, 0x03, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x03, 0x00, 0x03,  // Code for char 4
+        0x0B, 0x3F, 0x0C, 0x7F, 0x1C, 0x63, 0x38, 0x63, 0x30, 0x63, 0x30, 0x63, 0x30, 0x63, 0x30, 0x63, 0x30, 0xE3, 0x38, 0xC3, 0x1F, 0x83, 0x0F,  // Code for char 5
+        0x0B, 0xC0, 0x0F, 0xF0, 0x1F, 0xF8, 0x39, 0xDC, 0x30, 0xCE, 0x30, 0xC7, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x39, 0x80, 0x1F, 0x00, 0x0F,  // Code for char 6
+        0x0B, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x30, 0x03, 0x3C, 0x03, 0x0F, 0xC3, 0x03, 0xF3, 0x00, 0x3F, 0x00, 0x0F, 0x00, 0x03, 0x00,  // Code for char 7
+        0x0B, 0x00, 0x0F, 0xBC, 0x1F, 0xFE, 0x39, 0xE7, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xE7, 0x30, 0xFE, 0x39, 0xBC, 0x1F, 0x00, 0x0F,  // Code for char 8
+        0x0B, 0x3C, 0x00, 0x7E, 0x00, 0xE7, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x38, 0xC3, 0x1C, 0xC3, 0x0E, 0xE7, 0x07, 0xFE, 0x03, 0xFC, 0x00,  // Code for char 9
+        0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x1C, 0x70, 0x1C, 0x70, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char :
+        0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x9C, 0x70, 0xFC, 0x70, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ;
+        0x09, 0x00, 0x00, 0xC0, 0x00, 0xE0, 0x01, 0xF0, 0x03, 0x38, 0x07, 0x1C, 0x0E, 0x0E, 0x1C, 0x07, 0x38, 0x03, 0x30, 0x00, 0x00, 0x00, 0x00,  // Code for char <
+        0x0A, 0x00, 0x00, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x00, 0x00,  // Code for char =
+        0x09, 0x00, 0x00, 0x03, 0x30, 0x07, 0x38, 0x0E, 0x1C, 0x1C, 0x0E, 0x38, 0x07, 0xF0, 0x03, 0xE0, 0x01, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char >
+        0x0A, 0x1C, 0x00, 0x1E, 0x00, 0x07, 0x00, 0x03, 0x00, 0x83, 0x37, 0xC3, 0x37, 0xE3, 0x00, 0x77, 0x00, 0x3E, 0x00, 0x1C, 0x00, 0x00, 0x00,  // Code for char ?
+        0x0B, 0xF8, 0x0F, 0xFE, 0x1F, 0x07, 0x18, 0xF3, 0x33, 0xFB, 0x37, 0x1B, 0x36, 0xFB, 0x37, 0xFB, 0x37, 0x07, 0x36, 0xFE, 0x03, 0xF8, 0x01,  // Code for char @
+        0x0A, 0x00, 0x38, 0x00, 0x3F, 0xE0, 0x07, 0xFC, 0x06, 0x1F, 0x06, 0x1F, 0x06, 0xFC, 0x06, 0xE0, 0x07, 0x00, 0x3F, 0x00, 0x38, 0x00, 0x00,  // Code for char A
+        0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xE7, 0x30, 0xFE, 0x39, 0xBC, 0x1F, 0x00, 0x0F, 0x00, 0x00,  // Code for char B
+        0x0A, 0xF0, 0x03, 0xFC, 0x0F, 0x0E, 0x1C, 0x07, 0x38, 0x03, 0x30, 0x03, 0x30, 0x03, 0x30, 0x07, 0x38, 0x0E, 0x1C, 0x0C, 0x0C, 0x00, 0x00,  // Code for char C
+        0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0x03, 0x30, 0x03, 0x30, 0x03, 0x30, 0x03, 0x30, 0x07, 0x38, 0x0E, 0x1C, 0xFC, 0x0F, 0xF0, 0x03, 0x00, 0x00,  // Code for char D
+        0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0x03, 0x30, 0x03, 0x30, 0x00, 0x00,  // Code for char E
+        0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0xC3, 0x00, 0xC3, 0x00, 0xC3, 0x00, 0xC3, 0x00, 0xC3, 0x00, 0xC3, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00,  // Code for char F
+        0x0A, 0xF0, 0x03, 0xFC, 0x0F, 0x0E, 0x1C, 0x07, 0x38, 0x03, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC7, 0x3F, 0xC6, 0x3F, 0x00, 0x00,  // Code for char G
+        0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00,  // Code for char H
+        0x08, 0x00, 0x00, 0x00, 0x00, 0x03, 0x30, 0x03, 0x30, 0xFF, 0x3F, 0xFF, 0x3F, 0x03, 0x30, 0x03, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char I
+        0x0A, 0x00, 0x0E, 0x00, 0x1E, 0x00, 0x38, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x38, 0xFF, 0x1F, 0xFF, 0x07, 0x00, 0x00,  // Code for char J
+        0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0xC0, 0x00, 0xE0, 0x01, 0xF0, 0x03, 0x38, 0x07, 0x1C, 0x0E, 0x0E, 0x1C, 0x07, 0x38, 0x03, 0x30, 0x00, 0x00,  // Code for char K
+        0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00,  // Code for char L
+        0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0x1E, 0x00, 0x78, 0x00, 0xE0, 0x01, 0xE0, 0x01, 0x78, 0x00, 0x1E, 0x00, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00,  // Code for char M
+        0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0x0E, 0x00, 0x38, 0x00, 0xF0, 0x00, 0xC0, 0x03, 0x00, 0x07, 0x00, 0x1C, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00,  // Code for char N
+        0x0A, 0xF0, 0x03, 0xFC, 0x0F, 0x0E, 0x1C, 0x07, 0x38, 0x03, 0x30, 0x03, 0x30, 0x07, 0x38, 0x0E, 0x1C, 0xFC, 0x0F, 0xF0, 0x03, 0x00, 0x00,  // Code for char O
+        0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0x83, 0x01, 0x83, 0x01, 0x83, 0x01, 0x83, 0x01, 0x83, 0x01, 0xC7, 0x01, 0xFE, 0x00, 0x7C, 0x00, 0x00, 0x00,  // Code for char P
+        0x0A, 0xF0, 0x03, 0xFC, 0x0F, 0x0E, 0x1C, 0x07, 0x38, 0x03, 0x30, 0x03, 0x36, 0x07, 0x3E, 0x0E, 0x1C, 0xFC, 0x3F, 0xF0, 0x33, 0x00, 0x00,  // Code for char Q
+        0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0x83, 0x01, 0x83, 0x01, 0x83, 0x03, 0x83, 0x07, 0x83, 0x0F, 0xC7, 0x1D, 0xFE, 0x38, 0x7C, 0x30, 0x00, 0x00,  // Code for char R
+        0x0A, 0x3C, 0x0C, 0x7E, 0x1C, 0xE7, 0x38, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC7, 0x39, 0x8E, 0x1F, 0x0C, 0x0F, 0x00, 0x00,  // Code for char S
+        0x09, 0x00, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0xFF, 0x3F, 0xFF, 0x3F, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char T
+        0x0A, 0xFF, 0x07, 0xFF, 0x1F, 0x00, 0x38, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x38, 0xFF, 0x1F, 0xFF, 0x07, 0x00, 0x00,  // Code for char U
+        0x0A, 0x07, 0x00, 0x3F, 0x00, 0xF8, 0x01, 0xC0, 0x0F, 0x00, 0x3E, 0x00, 0x3E, 0xC0, 0x0F, 0xF8, 0x01, 0x3F, 0x00, 0x07, 0x00, 0x00, 0x00,  // Code for char V
+        0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x1C, 0x00, 0x06, 0x80, 0x03, 0x80, 0x03, 0x00, 0x06, 0x00, 0x1C, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00,  // Code for char W
+        0x0A, 0x03, 0x30, 0x0F, 0x3C, 0x1C, 0x0E, 0x30, 0x03, 0xE0, 0x01, 0xE0, 0x01, 0x30, 0x03, 0x1C, 0x0E, 0x0F, 0x3C, 0x03, 0x30, 0x00, 0x00,  // Code for char X
+        0x0A, 0x03, 0x00, 0x0F, 0x00, 0x3C, 0x00, 0xF0, 0x00, 0xC0, 0x3F, 0xC0, 0x3F, 0xF0, 0x00, 0x3C, 0x00, 0x0F, 0x00, 0x03, 0x00, 0x00, 0x00,  // Code for char Y
+        0x0A, 0x03, 0x30, 0x03, 0x3C, 0x03, 0x3E, 0x03, 0x33, 0xC3, 0x31, 0xE3, 0x30, 0x33, 0x30, 0x1F, 0x30, 0x0F, 0x30, 0x03, 0x30, 0x00, 0x00,  // Code for char Z
+        0x08, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x3F, 0xFF, 0x3F, 0x03, 0x30, 0x03, 0x30, 0x03, 0x30, 0x03, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char [
+        0x0B, 0x0E, 0x00, 0x1C, 0x00, 0x38, 0x00, 0x70, 0x00, 0xE0, 0x00, 0xC0, 0x01, 0x80, 0x03, 0x00, 0x07, 0x00, 0x0E, 0x00, 0x1C, 0x00, 0x18,  // Code for char BackSlash
+        0x08, 0x00, 0x00, 0x00, 0x00, 0x03, 0x30, 0x03, 0x30, 0x03, 0x30, 0x03, 0x30, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ]
+        0x0B, 0x60, 0x00, 0x70, 0x00, 0x38, 0x00, 0x1C, 0x00, 0x0E, 0x00, 0x07, 0x00, 0x0E, 0x00, 0x1C, 0x00, 0x38, 0x00, 0x70, 0x00, 0x60, 0x00,  // Code for char ^
+        0x0B, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0,  // Code for char _
+        0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x7E, 0x00, 0x4E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char `
+        0x0A, 0x00, 0x1C, 0x40, 0x3E, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0xE0, 0x3F, 0xC0, 0x3F, 0x00, 0x00,  // Code for char a
+        0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0xC0, 0x30, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0xE0, 0x38, 0xC0, 0x1F, 0x80, 0x0F, 0x00, 0x00,  // Code for char b
+        0x0A, 0x80, 0x0F, 0xC0, 0x1F, 0xE0, 0x38, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0xC0, 0x18, 0x80, 0x08, 0x00, 0x00,  // Code for char c
+        0x0A, 0x80, 0x0F, 0xC0, 0x1F, 0xE0, 0x38, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0xE0, 0x30, 0xC0, 0x30, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00,  // Code for char d
+        0x0A, 0x80, 0x0F, 0xC0, 0x1F, 0xE0, 0x3B, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0xC0, 0x13, 0x80, 0x01, 0x00, 0x00,  // Code for char e
+        0x08, 0xC0, 0x00, 0xC0, 0x00, 0xFC, 0x3F, 0xFE, 0x3F, 0xC7, 0x00, 0xC3, 0x00, 0xC3, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char f
+        0x0A, 0x80, 0x03, 0xC0, 0xC7, 0xE0, 0xCE, 0x60, 0xCC, 0x60, 0xCC, 0x60, 0xCC, 0x60, 0xCC, 0x60, 0xE6, 0xE0, 0x7F, 0xE0, 0x3F, 0x00, 0x00,  // Code for char g
+        0x09, 0xFF, 0x3F, 0xFF, 0x3F, 0xC0, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0xE0, 0x00, 0xC0, 0x3F, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x00,  // Code for char h
+        0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x60, 0x30, 0xEC, 0x3F, 0xEC, 0x3F, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char i
+        0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0xE0, 0x00, 0xC0, 0x60, 0xC0, 0xEC, 0xFF, 0xEC, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char j
+        0x09, 0x00, 0x00, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x03, 0x80, 0x07, 0xC0, 0x0F, 0xE0, 0x1C, 0x60, 0x38, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00,  // Code for char k
+        0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x03, 0x30, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char l
+        0x0A, 0xE0, 0x3F, 0xC0, 0x3F, 0xE0, 0x00, 0xE0, 0x00, 0xC0, 0x3F, 0xC0, 0x3F, 0xE0, 0x00, 0xE0, 0x00, 0xC0, 0x3F, 0x80, 0x3F, 0x00, 0x00,  // Code for char m
+        0x0A, 0x00, 0x00, 0xE0, 0x3F, 0xE0, 0x3F, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0xE0, 0x00, 0xC0, 0x3F, 0x80, 0x3F, 0x00, 0x00,  // Code for char n
+        0x0A, 0x80, 0x0F, 0xC0, 0x1F, 0xE0, 0x38, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0xE0, 0x38, 0xC0, 0x1F, 0x80, 0x0F, 0x00, 0x00,  // Code for char o
+        0x0A, 0xE0, 0xFF, 0xE0, 0xFF, 0x60, 0x0C, 0x60, 0x18, 0x60, 0x18, 0x60, 0x18, 0x60, 0x18, 0xE0, 0x1C, 0xC0, 0x0F, 0x80, 0x07, 0x00, 0x00,  // Code for char p
+        0x0A, 0x80, 0x07, 0xC0, 0x0F, 0xE0, 0x1C, 0x60, 0x18, 0x60, 0x18, 0x60, 0x18, 0x60, 0x18, 0x60, 0x0C, 0xE0, 0xFF, 0xE0, 0xFF, 0x00, 0x00,  // Code for char q
+        0x0A, 0x00, 0x00, 0xE0, 0x3F, 0xE0, 0x3F, 0xC0, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0xE0, 0x00, 0xC0, 0x00, 0x00, 0x00,  // Code for char r
+        0x08, 0xC0, 0x11, 0xE0, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x3F, 0x40, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char s
+        0x08, 0x60, 0x00, 0x60, 0x00, 0xFE, 0x1F, 0xFE, 0x3F, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char t
+        0x0A, 0xE0, 0x0F, 0xE0, 0x1F, 0x00, 0x38, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x18, 0xE0, 0x3F, 0xE0, 0x3F, 0x00, 0x00,  // Code for char u
+        0x0A, 0x60, 0x00, 0xE0, 0x01, 0x80, 0x07, 0x00, 0x1E, 0x00, 0x38, 0x00, 0x38, 0x00, 0x1E, 0x80, 0x07, 0xE0, 0x01, 0x60, 0x00, 0x00, 0x00,  // Code for char v
+        0x0A, 0xE0, 0x07, 0xE0, 0x1F, 0x00, 0x38, 0x00, 0x1C, 0xE0, 0x0F, 0xE0, 0x0F, 0x00, 0x1C, 0x00, 0x38, 0xE0, 0x1F, 0xE0, 0x07, 0x00, 0x00,  // Code for char w
+        0x09, 0x60, 0x30, 0xE0, 0x38, 0xC0, 0x1D, 0x80, 0x0F, 0x00, 0x07, 0x80, 0x0F, 0xC0, 0x1D, 0xE0, 0x38, 0x60, 0x30, 0x00, 0x00, 0x00, 0x00,  // Code for char x
+        0x09, 0x00, 0x00, 0x60, 0x00, 0xE0, 0x81, 0x80, 0xE7, 0x00, 0x7E, 0x00, 0x1E, 0x80, 0x07, 0xE0, 0x01, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char y
+        0x09, 0x60, 0x30, 0x60, 0x38, 0x60, 0x3C, 0x60, 0x36, 0x60, 0x33, 0xE0, 0x31, 0xE0, 0x30, 0x60, 0x30, 0x20, 0x30, 0x00, 0x00, 0x00, 0x00,  // Code for char z
+        0x09, 0x00, 0x00, 0x80, 0x00, 0xC0, 0x01, 0xFC, 0x1F, 0x7E, 0x3F, 0x07, 0x70, 0x03, 0x60, 0x03, 0x60, 0x03, 0x60, 0x00, 0x00, 0x00, 0x00,  // Code for char {
+        0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char |
+        0x09, 0x00, 0x00, 0x03, 0x60, 0x03, 0x60, 0x03, 0x60, 0x07, 0x70, 0x7E, 0x3F, 0xFC, 0x1F, 0xC0, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char }
+        0x0A, 0x10, 0x00, 0x18, 0x00, 0x0C, 0x00, 0x04, 0x00, 0x0C, 0x00, 0x18, 0x00, 0x10, 0x00, 0x18, 0x00, 0x0C, 0x00, 0x04, 0x00, 0x00, 0x00,  // Code for char ~
+        0x0A, 0x00, 0x0F, 0x80, 0x0F, 0xC0, 0x0C, 0x60, 0x0C, 0x30, 0x0C, 0x30, 0x0C, 0x60, 0x0C, 0xC0, 0x0C, 0x80, 0x0F, 0x00, 0x0F, 0x00, 0x00   // Code for char 
+        };
+
+
+//Font Generated by MikroElektronika GLCD Font Creator 1.2.0.0
+//MikroElektronika 2011 
+//http://www.mikroe.com 
+
+//GLCD FontName : Terminal12x16
+//GLCD FontSize : 12 x 16
+
+fontdatatype Terminal12x16[] PROGMEM = {
+        0x0C, 0x10, 0x20, 0x60,
+        0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char  
+        0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7C, 0x00, 0xFF, 0x33, 0xFF, 0x33, 0xFF, 0x33, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char !
+        0x09, 0x00, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x3C, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x3C, 0x00, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char "
+        0x0C, 0x00, 0x02, 0x10, 0x1E, 0x90, 0x1F, 0xF0, 0x1F, 0xFE, 0x03, 0x7E, 0x1E, 0x9E, 0x1F, 0xF0, 0x1F, 0xFE, 0x03, 0x7E, 0x02, 0x1E, 0x00, 0x10, 0x00,  // Code for char #
+        0x0A, 0x00, 0x00, 0x78, 0x04, 0xFC, 0x0C, 0xFC, 0x0C, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0xCC, 0x0F, 0xCC, 0x0F, 0x88, 0x07, 0x00, 0x00, 0x00, 0x00,  // Code for char $
+        0x0C, 0x00, 0x30, 0x38, 0x38, 0x38, 0x3C, 0x38, 0x1E, 0x38, 0x0F, 0x80, 0x07, 0xC0, 0x03, 0xE0, 0x39, 0xF0, 0x38, 0x78, 0x38, 0x3C, 0x38, 0x1C, 0x00,  // Code for char %
+        0x0B, 0x00, 0x00, 0x00, 0x1F, 0xB8, 0x3F, 0xFC, 0x3F, 0xFE, 0x31, 0xE6, 0x37, 0xFE, 0x3F, 0x3E, 0x1E, 0x1C, 0x3E, 0x00, 0x36, 0x00, 0x22, 0x00, 0x00,  // Code for char &
+        0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x27, 0x00, 0x3F, 0x00, 0x3F, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char '
+        0x09, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x03, 0xFC, 0x0F, 0xFE, 0x1F, 0xFF, 0x3F, 0x07, 0x38, 0x01, 0x20, 0x01, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char (
+        0x09, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x01, 0x20, 0x07, 0x38, 0xFF, 0x3F, 0xFE, 0x1F, 0xFC, 0x0F, 0xF0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char )
+        0x0A, 0x00, 0x00, 0x98, 0x0C, 0xB8, 0x0E, 0xF8, 0x0F, 0xF8, 0x0F, 0xF8, 0x0F, 0xF8, 0x0F, 0xF8, 0x0F, 0xB8, 0x0E, 0x98, 0x0C, 0x00, 0x00, 0x00, 0x00,  // Code for char *
+        0x0A, 0x00, 0x00, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0xF0, 0x0F, 0xF0, 0x0F, 0xF0, 0x0F, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00,  // Code for char +
+        0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB8, 0x00, 0xF8, 0x00, 0xF8, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ,
+        0x0A, 0x00, 0x00, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00,  // Code for char -
+        0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char .
+        0x0C, 0x00, 0x18, 0x00, 0x1C, 0x00, 0x1E, 0x00, 0x0F, 0x80, 0x07, 0xC0, 0x03, 0xE0, 0x01, 0xF0, 0x00, 0x78, 0x00, 0x3C, 0x00, 0x1E, 0x00, 0x0E, 0x00,  // Code for char /
+        0x0C, 0xF8, 0x07, 0xFE, 0x1F, 0xFE, 0x1F, 0x07, 0x3F, 0x83, 0x33, 0xC3, 0x31, 0xE3, 0x30, 0x73, 0x30, 0x3F, 0x38, 0xFE, 0x1F, 0xFE, 0x1F, 0xF8, 0x07,  // Code for char 0
+        0x0B, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x30, 0x0C, 0x30, 0x0E, 0x30, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00,  // Code for char 1
+        0x0C, 0x1C, 0x30, 0x1E, 0x38, 0x1F, 0x3C, 0x07, 0x3E, 0x03, 0x3F, 0x83, 0x37, 0xC3, 0x33, 0xE3, 0x31, 0xF7, 0x30, 0x7F, 0x30, 0x3E, 0x30, 0x1C, 0x30,  // Code for char 2
+        0x0C, 0x0C, 0x0C, 0x0E, 0x1C, 0x0F, 0x3C, 0xC7, 0x38, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xE7, 0x39, 0xFF, 0x3F, 0x7E, 0x1F, 0x3C, 0x0E,  // Code for char 3
+        0x0C, 0xC0, 0x03, 0xE0, 0x03, 0xF0, 0x03, 0x78, 0x03, 0x3C, 0x03, 0x1E, 0x03, 0x0F, 0x03, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x03, 0x00, 0x03,  // Code for char 4
+        0x0C, 0x3F, 0x0C, 0x7F, 0x1C, 0x7F, 0x3C, 0x63, 0x38, 0x63, 0x30, 0x63, 0x30, 0x63, 0x30, 0x63, 0x30, 0xE3, 0x38, 0xE3, 0x3F, 0xC3, 0x1F, 0x83, 0x0F,  // Code for char 5
+        0x0C, 0xC0, 0x0F, 0xF0, 0x1F, 0xF8, 0x3F, 0xFC, 0x39, 0xDE, 0x30, 0xCF, 0x30, 0xC7, 0x30, 0xC3, 0x30, 0xC3, 0x39, 0xC3, 0x3F, 0x80, 0x1F, 0x00, 0x0F,  // Code for char 6
+        0x0C, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x30, 0x03, 0x3C, 0x03, 0x3F, 0xC3, 0x0F, 0xF3, 0x03, 0xFF, 0x00, 0x3F, 0x00, 0x0F, 0x00, 0x03, 0x00,  // Code for char 7
+        0x0C, 0x00, 0x0F, 0xBC, 0x1F, 0xFE, 0x3F, 0xFF, 0x39, 0xE7, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xE7, 0x30, 0xFF, 0x39, 0xFE, 0x3F, 0xBC, 0x1F, 0x00, 0x0F,  // Code for char 8
+        0x0C, 0x3C, 0x00, 0x7E, 0x00, 0xFF, 0x30, 0xE7, 0x30, 0xC3, 0x30, 0xC3, 0x38, 0xC3, 0x3C, 0xC3, 0x1E, 0xE7, 0x0F, 0xFF, 0x07, 0xFE, 0x03, 0xFC, 0x00,  // Code for char 9
+        0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x1C, 0x70, 0x1C, 0x70, 0x1C, 0x70, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char :
+        0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x9C, 0x70, 0xFC, 0x70, 0xFC, 0x70, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ;
+        0x0A, 0x00, 0x00, 0xC0, 0x00, 0xE0, 0x01, 0xF0, 0x03, 0xF8, 0x07, 0x3C, 0x0F, 0x1E, 0x1E, 0x0F, 0x3C, 0x07, 0x38, 0x03, 0x30, 0x00, 0x00, 0x00, 0x00,  // Code for char <
+        0x0B, 0x00, 0x00, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x60, 0x06, 0x00, 0x00,  // Code for char =
+        0x0A, 0x00, 0x00, 0x03, 0x30, 0x07, 0x38, 0x0F, 0x3C, 0x1E, 0x1E, 0x3C, 0x0F, 0xF8, 0x07, 0xF0, 0x03, 0xE0, 0x01, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char >
+        0x0B, 0x1C, 0x00, 0x1E, 0x00, 0x1F, 0x00, 0x07, 0x00, 0x83, 0x37, 0xC3, 0x37, 0xE3, 0x37, 0xF7, 0x00, 0x7F, 0x00, 0x3E, 0x00, 0x1C, 0x00, 0x00, 0x00,  // Code for char ?
+        0x0C, 0xF8, 0x0F, 0xFE, 0x1F, 0xFF, 0x1F, 0xF7, 0x3B, 0xFB, 0x37, 0xFB, 0x37, 0xFB, 0x37, 0xFB, 0x37, 0xFF, 0x37, 0xFF, 0x37, 0xFE, 0x03, 0xF8, 0x01,  // Code for char @
+        0x0B, 0x00, 0x38, 0x00, 0x3F, 0xE0, 0x3F, 0xFC, 0x07, 0xFF, 0x06, 0x1F, 0x06, 0xFF, 0x06, 0xFC, 0x07, 0xE0, 0x3F, 0x00, 0x3F, 0x00, 0x38, 0x00, 0x00,  // Code for char A
+        0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xE7, 0x30, 0xFF, 0x39, 0xFE, 0x3F, 0xBC, 0x1F, 0x00, 0x0F, 0x00, 0x00,  // Code for char B
+        0x0B, 0xF0, 0x03, 0xFC, 0x0F, 0xFE, 0x1F, 0x0F, 0x3C, 0x07, 0x38, 0x03, 0x30, 0x03, 0x30, 0x07, 0x38, 0x0F, 0x3C, 0x0E, 0x1C, 0x0C, 0x0C, 0x00, 0x00,  // Code for char C
+        0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x03, 0x30, 0x03, 0x30, 0x03, 0x30, 0x07, 0x38, 0x0F, 0x3C, 0xFE, 0x1F, 0xFC, 0x0F, 0xF0, 0x03, 0x00, 0x00,  // Code for char D
+        0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0x03, 0x30, 0x03, 0x30, 0x00, 0x00,  // Code for char E
+        0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0xC3, 0x00, 0xC3, 0x00, 0xC3, 0x00, 0xC3, 0x00, 0xC3, 0x00, 0xC3, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00,  // Code for char F
+        0x0B, 0xF0, 0x03, 0xFC, 0x0F, 0xFE, 0x1F, 0x0F, 0x3C, 0x07, 0x38, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC7, 0x3F, 0xC7, 0x3F, 0xC6, 0x3F, 0x00, 0x00,  // Code for char G
+        0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00,  // Code for char H
+        0x09, 0x00, 0x00, 0x00, 0x00, 0x03, 0x30, 0x03, 0x30, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x03, 0x30, 0x03, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char I
+        0x0B, 0x00, 0x0E, 0x00, 0x1E, 0x00, 0x3E, 0x00, 0x38, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x38, 0xFF, 0x3F, 0xFF, 0x1F, 0xFF, 0x07, 0x00, 0x00,  // Code for char J
+        0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0xE0, 0x01, 0xF0, 0x03, 0xF8, 0x07, 0x3C, 0x0F, 0x1E, 0x1E, 0x0F, 0x3C, 0x07, 0x38, 0x03, 0x30, 0x00, 0x00,  // Code for char K
+        0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00,  // Code for char L
+        0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x7E, 0x00, 0xF8, 0x01, 0xE0, 0x01, 0xF8, 0x01, 0x7E, 0x00, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00,  // Code for char M
+        0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x3E, 0x00, 0xF8, 0x00, 0xF0, 0x03, 0xC0, 0x07, 0x00, 0x1F, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00,  // Code for char N
+        0x0B, 0xF0, 0x03, 0xFC, 0x0F, 0xFE, 0x1F, 0x0F, 0x3C, 0x07, 0x38, 0x03, 0x30, 0x07, 0x38, 0x0F, 0x3C, 0xFE, 0x1F, 0xFC, 0x0F, 0xF0, 0x03, 0x00, 0x00,  // Code for char O
+        0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x83, 0x01, 0x83, 0x01, 0x83, 0x01, 0x83, 0x01, 0xC7, 0x01, 0xFF, 0x01, 0xFE, 0x00, 0x7C, 0x00, 0x00, 0x00,  // Code for char P
+        0x0B, 0xF0, 0x03, 0xFC, 0x0F, 0xFE, 0x1F, 0x0F, 0x3C, 0x07, 0x38, 0x03, 0x36, 0x07, 0x3E, 0x0F, 0x3E, 0xFE, 0x3F, 0xFC, 0x3F, 0xF0, 0x33, 0x00, 0x00,  // Code for char Q
+        0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x83, 0x01, 0x83, 0x03, 0x83, 0x07, 0x83, 0x0F, 0xC7, 0x1F, 0xFF, 0x3D, 0xFE, 0x38, 0x7C, 0x30, 0x00, 0x00,  // Code for char R
+        0x0B, 0x3C, 0x0C, 0x7E, 0x1C, 0xFF, 0x3C, 0xE7, 0x38, 0xC3, 0x30, 0xC3, 0x30, 0xC3, 0x30, 0xC7, 0x39, 0xCF, 0x3F, 0x8E, 0x1F, 0x0C, 0x0F, 0x00, 0x00,  // Code for char S
+        0x0A, 0x00, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char T
+        0x0B, 0xFF, 0x07, 0xFF, 0x1F, 0xFF, 0x3F, 0x00, 0x38, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x38, 0xFF, 0x3F, 0xFF, 0x1F, 0xFF, 0x07, 0x00, 0x00,  // Code for char U
+        0x0B, 0x07, 0x00, 0x3F, 0x00, 0xFF, 0x01, 0xF8, 0x0F, 0xC0, 0x3F, 0x00, 0x3E, 0xC0, 0x3F, 0xF8, 0x0F, 0xFF, 0x01, 0x3F, 0x00, 0x07, 0x00, 0x00, 0x00,  // Code for char V
+        0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x1E, 0x80, 0x07, 0x80, 0x03, 0x80, 0x07, 0x00, 0x1E, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00,  // Code for char W
+        0x0B, 0x03, 0x30, 0x0F, 0x3C, 0x1F, 0x3E, 0x3C, 0x0F, 0xF0, 0x03, 0xE0, 0x01, 0xF0, 0x03, 0x3C, 0x0F, 0x1F, 0x3E, 0x0F, 0x3C, 0x03, 0x30, 0x00, 0x00,  // Code for char X
+        0x0B, 0x03, 0x00, 0x0F, 0x00, 0x3F, 0x00, 0xFC, 0x00, 0xF0, 0x3F, 0xC0, 0x3F, 0xF0, 0x3F, 0xFC, 0x00, 0x3F, 0x00, 0x0F, 0x00, 0x03, 0x00, 0x00, 0x00,  // Code for char Y
+        0x0B, 0x03, 0x30, 0x03, 0x3C, 0x03, 0x3E, 0x03, 0x3F, 0xC3, 0x33, 0xE3, 0x31, 0xF3, 0x30, 0x3F, 0x30, 0x1F, 0x30, 0x0F, 0x30, 0x03, 0x30, 0x00, 0x00,  // Code for char Z
+        0x09, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x03, 0x30, 0x03, 0x30, 0x03, 0x30, 0x03, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char [
+        0x0C, 0x0E, 0x00, 0x1E, 0x00, 0x3C, 0x00, 0x78, 0x00, 0xF0, 0x00, 0xE0, 0x01, 0xC0, 0x03, 0x80, 0x07, 0x00, 0x0F, 0x00, 0x1E, 0x00, 0x1C, 0x00, 0x18,  // Code for char BackSlash
+        0x09, 0x00, 0x00, 0x00, 0x00, 0x03, 0x30, 0x03, 0x30, 0x03, 0x30, 0x03, 0x30, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ]
+        0x0C, 0x60, 0x00, 0x70, 0x00, 0x78, 0x00, 0x3C, 0x00, 0x1E, 0x00, 0x0F, 0x00, 0x0F, 0x00, 0x1E, 0x00, 0x3C, 0x00, 0x78, 0x00, 0x70, 0x00, 0x60, 0x00,  // Code for char ^
+        0x0C, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x00, 0xC0,  // Code for char _
+        0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x7E, 0x00, 0x7E, 0x00, 0x4E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char `
+        0x0B, 0x00, 0x1C, 0x40, 0x3E, 0x60, 0x3F, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0xE0, 0x3F, 0xE0, 0x3F, 0xC0, 0x3F, 0x00, 0x00,  // Code for char a
+        0x0B, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0xE0, 0x30, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0xE0, 0x38, 0xE0, 0x3F, 0xC0, 0x1F, 0x80, 0x0F, 0x00, 0x00,  // Code for char b
+        0x0B, 0x80, 0x0F, 0xC0, 0x1F, 0xE0, 0x3F, 0xE0, 0x38, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0xE0, 0x38, 0xC0, 0x18, 0x80, 0x08, 0x00, 0x00,  // Code for char c
+        0x0B, 0x80, 0x0F, 0xC0, 0x1F, 0xE0, 0x3F, 0xE0, 0x38, 0x60, 0x30, 0x60, 0x30, 0xE0, 0x30, 0xE0, 0x30, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00,  // Code for char d
+        0x0B, 0x80, 0x0F, 0xC0, 0x1F, 0xE0, 0x3F, 0xE0, 0x3B, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0xE0, 0x33, 0xC0, 0x13, 0x80, 0x01, 0x00, 0x00,  // Code for char e
+        0x09, 0xC0, 0x00, 0xC0, 0x00, 0xFC, 0x3F, 0xFE, 0x3F, 0xFF, 0x3F, 0xC7, 0x00, 0xC3, 0x00, 0xC3, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char f
+        0x0B, 0x80, 0x03, 0xC0, 0xC7, 0xE0, 0xCF, 0xE0, 0xCE, 0x60, 0xCC, 0x60, 0xCC, 0x60, 0xCC, 0x60, 0xEE, 0xE0, 0xFF, 0xE0, 0x7F, 0xE0, 0x3F, 0x00, 0x00,  // Code for char g
+        0x0A, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0xE0, 0x00, 0x60, 0x00, 0x60, 0x00, 0xE0, 0x00, 0xE0, 0x3F, 0xC0, 0x3F, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x00,  // Code for char h
+        0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x60, 0x30, 0xEC, 0x3F, 0xEC, 0x3F, 0xEC, 0x3F, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char i
+        0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0xE0, 0x00, 0xE0, 0x60, 0xC0, 0xEC, 0xFF, 0xEC, 0xFF, 0xEC, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char j
+        0x0A, 0x00, 0x00, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x80, 0x07, 0xC0, 0x0F, 0xE0, 0x1F, 0xE0, 0x3C, 0x60, 0x38, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00,  // Code for char k
+        0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x03, 0x30, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char l
+        0x0B, 0xE0, 0x3F, 0xE0, 0x3F, 0xE0, 0x3F, 0xE0, 0x00, 0xE0, 0x3F, 0xC0, 0x3F, 0xE0, 0x3F, 0xE0, 0x00, 0xE0, 0x3F, 0xC0, 0x3F, 0x80, 0x3F, 0x00, 0x00,  // Code for char m
+        0x0B, 0x00, 0x00, 0xE0, 0x3F, 0xE0, 0x3F, 0xE0, 0x3F, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0xE0, 0x00, 0xE0, 0x3F, 0xC0, 0x3F, 0x80, 0x3F, 0x00, 0x00,  // Code for char n
+        0x0B, 0x80, 0x0F, 0xC0, 0x1F, 0xE0, 0x3F, 0xE0, 0x38, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0xE0, 0x38, 0xE0, 0x3F, 0xC0, 0x1F, 0x80, 0x0F, 0x00, 0x00,  // Code for char o
+        0x0B, 0xE0, 0xFF, 0xE0, 0xFF, 0xE0, 0xFF, 0x60, 0x1C, 0x60, 0x18, 0x60, 0x18, 0x60, 0x18, 0xE0, 0x1C, 0xE0, 0x1F, 0xC0, 0x0F, 0x80, 0x07, 0x00, 0x00,  // Code for char p
+        0x0B, 0x80, 0x07, 0xC0, 0x0F, 0xE0, 0x1F, 0xE0, 0x1C, 0x60, 0x18, 0x60, 0x18, 0x60, 0x18, 0x60, 0x1C, 0xE0, 0xFF, 0xE0, 0xFF, 0xE0, 0xFF, 0x00, 0x00,  // Code for char q
+        0x0B, 0x00, 0x00, 0xE0, 0x3F, 0xE0, 0x3F, 0xE0, 0x3F, 0xE0, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xC0, 0x00, 0x00, 0x00,  // Code for char r
+        0x09, 0xC0, 0x11, 0xE0, 0x33, 0xE0, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x33, 0x60, 0x3F, 0x60, 0x3F, 0x40, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char s
+        0x09, 0x60, 0x00, 0x60, 0x00, 0xFE, 0x1F, 0xFE, 0x3F, 0xFE, 0x3F, 0x60, 0x30, 0x60, 0x30, 0x60, 0x30, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char t
+        0x0B, 0xE0, 0x0F, 0xE0, 0x1F, 0xE0, 0x3F, 0x00, 0x38, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x38, 0xE0, 0x3F, 0xE0, 0x3F, 0xE0, 0x3F, 0x00, 0x00,  // Code for char u
+        0x0B, 0x60, 0x00, 0xE0, 0x01, 0xE0, 0x07, 0x80, 0x1F, 0x00, 0x3E, 0x00, 0x38, 0x00, 0x3E, 0x80, 0x1F, 0xE0, 0x07, 0xE0, 0x01, 0x60, 0x00, 0x00, 0x00,  // Code for char v
+        0x0B, 0xE0, 0x07, 0xE0, 0x1F, 0xE0, 0x3F, 0x00, 0x3C, 0xE0, 0x1F, 0xE0, 0x0F, 0xE0, 0x1F, 0x00, 0x3C, 0xE0, 0x3F, 0xE0, 0x1F, 0xE0, 0x07, 0x00, 0x00,  // Code for char w
+        0x0A, 0x60, 0x30, 0xE0, 0x38, 0xE0, 0x3D, 0xC0, 0x1F, 0x80, 0x0F, 0x80, 0x0F, 0xC0, 0x1F, 0xE0, 0x3D, 0xE0, 0x38, 0x60, 0x30, 0x00, 0x00, 0x00, 0x00,  // Code for char x
+        0x0A, 0x00, 0x00, 0x60, 0x00, 0xE0, 0x81, 0xE0, 0xE7, 0x80, 0xFF, 0x00, 0x7E, 0x80, 0x1F, 0xE0, 0x07, 0xE0, 0x01, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char y
+        0x0A, 0x60, 0x30, 0x60, 0x38, 0x60, 0x3C, 0x60, 0x3E, 0x60, 0x37, 0xE0, 0x33, 0xE0, 0x31, 0xE0, 0x30, 0x60, 0x30, 0x20, 0x30, 0x00, 0x00, 0x00, 0x00,  // Code for char z
+        0x0A, 0x00, 0x00, 0x80, 0x00, 0xC0, 0x01, 0xFC, 0x1F, 0xFE, 0x3F, 0x7F, 0x7F, 0x07, 0x70, 0x03, 0x60, 0x03, 0x60, 0x03, 0x60, 0x00, 0x00, 0x00, 0x00,  // Code for char {
+        0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x3F, 0xFF, 0x3F, 0xFF, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char |
+        0x0A, 0x00, 0x00, 0x03, 0x60, 0x03, 0x60, 0x03, 0x60, 0x07, 0x70, 0x7F, 0x7F, 0xFE, 0x3F, 0xFC, 0x1F, 0xC0, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char }
+        0x0B, 0x10, 0x00, 0x18, 0x00, 0x1C, 0x00, 0x0C, 0x00, 0x0C, 0x00, 0x1C, 0x00, 0x18, 0x00, 0x18, 0x00, 0x1C, 0x00, 0x0C, 0x00, 0x04, 0x00, 0x00, 0x00,  // Code for char ~
+        0x0B, 0x00, 0x0F, 0x80, 0x0F, 0xC0, 0x0F, 0xE0, 0x0C, 0x70, 0x0C, 0x30, 0x0C, 0x70, 0x0C, 0xE0, 0x0C, 0xC0, 0x0F, 0x80, 0x0F, 0x00, 0x0F, 0x00, 0x00   // Code for char 
+        };
+
+
+//Font Generated by MikroElektronika GLCD Font Creator 1.2.0.0
+//MikroElektronika 2011 
+//http://www.mikroe.com 
+
+//GLCD FontName : Trebuchet_MS16x21
+//GLCD FontSize : 16 x 21
+
+fontdatatype Trebuchet_MS16x21[] PROGMEM = {
+        0x10, 0x15, 0x2E, 0x0D,
+        0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x1E, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char .
+        0x0C, 0x00, 0x00, 0x10, 0x00, 0x00, 0x1E, 0x00, 0xC0, 0x1F, 0x00, 0xF0, 0x1F, 0x00, 0xFE, 0x0F, 0x80, 0xFF, 0x03, 0xF0, 0x7F, 0x00, 0xFE, 0x0F, 0x00, 0xFF, 0x03, 0x00, 0x7F, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char /
+        0x10, 0x00, 0x00, 0x00, 0xC0, 0x7F, 0x00, 0xF0, 0xFF, 0x03, 0xFC, 0xFF, 0x07, 0xFE, 0xFF, 0x0F, 0x3E, 0x80, 0x0F, 0x0F, 0x00, 0x1E, 0x07, 0x00, 0x1C, 0x07, 0x00, 0x1C, 0x07, 0x00, 0x1C, 0x0F, 0x00, 0x1E, 0x1F, 0x80, 0x0F, 0xFE, 0xFF, 0x0F, 0xFC, 0xFF, 0x07, 0xF8, 0xFF, 0x01, 0xC0, 0x7F, 0x00,  // Code for char 0
+        0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x78, 0x00, 0x00, 0x38, 0x00, 0x00, 0x3C, 0x00, 0x00, 0xFE, 0xFF, 0x1F, 0xFE, 0xFF, 0x1F, 0xFF, 0xFF, 0x1F, 0xFF, 0xFF, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char 1
+        0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x18, 0x1E, 0x00, 0x1C, 0x0E, 0x00, 0x1F, 0x0F, 0x80, 0x1F, 0x07, 0xC0, 0x1F, 0x07, 0xF0, 0x1F, 0x07, 0xF8, 0x1D, 0x07, 0xFE, 0x1C, 0x0F, 0x3F, 0x1C, 0xFE, 0x1F, 0x1C, 0xFE, 0x0F, 0x1C, 0xFC, 0x03, 0x1C, 0xF8, 0x00, 0x1C, 0x00, 0x00, 0x1C,  // Code for char 2
+        0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x00, 0x0E, 0x0E, 0x00, 0x0F, 0x0F, 0x00, 0x1E, 0x07, 0x00, 0x1C, 0x07, 0x07, 0x1C, 0x07, 0x07, 0x1C, 0x07, 0x07, 0x1C, 0x8F, 0x0F, 0x1E, 0xFF, 0x1F, 0x1E, 0xFE, 0xFD, 0x0F, 0xFC, 0xFD, 0x0F, 0x78, 0xF8, 0x07, 0x00, 0xF0, 0x01, 0x00, 0x00, 0x00,  // Code for char 3
+        0x10, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x00, 0x00, 0xF0, 0x00, 0x00, 0xF8, 0x00, 0x00, 0xFE, 0x00, 0x00, 0xEF, 0x00, 0x80, 0xE7, 0x00, 0xC0, 0xE3, 0x00, 0xF0, 0xE0, 0x00, 0x78, 0xE0, 0x00, 0xFC, 0xFF, 0x1F, 0xFE, 0xFF, 0x1F, 0xFF, 0xFF, 0x1F, 0xFF, 0xFF, 0x1F, 0x00, 0xE0, 0x00, 0x00, 0xE0, 0x00,  // Code for char 4
+        0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0xFF, 0x03, 0x0F, 0xFF, 0x07, 0x0E, 0xFF, 0x03, 0x1C, 0xFF, 0x01, 0x1C, 0xC7, 0x01, 0x1C, 0xC7, 0x01, 0x1C, 0xC7, 0x01, 0x1E, 0xC7, 0x03, 0x1F, 0xC7, 0xFF, 0x0F, 0x87, 0xFF, 0x0F, 0x07, 0xFF, 0x07, 0x00, 0xFC, 0x01, 0x00, 0x00, 0x00,  // Code for char 5
+        0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00, 0x80, 0xFF, 0x03, 0xE0, 0xFF, 0x07, 0xF0, 0xFF, 0x0F, 0xF8, 0x0F, 0x1E, 0x7C, 0x07, 0x1C, 0x3E, 0x07, 0x1C, 0x1E, 0x07, 0x1C, 0x0F, 0x07, 0x1C, 0x07, 0x0F, 0x1E, 0x02, 0xFE, 0x0F, 0x00, 0xFE, 0x0F, 0x00, 0xFC, 0x07, 0x00, 0xF0, 0x01,  // Code for char 6
+        0x10, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x07, 0x00, 0x00, 0x07, 0x00, 0x18, 0x07, 0x00, 0x1E, 0x07, 0xC0, 0x1F, 0x07, 0xF0, 0x1F, 0x07, 0xFC, 0x0F, 0x07, 0xFF, 0x01, 0xC7, 0x7F, 0x00, 0xF7, 0x0F, 0x00, 0xFF, 0x03, 0x00, 0xFF, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x03, 0x00, 0x00,  // Code for char 7
+        0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x03, 0x78, 0xF8, 0x07, 0xFC, 0xFD, 0x0F, 0xFE, 0xFF, 0x0F, 0xFF, 0x1F, 0x1E, 0x8F, 0x0F, 0x1C, 0x07, 0x07, 0x1C, 0x07, 0x0F, 0x1C, 0x8F, 0x0F, 0x1C, 0xFF, 0x3F, 0x1E, 0xFE, 0xFD, 0x0F, 0xFE, 0xFD, 0x0F, 0x78, 0xF0, 0x07, 0x00, 0xE0, 0x03,  // Code for char 8
+        0x0F, 0x00, 0x00, 0x00, 0xF0, 0x01, 0x00, 0xFC, 0x07, 0x00, 0xFE, 0x0F, 0x00, 0xFE, 0x0F, 0x08, 0x0F, 0x1E, 0x1C, 0x07, 0x1C, 0x1E, 0x07, 0x1C, 0x0F, 0x07, 0x9C, 0x0F, 0x07, 0xDC, 0x07, 0x0F, 0xFE, 0x03, 0xFE, 0xFF, 0x01, 0xFC, 0xFF, 0x00, 0xF8, 0x3F, 0x00, 0xE0, 0x0F, 0x00, 0x00, 0x00, 0x00,  // Code for char 9
+        0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x0C, 0xC0, 0x03, 0x1E, 0xC0, 0x03, 0x1E, 0x80, 0x01, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00   // Code for char :
+        };
+
+
+
diff --git a/libraries/SondeLib/Display.cpp b/libraries/SondeLib/Display.cpp
new file mode 100755
index 0000000..3dbf959
--- /dev/null
+++ b/libraries/SondeLib/Display.cpp
@@ -0,0 +1,1590 @@
+#include <U8x8lib.h>
+#include <U8g2lib.h>
+#include <SPIFFS.h>
+#include <axp20x.h>
+#include <MicroNMEA.h>
+#include "Display.h"
+#include "Sonde.h"
+#include "math.h"
+
+int readLine(Stream &stream, char *buffer, int maxlen);
+
+extern const char *version_name;
+extern const char *version_id;
+
+#include <../fonts/FreeMono9pt7b.h>
+#include <../fonts/FreeMono12pt7b.h>
+#include <../fonts/FreeSans9pt7b.h>
+#include <../fonts/FreeSans12pt7b.h>
+#include <../fonts/Picopixel.h>
+
+extern Sonde sonde;
+
+extern MicroNMEA nmea;
+
+extern AXP20X_Class axp;
+extern bool axp192_found;
+extern SemaphoreHandle_t axpSemaphore;
+
+
+SPIClass spiDisp(HSPI);
+
+const char *sondeTypeStr[NSondeTypes] = { "DFM6", "DFM9", "RS41", "RS92", "M10 " };
+
+byte myIP_tiles[8*11];
+static uint8_t ap_tile[8]={0x00,0x04,0x22,0x92, 0x92, 0x22, 0x04, 0x00};
+
+static const uint8_t font[10][5]={
+  0x3E, 0x51, 0x49, 0x45, 0x3E,   // 0
+  0x00, 0x42, 0x7F, 0x40, 0x00,   // 1
+  0x42, 0x61, 0x51, 0x49, 0x46,   // 2
+  0x21, 0x41, 0x45, 0x4B, 0x31,   // 3
+  0x18, 0x14, 0x12, 0x7F, 0x10,   // 4
+  0x27, 0x45, 0x45, 0x45, 0x39,   // 5
+  0x3C, 0x4A, 0x49, 0x49, 0x30,   // 6
+  0x01, 0x01, 0x79, 0x05, 0x03,   // 7
+  0x36, 0x49, 0x49, 0x49, 0x36,   // 8
+  0x06, 0x49, 0x39, 0x29, 0x1E }; // 9;  .=0x40
+
+
+static unsigned char kmh_tiles[] U8X8_PROGMEM = {
+   0x1F, 0x04, 0x0A, 0x11, 0x00, 0x1F, 0x02, 0x04, 0x42, 0x3F, 0x10, 0x08, 0xFC, 0x22, 0x20, 0xF8
+   };
+static unsigned char ms_tiles[] U8X8_PROGMEM = {
+   0x1F, 0x02, 0x04, 0x02, 0x1F, 0x40, 0x20, 0x10, 0x08, 0x04, 0x12, 0xA8, 0xA8, 0xA4, 0x40, 0x00
+   };
+static unsigned char stattiles[5][4] =  {
+   0x00, 0x1F, 0x00, 0x00 ,   // | == ok
+   0x00, 0x10, 0x10, 0x00 ,   // . == no header found
+   0x1F, 0x15, 0x15, 0x00 ,   // E == decode error
+   0x00, 0x00, 0x00, 0x00 ,   // ' ' == unknown/unassigned
+   0x07, 0x05, 0x07, 0x00 };  // ° = rx ok, but no valid position
+static unsigned char stattilesXL[5][5] =  {
+   0x00, 0x7F, 0x00, 0x00, 0x00,  // | == ok
+   0x00, 0x40, 0x40, 0x00, 0x00,  // . == no header found
+   0x7F, 0x49, 0x49, 0x49, 0x00,  // E == decode error
+   0x00, 0x00, 0x00, 0x00, 0x00,   // ' ' == unknown/unassigned
+   0x07, 0x05, 0x07, 0x00, 0x00 };  // ° = rx ok, but no valid position (not yet used?)
+
+
+//static uint8_t halfdb_tile[8]={0x80, 0x27, 0x45, 0x45, 0x45, 0x39, 0x00, 0x00};
+
+static uint8_t halfdb_tile1[8]={0x00, 0x38, 0x28, 0x28, 0x28, 0xC8, 0x00, 0x00};
+static uint8_t halfdb_tile2[8]={0x00, 0x11, 0x02, 0x02, 0x02, 0x01, 0x00, 0x00};
+
+//static uint8_t empty_tile[8]={0x80, 0x3E, 0x51, 0x49, 0x45, 0x3E, 0x00, 0x00};
+
+static uint8_t empty_tile1[8]={0x00, 0xF0, 0x88, 0x48, 0x28, 0xF0, 0x00, 0x00};
+static uint8_t empty_tile2[8]={0x00, 0x11, 0x02, 0x02, 0x02, 0x01, 0x00, 0x00};
+
+//static uint8_t gps_tile[8]={0x3E, 0x77, 0x63, 0x77, 0x3E, 0x1C, 0x08, 0x00};
+static uint8_t gps_tile[8]={0x00, 0x0E, 0x1F, 0x3B, 0x71, 0x3B, 0x1F, 0x0E};
+static uint8_t nogps_tile[8]={0x41, 0x22, 0x14, 0x08, 0x14, 0x22, 0x41, 0x00};
+
+static uint8_t deg_tile[8]={0x00, 0x06,0x09, 0x09, 0x06, 0x00, 0x00, 0x00};
+
+
+/* Description of display layouts.
+ * for each display, the content is described by a DispEntry structure
+ * timeout values are in milliseconds, for view activ, rx signal present, no rx signal present
+ * for each displey, actions (switching to different sonde or different view) can be defined
+ * based on key presses or on expired timeouts
+ */
+DispEntry searchLayout[] = {
+	{0, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawText, "Scan:"},
+	{0, 8, FONT_LARGE, -1, 0xFFFF, 0, disp.drawType, NULL},
+	{3, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawFreq, " MHz"},
+	{5, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawSite, "l"},
+	{7, 5, 0, -1, 0xFFFF, 0, disp.drawIP, NULL},	
+	{-1, -1, -1, 0, 0, 0, NULL, NULL},
+};
+int16_t searchTimeouts[] = { -1, 0, 0 };
+uint8_t searchActions[] = {
+	ACT_NONE,
+	ACT_DISPLAY_DEFAULT, ACT_NONE, ACT_DISPLAY_SPECTRUM, ACT_DISPLAY_WIFI,
+	ACT_NONE, ACT_NONE, ACT_NONE, ACT_NONE,
+	ACT_NONE, ACT_DISPLAY_DEFAULT, ACT_NEXTSONDE};
+DispEntry legacyLayout[] = {
+	{0, 5, FONT_SMALL, -1, 0xFFFF, 0, disp.drawFreq, " MHz"},
+	{1, 8, FONT_SMALL, -1, 0xFFFF, 0, disp.drawAFC, NULL},
+	{0, 0, FONT_SMALL, -1, 0xFFFF, 0, disp.drawType, NULL},
+	{1, 0, FONT_SMALL, -1, 0xFFFF, 0, disp.drawID, NULL},
+	{2, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawLat, NULL},
+	{4, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawLon, NULL},
+	{2, 10, FONT_SMALL, -1, 0xFFFF, 0, disp.drawAlt, NULL},
+	{3, 10, FONT_SMALL, -1, 0xFFFF, 0, disp.drawHS, NULL},
+	{4, 9, FONT_SMALL, -1, 0xFFFF, 0, disp.drawVS, NULL},
+	{6, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawRSSI, NULL},
+	{6, 7, 0, -1, 0xFFFF, 0, disp.drawQS, NULL},
+	{7, 0, FONT_SMALL, -1, 0xFFFF, 0, disp.drawVBat, "%"},
+	{7, 5, 0, -1, 0xFFFF, 0, disp.drawIP, NULL},	
+	{-1, -1, -1, 0, 0, 0, NULL, NULL},
+};
+int16_t legacyTimeouts[] = { -1, -1, 20000 };
+uint8_t legacyActions[] = {
+	ACT_NONE,
+	ACT_NEXTSONDE, ACT_DISPLAY(0), ACT_DISPLAY_SPECTRUM, ACT_DISPLAY_WIFI,
+	ACT_DISPLAY(2), ACT_NONE, ACT_NONE, ACT_NONE,
+	ACT_NONE, ACT_NONE, ACT_DISPLAY(0)};
+DispEntry fieldLayout[] = {
+	{2, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawLat, NULL},
+	{4, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawLon, NULL},
+	{3, 10, FONT_SMALL, -1, 0xFFFF, 0, disp.drawHS, NULL},
+	{4, 9, FONT_SMALL, -1, 0xFFFF, 0, disp.drawVS, NULL},
+	{0, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawID, NULL},
+	{6, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawAlt, NULL},
+	{6, 7, 0, -1, 0xFFFF, 0, disp.drawQS, NULL},
+	{-1, -1, -1, 0, 0, 0, NULL, NULL},
+};
+
+int16_t fieldTimeouts[] = { -1, -1, -1 };
+uint8_t fieldActions[] = {
+	ACT_NONE,
+	ACT_NEXTSONDE, ACT_DISPLAY(0), ACT_DISPLAY_SPECTRUM, ACT_DISPLAY_WIFI,
+	ACT_DISPLAY(4), ACT_NONE, ACT_NONE, ACT_NONE,
+	ACT_NONE, ACT_NONE, ACT_NONE};
+DispEntry field2Layout[] = {
+	{2, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawLat, NULL},
+	{4, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawLon, NULL},
+	{1, 12, FONT_SMALL, -1, 0xFFFF, 0, disp.drawType, NULL},
+	{0, 9, FONT_SMALL, -1, 0xFFFF, 0, disp.drawFreq, ""},
+	{3, 10, FONT_SMALL, -1, 0xFFFF, 0, disp.drawHS, NULL},
+	{4, 9, FONT_SMALL, -1, 0xFFFF, 0, disp.drawVS, NULL},
+	{0, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawID, NULL},
+	{6, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawAlt, NULL},
+	{6, 7, 0, -1, 0xFFFF, 0, disp.drawQS, NULL},
+	{-1, -1, -1, 0, 0, 0, NULL, NULL},
+};
+uint8_t field2Actions[] = {
+	ACT_NONE,
+	ACT_NEXTSONDE, ACT_DISPLAY(0), ACT_DISPLAY_SPECTRUM, ACT_DISPLAY_WIFI,
+	ACT_DISPLAY(1), ACT_NONE, ACT_NONE, ACT_NONE,
+	ACT_NONE, ACT_NONE, ACT_NONE};
+DispEntry gpsLayout[] = {
+	{0, 0, FONT_LARGE, -1, 0xFFFF, 0, disp.drawID, NULL},
+	{2, 0, FONT_SMALL, -1, 0xFFFF, 0, disp.drawLat, NULL},
+	{3, 0, FONT_SMALL, -1, 0xFFFF, 0, disp.drawLon, NULL},
+	{4, 0, FONT_SMALL, -1, 0xFFFF, 0, disp.drawAlt, NULL},
+	//{6, 0, FONT_SMALL, -1, 0xFFFF, 0, disp.drawGPS, "V"},
+	{6, 1, FONT_SMALL, -1, 0xFFFF, 0,disp.drawGPS, "A"},
+	{6, 8, FONT_SMALL, -1, 0xFFFF, 0,disp.drawGPS, "O"},
+	{7, 0, FONT_SMALL, -1, 0xFFFF, 0, disp.drawGPS, "D"},
+	{7, 8, FONT_SMALL, -1, 0xFFFF, 0, disp.drawGPS, "I"},
+	{-1, -1, -1, 0, 0, 0, NULL, NULL},
+};
+uint8_t gpsActions[] = {
+	ACT_NONE,
+	ACT_NEXTSONDE, ACT_DISPLAY(0), ACT_DISPLAY_SPECTRUM, ACT_DISPLAY_WIFI,
+	ACT_DISPLAY(1), ACT_NONE, ACT_NONE, ACT_NONE,
+	ACT_NONE, ACT_NONE, ACT_NONE};
+
+DispInfo staticLayouts[5] = {
+  { searchLayout, searchActions, searchTimeouts, "StaticSearch" },
+  { legacyLayout, legacyActions, legacyTimeouts, "StaticLegacy" },
+  { fieldLayout, fieldActions, fieldTimeouts, "StaticField1" },
+  { field2Layout, field2Actions, fieldTimeouts, "StaticFiel2" },
+  { gpsLayout, gpsActions, fieldTimeouts, "StaticGPS" } };
+
+
+/////////////// Wrapper code for various display
+
+// ALLFONTS requires 30k extra flash memory... for now there is still enough space :)
+#define ALLFONTS 1
+static const uint8_t *fl[] = { 
+                u8x8_font_chroma48medium8_r,        // 0 ** default small
+                u8x8_font_7x14_1x2_f,               // 1 ** default large
+#ifdef ALLFONTS
+                u8x8_font_amstrad_cpc_extended_f,   // 2
+                u8x8_font_5x7_f,                    // 3
+                u8x8_font_5x8_f,                    // 4
+                u8x8_font_8x13_1x2_f,               // 5
+                u8x8_font_8x13B_1x2_f,              // 6
+                u8x8_font_7x14B_1x2_f,              // 7
+                u8x8_font_artossans8_r,             // 8
+                u8x8_font_artosserif8_r,            // 9
+                u8x8_font_torussansbold8_r,         // 10 
+                u8x8_font_victoriabold8_r,          // 11
+                u8x8_font_victoriamedium8_r,        // 12
+                u8x8_font_pressstart2p_f,           // 13
+                u8x8_font_pcsenior_f,               // 14
+                u8x8_font_pxplusibmcgathin_f,       // 15
+                u8x8_font_pxplusibmcga_f,           // 16
+                u8x8_font_pxplustandynewtv_f,       // 17
+#endif
+};
+
+
+void U8x8Display::begin() {
+	Serial.printf("Init SSD1306 display %d %d\n", sonde.config.oled_scl, sonde.config.oled_sda);
+	//u8x8 = new U8X8_SSD1306_128X64_NONAME_SW_I2C(/* clock=*/ sonde.config.oled_scl, /* data=*/ sonde.config.oled_sda, /* reset=*/ sonde.config.oled_rst); // Unbuffered, basic graphics, software I2C
+	if (_type==2) {
+               	u8x8 = new U8X8_SH1106_128X64_NONAME_HW_I2C(/* reset=*/ sonde.config.oled_rst, /* clock=*/ sonde.config.oled_scl, /* data=*/ sonde.config.oled_sda); // Unbuffered, basic graphics, software I2C
+	} else { //__type==0 or anything else
+		u8x8 = new U8X8_SSD1306_128X64_NONAME_HW_I2C(/* reset=*/ sonde.config.oled_rst, /* clock=*/ sonde.config.oled_scl, /* data=*/ sonde.config.oled_sda); // Unbuffered, basic graphics, software I2C
+	} 
+	u8x8->begin();
+	if(sonde.config.oled_orient==3) u8x8->setFlipMode(true);
+
+	fontlist = fl;
+	nfonts = sizeof(fl)/sizeof(uint8_t *);
+	Serial.printf("Size of font list is %d\n", nfonts);
+}
+
+void U8x8Display::clear() {
+	u8x8->clear();
+}
+
+
+// For u8x8 oled display: 0=small font, 1=large font 7x14
+void U8x8Display::setFont(uint8_t fontindex) {
+	if(fontindex>=nfonts) fontindex=0; // prevent overflow
+	u8x8->setFont( fontlist[fontindex] );
+}
+
+void U8x8Display::getDispSize(uint8_t *height, uint8_t *width, uint8_t *lineskip, uint8_t *colskip) {
+	// TODO: maybe we should decided depending on font size (single/double?)
+        if(height) *height = 8;
+        if(width) *width = 16;
+	if(lineskip) *lineskip = 1;
+	if(colskip) *colskip = 1;
+}
+
+void U8x8Display::drawString(uint8_t x, uint8_t y, const char *s, int16_t width, uint16_t fg, uint16_t bg) {
+	u8x8->drawString(x, y, s);
+}
+
+void U8x8Display::drawTile(uint8_t x, uint8_t y, uint8_t cnt, uint8_t *tile_ptr) {
+	u8x8->drawTile(x, y, cnt, tile_ptr);
+}
+
+void U8x8Display::drawBitmap(uint16_t x1, uint16_t y1, const uint16_t* bitmap, int16_t w, int16_t h) {
+	// not supported
+}
+void U8x8Display::drawTriangle(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t x3, uint16_t y3, uint16_t color, bool fill) {
+	// not supported (yet)
+}
+
+void U8x8Display::welcome() {
+	u8x8->clear();
+  	setFont(FONT_LARGE);
+  	drawString(8 - strlen(version_name) / 2, 1, version_name);
+  	//drawString(8 - strlen(version_id) / 2, 2, version_id);
+  	setFont(FONT_SMALL);
+	drawString(0, 4, "RS41/92,DFM,M10");
+  	drawString(0, 6, "by FRS2013 ");
+  	drawString(11, 6, version_id);
+}
+
+static String previp;
+void U8x8Display::drawIP(uint8_t x, uint8_t y, int16_t width, uint16_t fg, uint16_t bg) {
+	if(!previp.equals(sonde.ipaddr)) {
+		// ip address has changed
+		// create tiles
+  		memset(myIP_tiles, 0, 11*8);
+		int len = sonde.ipaddr.length();
+		const char *ip = sonde.ipaddr.c_str();
+		int pix = (len-3)*6+6;
+		int tp = 80-pix+8;
+		//if(sonde.isAP) memcpy(myIP_tiles+(tp<16?0:8), ap_tile, 8);
+		memcpy(myIP_tiles+(tp<16?0:8), ap_tile, 8);
+		for(int i=0; i<len; i++) {
+			if(ip[i]=='.') { myIP_tiles[tp++]=0x40; myIP_tiles[tp++]=0x00; }
+        		else {
+          			int idx = ip[i]-'0';
+				memcpy(myIP_tiles+tp, &font[idx], 5);
+				myIP_tiles[tp+5] = 0;
+				tp+=6;
+        		}
+		}
+		while(tp<8*10) { myIP_tiles[tp++]=0; }
+			previp = sonde.ipaddr;
+	}
+	// draw tiles
+	u8x8->drawTile(x, y, 11, myIP_tiles);
+}
+
+// len must be multiple of 2, size is fixed for u8x8 display
+void U8x8Display::drawQS(uint8_t x, uint8_t y, uint8_t len, uint8_t /*size*/, uint8_t *stat, uint16_t fg, uint16_t bg) {
+	for(int i=0; i<len; i+=2) {
+	        uint8_t tile[8];
+	        *(uint32_t *)(&tile[0]) = *(uint32_t *)(&(stattiles[stat[i]]));
+	        *(uint32_t *)(&tile[4]) = *(uint32_t *)(&(stattiles[stat[i+1]]));
+	        drawTile(x+i/2, y, 1, tile);
+	}
+}
+
+
+const GFXfont *gfl[] = {
+	&FreeMono9pt7b,		// 3
+	&FreeMono12pt7b,	// 4
+	&FreeSans9pt7b,		// 5
+	&FreeSans12pt7b,	// 6
+	&Picopixel,             // 7
+};
+struct gfxoffset_t {
+	uint8_t yofs, yclear;
+};
+// obtained as max offset from font (last column) and maximum height (3rd column) in glyphs
+// first value: offset: max offset from font glyphs (last column * (-1))   (check /, \, `, $)`
+// yclear:max height: max of (height in 3rd column) + (yofs + 6th column)  (check j)
+const struct gfxoffset_t gfxoffsets[]={
+	{ 11, 15 },  // 13+11-9 "j"
+	{ 15, 20 },  // 19+15-14
+        { 13, 18 },  // 17+13-12 "j" 
+        { 17, 23 }, // 23+17-17
+        {  4, 6},       // 6+4-4
+};
+static int ngfx = sizeof(gfl)/sizeof(GFXfont *);
+	
+#include <pgmspace.h>
+#define pgm_read_pointer(addr) ((void *)pgm_read_dword(addr))
+
+///////////////
+
+
+char Display::buf[17];
+char Display::lineBuf[Display::LINEBUFLEN];
+
+RawDisplay *Display::rdis = NULL;
+
+//TODO: maybe merge with initFromFile later?
+void Display::init() {
+	Serial.printf("disptype is %d\n",sonde.config.disptype);
+	rdis = new U8x8Display(sonde.config.disptype);
+	Serial.println("Display created");
+	rdis->begin();
+	delay(100);
+	Serial.println("Display initialized");
+	rdis->clear();
+}
+
+
+Display::Display() {
+	layouts = staticLayouts;
+	setLayout(0);
+}
+
+#define MAXSCREENS 20
+#define DISP_ACTIONS_N 12
+#define DISP_TIMEOUTS_N 3
+
+void Display::replaceLayouts(DispInfo *newlayouts, int nnew) {
+	if(nnew<1) return;  // no new layouts => ignore
+
+	// remember old layouts
+	DispInfo *old = layouts;
+
+	// assign new layouts and current layout
+	Serial.printf("replaceLayouts: idx=%d n(new)=%d\n", layoutIdx, nLayouts);
+	layouts = newlayouts;
+	nLayouts = nnew;
+	if(layoutIdx >= nLayouts) layoutIdx = 0;
+	layout = layouts+layoutIdx;
+
+	// Make it unlikely that anyone else is still using previous layouts
+	delay(500);
+
+	// and release memory not used any more
+	if(old==staticLayouts) return;
+	for(int i=0; i<MAXSCREENS; i++) {
+		if(old[i].de) free(old[i].de);
+	}
+	free(old);
+}
+
+int Display::allocDispInfo(int entries, DispInfo *d, char *label)
+{
+	int totalsize = (entries+1)*sizeof(DispEntry) + DISP_ACTIONS_N*sizeof(uint8_t) + DISP_TIMEOUTS_N * sizeof(int16_t);
+	char *mem = (char *)malloc(totalsize);
+	if(!mem) return -1;
+	memset (mem, 0, totalsize);
+
+	d->de = (DispEntry *)mem;
+	mem += (entries+1) * sizeof(DispEntry);
+
+	d->actions = (uint8_t *)mem;
+	mem += DISP_ACTIONS_N * sizeof(uint8_t);
+	d->actions[0] = ACT_NONE;
+
+	d->timeouts = (int16_t *)mem;
+
+	d->label = label;
+	Serial.printf("allocated %d bytes (%d entries) for %p (addr=%p)\n", totalsize, entries, d, d->de);
+	return 0;
+}
+
+uint16_t encodeColor(uint32_t col) {
+	return (col>>19) << 11 | ((col>>10)&0x3F) << 5 | ((col>>3)&0x1F);
+}
+uint16_t encodeColor(char *colstr) {
+	uint32_t col;
+	int res=sscanf(colstr, "%" SCNx32, &col);
+	if(res!=1) return 0xffff;
+	return encodeColor(col);
+}
+
+void Display::parseDispElement(char *text, DispEntry *de)
+{
+	char type = *text;
+	if(type>='A'&&type<='Z') {
+		type += 32;  // lc
+		de->fmt = fontlar;
+	} else {
+		de->fmt = fontsma;
+	}
+	de->fg = colfg;
+	de->bg = colbg;
+	switch(type) {
+	case 'l':
+		de->func = disp.drawLat; 
+		break;
+	case 'o':
+		de->func = disp.drawLon; 
+		break;
+	case 'a':
+		de->func = disp.drawAlt; 
+		break;
+	case 'h':
+		de->func = disp.drawHS; 
+		de->extra = text[1]?strdup(text+1):NULL; 
+		break;
+	case 'v':
+		de->func = disp.drawVS; 
+		de->extra = text[1]?strdup(text+1):NULL; 
+		break;
+	case 'i':
+		de->func = disp.drawID;
+		de->extra = strdup(text+1);
+		break;
+	case 'q':
+		{
+		struct StatInfo *statinfo = (struct StatInfo *)malloc(sizeof(struct StatInfo));
+		// maybe enable more flexible configuration?
+		statinfo->size=3;
+		statinfo->len=18;
+		if(text[1]=='4') statinfo->size = 4;
+
+		de->extra = (const char *)statinfo;
+		de->func = disp.drawQS;
+		}
+		break;
+	case 't':
+		de->func = disp.drawType; 
+		break;
+	case 'c':
+		de->func = disp.drawAFC; 
+		break;
+	case 'y':
+		de->func = disp.drawVBat;
+		de->extra = strdup(text+1); 
+		break;
+	case 'f':
+		de->func = disp.drawFreq;
+		de->extra = strdup(text+1);
+		Serial.printf("parsing 'f' entry: extra is '%s'\n", de->extra);
+		break;
+	case 'n':
+		// IP address / small always uses tiny font on TFT for backward compatibility
+		// Large font can be used arbitrarily
+		if(de->fmt==fontsma) de->fmt=0;
+		de->func = disp.drawIP; break;
+	case 's':
+		de->func = disp.drawSite;
+		de->extra = strdup(text+1);
+		break;
+	case 'k':
+		de->func = disp.drawKilltimer;
+		de->extra = strdup(text+1);
+		break;
+	case 'g':
+		de->func = disp.drawGPS;
+		de->extra = strdup(text+1);
+		Serial.printf("parsing 'g' entry: extra is '%s'\n", de->extra);
+		break;
+	case 'r':
+		de->func = disp.drawRSSI; 
+		break;
+	case 'x':
+		de->func = disp.drawText;
+		de->extra = strdup(text+1);
+		break;
+	case 'b':
+		de->func = disp.drawBatt;
+		de->extra = strdup(text+1);
+		break;
+
+	default:
+		Serial.printf("Unknown element: %c\n", type);
+		break;
+	}
+}
+
+static uint8_t ACTION(char c) {
+	switch(c) {
+	case 'D': 
+		return ACT_DISPLAY_DEFAULT;
+	case 'F':
+		return ACT_DISPLAY_SPECTRUM;
+	case 'W':
+		return ACT_DISPLAY_WIFI;
+	case '+':
+		return ACT_NEXTSONDE;
+	case '#':	
+		return ACT_NONE;
+	case '>':
+		return ACT_DISPLAY_NEXT;
+	default:
+		if(c>='0'&&c<='9')
+			return ACT_DISPLAY(c-'0');
+		// Hack, will change later to better syntax
+		if(c>='a'&&c<='z')
+			return ACT_ADDFREQ(c-'a'+2);
+	}
+	return ACT_NONE;
+}
+
+
+int Display::countEntries(File f) {
+	int pos = f.position();
+	int n = 0;
+	while(1) {
+		//String line = readLine(f);  //f.readStringUntil('\n');
+		//line.trim();
+		//const char *c=line.c_str();
+		readLine(f, lineBuf, LINEBUFLEN);
+		const char *c = trim(lineBuf);
+		if(*c=='#') continue;
+		if(*c>='0'&&*c<='9') n++;
+		if(strchr(c,'=')) continue;
+		break;
+	}	
+	f.seek(pos, SeekSet);
+	Serial.printf("Counted %d entries\n", n);
+	return n;
+}
+
+void Display::initFromFile() {
+	File d = SPIFFS.open("/screens.txt", "r");
+	if(!d) return;
+
+	DispInfo *newlayouts = (DispInfo *)malloc(MAXSCREENS * sizeof(DispInfo));
+	if(!newlayouts) {
+		Serial.println("Init from file: FAILED, not updating layouts");
+		return;
+	}
+	memset(newlayouts, 0, MAXSCREENS * sizeof(DispInfo));
+
+	// default color
+	colfg = 0xffff; // white; only used for ILI9225
+	colbg = 0;  // black; only used for ILI9225
+	int idx = -1;
+	int what = -1;
+	int entrysize;
+	Serial.printf("Reading from /screens.txt. available=%d\n",d.available());
+	while(d.available()) {
+		//Serial.printf("Unused stack: %d\n", uxTaskGetStackHighWaterMark(0));
+		const char *ptr;
+		readLine(d, lineBuf, LINEBUFLEN);
+		const char *s = trim(lineBuf);
+		// String line = readLine(d);  
+		// line.trim();
+		// const char *s = line.c_str();
+		Serial.printf("Line: '%s'\n", s);
+		if(*s == '#') continue;  // ignore comments
+		switch(what) {
+		case -1:	// wait for start of screen (@)
+			{
+			if(*s != '@') {
+				Serial.printf("Illegal start of screen: %s\n", s);
+				continue;
+			}
+			char *label = strdup(s+1);
+			entrysize = countEntries(d);
+			Serial.printf("Reading entry with %d elements\n", entrysize);
+			idx++;
+			int res = allocDispInfo(entrysize, &newlayouts[idx], label);
+			Serial.printf("allocDispInfo: idx %d: label is %p - %s\n",idx,newlayouts[idx].label, newlayouts[idx].label);
+			if(res<0) {
+				Serial.println("Error allocating memory for disp info");
+				continue;
+			}
+			what = 0;
+			}
+			break;
+		default:	// parse content... (additional data or line `what`)
+			if(strncmp(s,"timer=",6)==0) {  // timer values
+				char t1[10],t2[10],t3[10];
+				sscanf(s+6, "%5[0-9a-zA-Z-] , %5[0-9a-zA-Z-] , %5[0-9a-zA-Z-]", t1, t2, t3);
+				Serial.printf("timers are %s, %s, %s\n", t1, t2, t3);
+				newlayouts[idx].timeouts[0] = (*t1=='n'||*t1=='N')?sonde.config.norx_timeout:atoi(t1);
+				newlayouts[idx].timeouts[1] = (*t2=='n'||*t2=='N')?sonde.config.norx_timeout:atoi(t2);
+				newlayouts[idx].timeouts[2] = (*t3=='n'||*t3=='N')?sonde.config.norx_timeout:atoi(t3);
+				// Code later assumes milliseconds, but config.txt and screens.txt use values in seconds
+				if(newlayouts[idx].timeouts[0]>0) newlayouts[idx].timeouts[0]*=1000;
+				if(newlayouts[idx].timeouts[1]>0) newlayouts[idx].timeouts[1]*=1000;
+				if(newlayouts[idx].timeouts[2]>0) newlayouts[idx].timeouts[2]*=1000;
+				//sscanf(s+6, "%hd,%hd,%hd", newlayouts[idx].timeouts, newlayouts[idx].timeouts+1, newlayouts[idx].timeouts+2);
+				Serial.printf("timer values: %d, %d, %d\n", newlayouts[idx].timeouts[0], newlayouts[idx].timeouts[1], newlayouts[idx].timeouts[2]);
+			} else if(strncmp(s, "key1action=",11)==0) { // key 1 actions
+				char c1,c2,c3,c4;
+				sscanf(s+11, "%c,%c,%c,%c", &c1, &c2, &c3, &c4);
+				newlayouts[idx].actions[1] = ACTION(c1);
+				newlayouts[idx].actions[2] = ACTION(c2);
+				newlayouts[idx].actions[3] = ACTION(c3);
+				newlayouts[idx].actions[4] = ACTION(c4);
+			} else if(strncmp(s, "key2action=",11)==0) { // key 2 actions
+				char c1,c2,c3,c4;
+				sscanf(s+11, "%c,%c,%c,%c", &c1, &c2, &c3, &c4);
+				newlayouts[idx].actions[5] = ACTION(c1);
+				newlayouts[idx].actions[6] = ACTION(c2);
+				newlayouts[idx].actions[7] = ACTION(c3);
+				newlayouts[idx].actions[8] = ACTION(c4);
+				Serial.printf("parsing key2action: %c %c %c %c\n", c1, c2, c3, c4);
+			} else if(strncmp(s, "timeaction=",11)==0) { // timer actions
+				char c1,c2,c3;
+				sscanf(s+11, "%c,%c,%c", &c1, &c2, &c3);
+				newlayouts[idx].actions[9] = ACTION(c1);
+				newlayouts[idx].actions[10] = ACTION(c2);
+				newlayouts[idx].actions[11] = ACTION(c3);
+			} else if(strncmp(s, "fonts=",6)==0) { // change font
+				sscanf(s+6, "%d,%d", &fontsma, &fontlar);
+			} else if(strncmp(s, "scale=",6)==0) { // change line->pixel scaling for ILI9225 display
+				sscanf(s+6, "%d,%d", &yscale, &xscale);
+			} else if(strncmp(s, "color=",6)==0) { //
+				int res;
+				uint32_t fg,bg;
+				res=sscanf(s+6, "%" SCNx32 ",%" SCNx32, &fg, &bg);
+				colfg = (fg>>19) << 11 | ((fg>>10)&0x3F) << 5 | ((fg>>3)&0x1F);
+				if(res==2) {
+					colbg = (bg>>19) << 11 | ((bg>>10)&0x3F) << 5 | ((bg>>3)&0x1F);
+				}
+			} else if( (ptr=strchr(s, '=')) ) {  // one line with some data...
+				float x,y,w;
+				int n;
+				char text[61];
+				n=sscanf(s, "%f,%f,%f", &y, &x, &w);
+				sscanf(ptr+1, "%60[^\r\n]", text);
+				if(sonde.config.disptype==1) { x*=xscale; y*=yscale; w*=xscale; }
+				newlayouts[idx].de[what].x = x;
+				newlayouts[idx].de[what].y = y;
+				newlayouts[idx].de[what].width = n>2 ? w : WIDTH_AUTO;
+				parseDispElement(text, newlayouts[idx].de+what);
+				Serial.printf("entry at %d,%d width=%d font %d, color=%x,%x\n", (int)x, (int)y, newlayouts[idx].de[what].width, newlayouts[idx].de[what].fmt,
+					newlayouts[idx].de[what].fg, newlayouts[idx].de[what].bg);
+				if(newlayouts[idx].de[what].func == disp.drawGPS) {
+					newlayouts[idx].usegps = GPSUSE_BASE|GPSUSE_DIST|GPSUSE_BEARING; // just all for now
+				}
+				what++;
+				newlayouts[idx].de[what].func = NULL;
+			} else {
+				for(int i=0; i<12; i++) {
+					Serial.printf("action %d: %d\n", i, (int)newlayouts[idx].actions[i]);
+				}
+ 				what=-1;
+			}
+			break;
+		}
+	}
+	replaceLayouts(newlayouts, idx+1);
+}
+
+void Display::circ(int x=1, int y=1) {
+	// draw circle
+		uint8_t tiles[48] = { 
+		0, 0, 0, 0, 0, 0, 128, 64,
+		32, 16, 8, 4, 4, 2, 2, 2,
+		1, 1, 1, 1, 1, 1, 1, 1,
+		1, 1, 1, 1, 1, 1, 1, 1,
+		2, 2, 2, 4, 4, 8, 16, 32,
+		64, 128, 0, 0, 0, 0, 0, 0 };
+		disp.rdis->drawTile(x, y, 6, tiles);
+		
+		uint8_t tiles2[48] = { 
+		0, 0, 0, 224, 28, 3, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 3, 28, 224, 0, 0, 0 };
+		disp.rdis->drawTile(x, y+1, 6, tiles2);
+		
+		uint8_t tiles3[48] = { 
+		0, 0, 0, 255, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 255, 0, 0, 0 };
+		disp.rdis->drawTile(x, y+2, 6, tiles3);
+		
+		uint8_t tiles4[48] = { 
+		0, 0, 0, 31, 224, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 224, 31, 0, 0, 0};
+		disp.rdis->drawTile(x, y+3, 6, tiles4);	
+		
+		uint8_t tiles5[48] = { 
+		0, 0, 0, 0, 1, 6, 8, 16,
+		32, 64, 128, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 128, 64, 32,
+		16, 8, 6, 1, 0, 0, 0, 0 };
+		disp.rdis->drawTile(x, y+4, 6, tiles5);
+			
+		uint8_t tiles6[48] = { 
+		0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 1, 1, 2, 2, 2,
+		4, 4, 4, 4, 4, 4, 4, 4,
+		4, 4, 4, 4, 4, 4, 4, 4,
+		2, 2, 2, 1, 1, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0 };
+		disp.rdis->drawTile(x, y+5, 6, tiles6);
+		
+		uint8_t centres[16] = { 
+		0, 0, 0, 0, 0, 0, 0, 128,
+		128, 0, 0, 0, 0, 0, 0, 0
+		};
+		disp.rdis->drawTile(x+2, y+2, 2, centres);
+		uint8_t centres2[16] = { 
+		0, 0, 0, 0, 0, 0, 0, 1,
+		1, 0, 0, 0, 0, 0, 0, 0
+		};
+		disp.rdis->drawTile(x+2, y+3, 2, centres2);
+		
+		//N
+		uint8_t N[16] = {0,0,0,0,0, 63, 2, 4,
+		8, 16, 63, 0,0,0,0,0};
+		disp.rdis->drawTile(x+2, y-1, 2, N);
+		//S
+		uint8_t S[16] = {0, 0, 0, 0, 0, 38, 73, 73,
+		73, 73, 50, 0,0,0,0,0};
+		disp.rdis->drawTile(x+2, y+6, 2, S);
+		//O
+		uint8_t O[8] = {0,224, 48, 16, 16, 48, 224, 0};
+		disp.rdis->drawTile(x-1, y+2, 1, O);		
+		uint8_t O2[8] = {0,7, 12, 8, 8, 12, 7, 0};
+		disp.rdis->drawTile(x-1, y+3, 1, O2);				
+		//E
+		uint8_t E[8] = {0,240, 144, 144, 16, 16, 16, 0};
+		disp.rdis->drawTile(x+6, y+2, 1, E);		
+		uint8_t E2[8] = {0,15, 9, 9, 8, 8, 8, 0};
+		disp.rdis->drawTile(x+6, y+3, 1, E2);		
+		
+}
+
+
+void Display::setLayout(int newidx) {
+	Serial.printf("setLayout: %d (max is %d)\n", newidx, nLayouts);
+	if(newidx>=nLayouts) newidx = 0; 
+	layout = &layouts[newidx];
+	layoutIdx = newidx;
+}
+
+void Display::drawString(DispEntry *de, const char *str) {
+	rdis->drawString(de->x, de->y, str, de->width, de->fg, de->bg);
+}
+
+void Display::drawLat(DispEntry *de) {
+	rdis->setFont(de->fmt);
+	if(!sonde.si()->validPos) {
+	   drawString(de,"00.0000");
+	   return;
+	}
+	snprintf(buf, 16, "%2.5f", sonde.si()->lat);
+	drawString(de,buf);
+}
+void Display::drawLon(DispEntry *de) {
+	rdis->setFont(de->fmt);
+	if(!sonde.si()->validPos) {
+	   drawString(de,"00.0000");
+	   return;
+	}
+	snprintf(buf, 16, "%2.5f", sonde.si()->lon);
+	drawString(de,buf);
+}
+void Display::drawAlt(DispEntry *de) {
+	rdis->setFont(de->fmt);
+	if(!sonde.si()->validPos) {
+	   drawString(de,"00000m");
+	   return;
+	}
+	float alt = sonde.si()->alt;
+	//testing only....   alt += 30000-454;
+	snprintf(buf, 16, alt>=1000?"   %5.0fm":"   %3.1fm", alt);
+	drawString(de,buf+strlen(buf)-6);
+}
+void Display::drawHS(DispEntry *de) {
+	rdis->setFont(de->fmt);
+	if(!sonde.si()->validPos) {
+	   drawString(de,"00.00");
+	   return;
+	}
+	boolean is_ms = (de->extra && de->extra[0]=='m')?true:false;  // m/s or km/h
+	float hs = sonde.si()->hs;
+	if(is_ms) hs = hs / 3.6;
+	boolean has_extra = (de->extra && de->extra[1]!=0)? true: false;
+	snprintf(buf, 16, hs>99?" %3.0f":" %2.1f", hs);
+	if(has_extra) { strcat(buf, de->extra+1); }
+	drawString(de,buf+strlen(buf)-4- (has_extra?strlen(de->extra+1):0) );
+	if(!has_extra) rdis->drawTile(de->x+4,de->y,2,is_ms?ms_tiles:kmh_tiles);
+}
+void Display::drawVS(DispEntry *de) {
+	rdis->setFont(de->fmt);
+	if(!sonde.si()->validPos) {
+	   drawString(de," 00.00");
+	   return;
+	}
+	snprintf(buf, 16, "  %+2.1f", sonde.si()->vs);
+	Serial.printf("drawVS: extra is %s width=%d\n", de->extra?de->extra:"<null>", de->width);
+	if(de->extra) { strcat(buf, de->extra); }
+	drawString(de, buf+strlen(buf)-5- (de->extra?strlen(de->extra):0) );
+	if(!de->extra) rdis->drawTile(de->x+5,de->y,2,ms_tiles);
+}
+void Display::drawID(DispEntry *de) {
+	rdis->setFont(de->fmt);
+	if(!sonde.si()->validID) {
+		drawString(de, "nnnnnnnn ");
+		return;
+	}
+	// TODO: handle DFM6 IDs
+
+	if(!de->extra || de->extra[0]=='s') {
+		// real serial number, as printed on sonde
+		drawString(de, sonde.si()->ser);
+	} else if (de->extra[0]=='a') {
+		// autorx sonde number ("DF9" and last 6 digits of real serial number)
+		if(sonde.si()->type == STYPE_DFM09) {
+			int n = strlen(sonde.si()->ser) - 6;
+			if(n<0) n=0;
+			memcpy(buf, "DF9", 3);
+			memcpy(buf+3, sonde.si()->ser+n, 6);
+			drawString(de, buf);
+		} else {
+			drawString(de, sonde.si()->ser);
+		}
+	} else {
+		// dxlAPRS sonde number (DF6 (why??) and 5 last digits of serial number as hex number
+		drawString(de, sonde.si()->id);
+	}
+}
+void Display::drawRSSI(DispEntry *de) {
+	rdis->setFont(de->fmt);
+	Serial.printf("\ndBSmetre %d\n",sonde.config.dbsmetre);
+	if (sonde.config.dbsmetre==0) {
+		if(sonde.config.disptype!=1) {
+			snprintf(buf, 16, "-%d   ", sonde.si()->rssi/2);
+			int len=strlen(buf)-3;
+			Serial.printf("drawRSSI: %d %d %d (%d)[%d]\n", de->y, de->x, sonde.si()->rssi/2, sonde.currentSonde, len);
+			buf[5]=0;
+			drawString(de,buf);
+			rdis->drawTile(de->x+len, de->y, 1, (sonde.si()->rssi&1)?halfdb_tile1:empty_tile1);
+			rdis->drawTile(de->x+len, de->y+1, 1, (sonde.si()->rssi&1)?halfdb_tile2:empty_tile2);
+		} else { // special for 2" display
+			snprintf(buf, 16, "-%d.%c  ", sonde.si()->rssi/2, (sonde.si()->rssi&1)?'5':'0');
+			drawString(de,buf);
+		}
+	} else {
+		int dbmetre=sonde.si()->rssi/2;
+		Serial.printf("\nSmetre %d\n",sonde.si()->rssi/2);
+		//Ici tableau Smetre
+		//S1 <-121dB 		//S2 <-115dB 		//S3 <-109dB 		//S4 <-103dB 		//S5 <-97dB
+		//S6 <-91dB		//S7 <-85dB 		//S8 <-79dB		//S9 <-73dB		//S9+10 <-63dB
+		//S9+20 <-53dB		//S9+30 <-43db		//S9+40 <- 33dB	//S9+50dB <-23dB	//S9+60 <-13dB
+		//S9+70 <-0dB		
+		if (dbmetre>138) drawString(de,"S0");
+		if ((dbmetre<137)&&(dbmetre>122)) drawString(de,"S1   ");
+		if ((dbmetre<121)&&(dbmetre>116)) drawString(de,"S2   ");
+		if ((dbmetre<115)&&(dbmetre>108)) drawString(de,"S3   ");
+		if ((dbmetre<109)&&(dbmetre>104)) drawString(de,"S4   ");
+		if ((dbmetre<103)&&(dbmetre>98)) drawString(de,"S5   ");
+		if ((dbmetre<97)&&(dbmetre>92)) drawString(de,"S6   ");
+		if ((dbmetre<91)&&(dbmetre>86)) drawString(de,"S7   ");
+		if ((dbmetre<85)&&(dbmetre>80)) drawString(de,"S8   ");
+		if ((dbmetre<79)&&(dbmetre>74)) drawString(de,"S9   ");
+		if ((dbmetre<73)&&(dbmetre>64)) drawString(de,"S9+10");
+		if ((dbmetre<63)&&(dbmetre>54)) drawString(de,"S9+20");
+		if ((dbmetre<53)&&(dbmetre>44)) drawString(de,"S9+30");
+		if ((dbmetre<43)&&(dbmetre>34)) drawString(de,"S9+40");
+		if ((dbmetre<33)&&(dbmetre>24)) drawString(de,"S9+50");
+		if ((dbmetre<23)&&(dbmetre>14)) drawString(de,"S9+60");
+		if ((dbmetre<13)&&(dbmetre>0)) drawString(de,"S9+70");
+	}
+}
+void Display::drawQS(DispEntry *de) {
+	uint8_t *stat = sonde.si()->rxStat;
+	struct StatInfo *statinfo = (struct StatInfo *)de->extra;
+	rdis->drawQS(de->x, de->y, statinfo->len, statinfo->size, stat, de->fg, de->bg);
+}
+
+void Display::drawType(DispEntry *de) {
+	rdis->setFont(de->fmt);
+        drawString(de, sondeTypeStr[sonde.si()->type]);
+}
+void Display::drawFreq(DispEntry *de) {
+	rdis->setFont(de->fmt);
+        snprintf(buf, 16, "%3.3f%s", sonde.si()->freq, de->extra?de->extra:"");
+        drawString(de, buf);
+}
+void Display::drawVBat(DispEntry *de) {
+	rdis->setFont(de->fmt);
+        snprintf(buf, 16, "%3.0f%s", sonde.si()->vbat, "%");
+        drawString(de, buf);
+}
+void Display::drawAFC(DispEntry *de) {
+ 	if(!sonde.config.showafc) return;
+	rdis->setFont(de->fmt);
+	//if(sonde.si()->afc==0) { strcpy(buf, "        "); }
+	//else
+	{ snprintf(buf, 15, "     %+3.2fk", sonde.si()->afc*0.001); }
+        drawString(de, buf+strlen(buf)-8);
+}
+void Display::drawIP(DispEntry *de) {
+	rdis->setFont(de->fmt);
+	rdis->drawIP(de->x, de->y, de->width, de->fg, de->bg);
+}
+void Display::drawSite(DispEntry *de) {
+        rdis->setFont(de->fmt);
+	switch(de->extra[0]) {
+	case '#':
+		// currentSonde is index in array starting with 0;
+		// but we draw "1" for the first entrie and so on...
+		snprintf(buf, 3, "%2d", sonde.currentSonde+1);
+		buf[2]=0;
+		break;
+	case 't':
+		snprintf(buf, 3, "%d", sonde.config.maxsonde);
+		buf[2]=0;
+		break;
+	case 'a':
+		{
+		uint8_t active = 0;
+ 		for(int i=0; i<sonde.config.maxsonde; i++) {
+	                if(sonde.sondeList[i].active) active++;
+		}
+ 		snprintf(buf, 3, "%d", active);
+		buf[2]=0;
+		}
+		break;
+	case '/':
+		snprintf(buf, 6, "%d/%d  ", sonde.currentSonde+1, sonde.config.maxsonde);
+		buf[5]=0;
+		break;
+	case 0: case 'l': default: // launch site
+		drawString(de, sonde.si()->launchsite);
+		return;
+	}
+	if(de->extra[0]) strcat(buf, de->extra+1);
+	drawString(de, buf);
+}
+void Display::drawTelemetry(DispEntry *de) {
+}
+
+void Display::drawKilltimer(DispEntry *de) {
+	rdis->setFont(de->fmt);
+	uint16_t value;
+	switch(de->extra[0]) {
+	case 'l': value = sonde.si()->launchKT; break;
+	case 'b': value = sonde.si()->burstKT; break;
+	case 'c': value = sonde.si()->countKT; break;
+	}
+	// format: 4=h:mm; 6=h:mm:ss; s=sssss
+	uint16_t h=value/3600;
+	uint16_t m=(value-h*3600)/60;
+	uint16_t s=value%60;
+	switch(de->extra[1]) {
+	case '4':
+		if(value!=0xffff) snprintf(buf, 5, "%d:%02d", h, m);
+		else strcpy(buf, "    ");
+		break;
+	case '6':
+		if(value!=0xffff) snprintf(buf, 7, "%d:%02d:%02d", h, m, s);
+		else strcpy(buf, "       ");
+		break;
+	default:
+		if(value!=0xffff) snprintf(buf, 6, "%5d", value);
+		else strcpy(buf, "     ");
+		break;
+	}
+	if(de->extra[1])
+		strcat(buf, de->extra+2);
+	drawString(de, buf);
+}
+
+
+#define EARTH_RADIUS (6371000.0F)
+#define PE (111.6F) // la terre a un rayon de r = 6371km. Soit un périmètre de P = 2*PI*r = 40030.17km. Soit, pour un degré a = P/360 = 111.16km
+#ifndef PI
+#define  PI  (3.1415926535897932384626433832795)
+#endif
+// defined by Arduino.h   #define radians(x) ( (x)*180.0F/PI )
+
+
+extern int lastCourse; // from RadioSonde_FSK.ino
+void Display::calcGPS() {
+	// base data
+if (sonde.config.gpsOn==0){
+	gpsValid = true;
+	gpsLon = atof(sonde.config.gps_lon);
+	gpsLat = atof(sonde.config.gps_lat);
+	gpsAlt = sonde.config.gps_alt;
+static int tmpc=0;
+	tmpc = (tmpc+5)%360;
+	gpsCourse = tmpc;
+} else {
+	gpsValid = nmea.isValid();
+	gpsLon = nmea.getLongitude()*0.000001;
+	gpsLat = nmea.getLatitude()*0.000001;
+	long alt;
+	nmea.getAltitude(alt); gpsAlt=(int)(alt/1000);
+	gpsCourse = (int)(nmea.getCourse()/1000);
+	gpsCourseOld = false;
+	if(gpsCourse==0) {
+		// either north or not new
+		if(lastCourse!=0) // use old value...
+		{
+			gpsCourseOld = true;
+			gpsCourse = lastCourse;
+		}
+	}
+}
+
+	// distance
+	if( gpsValid ) {
+        	float lat1 = gpsLat;
+        	float lat2 = sonde.si()->lat;
+        	float lon1 = gpsLon;
+        	float lon2 = sonde.si()->lon;
+        	float x = abs(lon2-lon1);
+        	Serial.printf("\nx= %f",x);
+        	float y = abs(lat2-lat1);
+        	Serial.printf("\ny= %f",y);
+        	float d = sqrt(x*x+y*y)*PE*1000;
+        	Serial.printf("\ndist= %5.1fm",d);
+		gpsDist = d;
+	} else {
+		gpsDist = -1;
+	}
+	// bearing
+	if( gpsValid ) {
+                float lat1 = (gpsLat);
+                float lat2 = (sonde.si()->lat);
+                float lon1 = (gpsLon);
+                float lon2 = (sonde.si()->lon);
+                float y = abs(sin(lon2-lon1)*cos(lat2));
+                float x = abs(cos(lat1)*sin(lat2) - sin(lat1)*cos(lat2)*cos(lon2-lon1));
+                float dir = atan2(y, x)/PI*180;
+                if(dir<0) dir+=360;
+		gpsDir = (int)dir;
+		gpsBear = gpsDir - gpsCourse;
+		if(gpsBear < 0) gpsBear += 360;
+		if(gpsBear >= 360) gpsBear -= 360;
+	} else {
+		gpsDir = -1;
+		gpsBear = -1;
+	}
+	
+	Serial.printf("\nGPS data: valid%d  GPS at %f,%f (alt=%d,cog=%d);  sonde at dist=%d, dir=%d rel.bear=%d\n",gpsValid?1:0,
+		gpsLat, gpsLon, gpsAlt, gpsCourse, gpsDist, gpsDir, gpsBear);
+	
+	//VBat %
+	float vbat,r,Dmax, Dact;
+	float ADC_PIN = 35;
+	float vbatmax=atof(sonde.config.vbatmax), vbatmin=atof(sonde.config.vbatmin);
+	r = analogRead(ADC_PIN);
+        vbat = r * (3.30 / 4094.00); //convert the value to a true voltage.
+        Serial.printf("\nVbatMAX= %1.2fV",vbatmax);
+        Serial.printf("\nVbatMIN= %1.2fV",vbatmin);
+	Dmax = vbatmax - vbatmin;
+	Dact = vbat - vbatmin;
+	vbat = (Dact / Dmax)*100;
+	Serial.printf("\nVbat:%3.0f\%\n",vbat);
+	sonde.si()->vbat=vbat;
+}
+
+void Display::drawGPS(DispEntry *de) {
+	//if(sonde.config.gps_rxd<0) return;
+	rdis->setFont(de->fmt);
+	switch(de->extra[0]) {
+	case 'W':
+		{
+		// show if GPS location is valid
+		uint8_t *tile = disp.gpsValid?gps_tile:nogps_tile;
+		rdis->drawTile(de->x, de->y, 1, tile);
+		}
+		break;
+	case 'O':
+		// GPS long
+		snprintf(buf, 16, "%2.5f", disp.gpsLon);
+		drawString(de,buf);
+		break;
+	case 'A':
+		// GPS lat
+		snprintf(buf, 16, "%2.5f", disp.gpsLat);
+		drawString(de,buf);
+		break;
+	case 'H':
+		// GPS alt
+		snprintf(buf, 16, "%4dm", disp.gpsAlt);
+		drawString(de,buf);
+		break;
+	case 'C':
+		// GPS Course over ground
+		snprintf(buf, 4, "%3d", disp.gpsCourse);
+		drawString(de, buf);
+		break;
+	case 'D':
+		{
+		rdis->setFont(de->fmt);
+		// distance
+		// equirectangular approximation is good enough
+		if( (sonde.si()->validPos&0x03)!=0x03 ) {
+			snprintf(buf, 16, "no pos ");
+			if(de->extra && *de->extra=='5') buf[5]=0;
+		} else if((!disp.gpsValid)||(disp.gpsLat!=0)&&(disp.gpsLon!=0)) {
+			snprintf(buf, 16, "no gps ");
+			if(de->extra && *de->extra=='5') buf[5]=0;
+		} else {
+			if(de->extra && *de->extra=='5') { // 5-character version: ****m / ***km / **e6m
+				if(disp.gpsDist>999999) snprintf(buf, 16, "%3.0de6m  ", (disp.gpsDist/1000000));
+				if(disp.gpsDist>999) snprintf(buf, 16, "%3.0dkm   ", (disp.gpsDist/1000));
+				else snprintf(buf, 16, "%5.0dm    ", (disp.gpsDist));
+
+			} else { // 6-character version: *****m / ****km)
+				if(disp.gpsDist>999) snprintf(buf, 16, "%3.0dkm    ", (disp.gpsDist/1000));
+				else snprintf(buf, 16, "%3.0dm     ", (disp.gpsDist));
+
+			}
+		}
+		Serial.printf("\nDist= %dm",disp.gpsDist);
+		drawString(de, buf);
+		}
+		break;
+	case 'I':
+		// dIrection
+		rdis->setFont(de->fmt);
+		if (!sonde.si()->validPos)  {
+			rdis->setFont(de->fmt);
+			drawString(de, "---");
+			break;
+		}
+		snprintf(buf, 16, "%3d", disp.gpsDir);
+		buf[3]=0;
+		drawString(de, buf);
+		//if(de->extra[1]==(char)176)
+		rdis->drawTile(de->x+3, de->y, 1, deg_tile);		
+		break;
+	case 'B':
+		// relative bearing
+		rdis->setFont(de->fmt);
+		if (!sonde.si()->validPos)  {
+			drawString(de, "---");
+			break;
+		}
+		snprintf(buf, 16, "%3d", disp.gpsBear);
+		buf[3]=0;
+		drawString(de, buf);
+		if(de->extra[1]==(char)176)
+		rdis->drawTile(de->x+3, de->y, 1, deg_tile);
+		break;
+	case '0':
+		// diagram
+		{
+		Serial.printf("\nDiagram\n");
+		int x=1, y=1;
+		disp.circ(x,y);
+		
+		int dirdegres=disp.gpsDist;
+		if (dirdegres==360) dirdegres=0;
+
+		
+		//reset aiguille
+		uint8_t resetaiguilles[16] = {0, 0, 0, 0, 0, 0, 0, 128, 128, 0, 0, 0, 0, 0, 0, 0};
+		disp.rdis->drawTile(x+2, y+2, 2, resetaiguilles);
+		uint8_t resetaiguilles2[16] = {0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0};
+		disp.rdis->drawTile(x+2, y+3, 2, resetaiguilles2);		
+
+
+		//Pour 0 à 90°
+		if (dirdegres<91) {
+		if (dirdegres<7) {
+			uint8_t trait[8]={255,0,0,0,0,0,0,0};			//0°
+			disp.rdis->drawTile(x+3, y+2, 1, trait);
+		}
+		if ((dirdegres>6)&&(dirdegres<13)) {
+			uint8_t trait[8]={240,15,0,0,0,0,0,0};		//6°
+			disp.rdis->drawTile(x+3, y+2, 1, trait);		
+		}
+		if ((dirdegres>12)&&(dirdegres<19)) {
+			uint8_t trait[8]={224,24,7,0,0,0,0,0};		//12°
+			disp.rdis->drawTile(x+3, y+2, 1, trait);
+		}
+		if ((dirdegres>18)&&(dirdegres<25)) {
+			uint8_t trait[8]={128,112,14,1,0,0,0,0};		//18°
+			disp.rdis->drawTile(x+3, y+2, 1, trait);
+		}
+		if ((dirdegres>24)&&(dirdegres<31)) {
+			uint8_t trait[8]={128,96,24,6,1,0,0,0};		//24°
+			disp.rdis->drawTile(x+3, y+2, 1, trait);
+		}
+		if ((dirdegres>30)&&(dirdegres<37)) {
+			uint8_t trait[8]={192,48,24,12,6,3,0,0};		//30°
+			disp.rdis->drawTile(x+3, y+2, 1, trait);
+		}
+		if ((dirdegres>36)&&(dirdegres<43)) {
+			uint8_t trait[8]={128,64,32,24,12,6,1,0};		//36°
+			disp.rdis->drawTile(x+3, y+2, 1, trait);
+		}
+		if ((dirdegres>42)&&(dirdegres<49)) {
+			uint8_t trait[8]={128,64,32,16,8,4,2,1};		//42° à 49° dont 45°
+			disp.rdis->drawTile(x+3, y+2, 1, trait);
+		}
+		if ((dirdegres>48)&&(dirdegres<55)) {
+			uint8_t trait[8]={128,96,48,24,12,8,4,2};		//48°
+			disp.rdis->drawTile(x+3, y+2, 1, trait);
+		}
+		if ((dirdegres>54)&&(dirdegres<61)) {
+			uint8_t trait[8]={128,64,32,32,16,16,8,4};		//54°
+			disp.rdis->drawTile(x+3, y+2, 1, trait);
+		}
+		if ((dirdegres>60)&&(dirdegres<67)) {
+			uint8_t trait[8]={128,64,64,32,32,16,16,8};		//60°
+			disp.rdis->drawTile(x+3, y+2, 1, trait);
+		}
+		if ((dirdegres>66)&&(dirdegres<73)) {
+			uint8_t trait[8]={128,64,64,64,32,32,32,16};		//66°
+			disp.rdis->drawTile(x+3, y+2, 1, trait);
+		}
+		if ((dirdegres>72)&&(dirdegres<79)) {
+			uint8_t trait[8]={128,128,64,64,64,64,32,32};		//72°
+			disp.rdis->drawTile(x+3, y+2, 1, trait);
+		}
+		if ((dirdegres>78)&&(dirdegres<85)) {
+			uint8_t trait[8]={128,128,128,128,64,64,64,64};	//78°
+			disp.rdis->drawTile(x+3, y+2, 1, trait);
+		}
+		if ((dirdegres>84)&&(dirdegres<91)) {
+			uint8_t trait[8]={128,128,128,128,128,128,128,128}; 	//84°
+			disp.rdis->drawTile(x+3, y+2, 1, trait);
+		}
+		}
+		
+		
+		//Pour 90° à 180°
+		if ((dirdegres>90)&&(dirdegres<181)) {
+		if (dirdegres<97) {
+			uint8_t trait[8]={1,1,1,1,1,1,1,1};			//90°
+			disp.rdis->drawTile(x+3, y+3, 1, trait);
+		}
+		if ((dirdegres>96)&&(dirdegres<103)) {
+			uint8_t trait[8]={1,1,1,1,2,2,2,2};			//96°
+			disp.rdis->drawTile(x+3, y+3, 1, trait);		
+		}
+		if ((dirdegres>102)&&(dirdegres<109)) {
+			uint8_t trait[8]={1,2,2,2,2,2,2,4};			//102°
+			disp.rdis->drawTile(x+3, y+3, 1, trait);		
+		}		
+		if ((dirdegres>108)&&(dirdegres<115)) {
+			uint8_t trait[8]={1,2,2,4,4,4,8,8};			//108°
+			disp.rdis->drawTile(x+3, y+3, 1, trait);		
+		}
+		if ((dirdegres>114)&&(dirdegres<121)) {
+			uint8_t trait[8]={1,2,2,4,4,8,8,16};			//114°
+			disp.rdis->drawTile(x+3, y+3, 1, trait);		
+		}
+		if ((dirdegres>120)&&(dirdegres<127)) {
+			uint8_t trait[8]={1,2,4,12,24,32,32,64};		//120°
+			disp.rdis->drawTile(x+3, y+3, 1, trait);		
+		}		
+		if ((dirdegres>126)&&(dirdegres<133)) {
+			uint8_t trait[8]={1,1,2,12,48,64,128,128};		//126°
+			disp.rdis->drawTile(x+3, y+3, 1, trait);		
+		}
+		if ((dirdegres>132)&&(dirdegres<139)) {
+			uint8_t trait[8]={1,2,4,8,16,32,64,128};		//132° à 138° dont 135°
+			disp.rdis->drawTile(x+3, y+3, 1, trait);		
+		}		
+		if ((dirdegres>138)&&(dirdegres<145)) {
+			uint8_t trait[8]={1,6,12,24,48,96,128,0};		//144°
+			disp.rdis->drawTile(x+3, y+3, 1, trait);		
+		}
+		if ((dirdegres>144)&&(dirdegres<151)) {
+			uint8_t trait[8]={1,6,24,96,128,0,0,0};		//150°
+			disp.rdis->drawTile(x+3, y+3, 1, trait);		
+		}		
+		if ((dirdegres>150)&&(dirdegres<163)) {
+			uint8_t trait[8]={1,14,112,128,0,0,0,0};		//162°
+			disp.rdis->drawTile(x+3, y+3, 1, trait);		
+		}	
+		if ((dirdegres>162)&&(dirdegres<169)) {
+			uint8_t trait[8]={3,60,192,0,0,0,0,0};		//168°
+			disp.rdis->drawTile(x+3, y+3, 1, trait);		
+		}
+		if ((dirdegres>168)&&(dirdegres<175)) {
+			uint8_t trait[8]={15,240,0,0,0,0,0,0};		//174°
+			disp.rdis->drawTile(x+3, y+3, 1, trait);		
+		}		
+		if ((dirdegres>174)&&(dirdegres<181)) {
+			uint8_t trait[8]={255,0,0,0,0,0,0,0};			//180°
+			disp.rdis->drawTile(x+3, y+3, 1, trait);		
+		}		
+		}
+		
+		//Pour 180 à 270
+		if ((dirdegres>180)&&(dirdegres<271)) {
+		if (dirdegres<187) {
+			uint8_t trait[8]={0,0,0,0,0,0,0,255};			//180°
+			disp.rdis->drawTile(x+2, y+3, 1, trait);
+		}
+		if ((dirdegres>186)&&(dirdegres<193)) {
+			uint8_t trait[8]={0,0,0,0,0,0,240,15};		//186°
+			disp.rdis->drawTile(x+2, y+3, 1, trait);		
+		}
+		if ((dirdegres>192)&&(dirdegres<199)) {
+			uint8_t trait[8]={0,0,0,0,0,192,60,3};		//192°
+			disp.rdis->drawTile(x+2, y+3, 1, trait);		
+		}
+		if ((dirdegres>198)&&(dirdegres<205)) {
+			uint8_t trait[8]={0,0,0,0,128,112,14,1};		//198°
+			disp.rdis->drawTile(x+2, y+3, 1, trait);		
+		}		
+		if ((dirdegres>204)&&(dirdegres<211)) {
+			uint8_t trait[8]={0,0,0,128,96,24,6,1};		//204°
+			disp.rdis->drawTile(x+2, y+3, 1, trait);		
+		}
+		if ((dirdegres>210)&&(dirdegres<217)) {
+			uint8_t trait[8]={0,0,192,32,48,12,4,3};		//210°
+			disp.rdis->drawTile(x+2, y+3, 1, trait);		
+		}
+		if ((dirdegres>216)&&(dirdegres<223)) {
+			uint8_t trait[8]={0,128,96,48,24,12,6,1};		//216°
+			disp.rdis->drawTile(x+2, y+3, 1, trait);		
+		}				
+		if ((dirdegres>222)&&(dirdegres<229)) {
+			uint8_t trait[8]={128,64,32,16,8,4,2,1};		//222° à 229° dont 225°
+			disp.rdis->drawTile(x+2, y+3, 1, trait);		
+		}
+		if ((dirdegres>228)&&(dirdegres<235)) {
+			uint8_t trait[8]={128,128,96,48,24,12,6,1};		//228°
+			disp.rdis->drawTile(x+2, y+3, 1, trait);		
+		}		
+		if ((dirdegres>234)&&(dirdegres<241)) {
+			uint8_t trait[8]={64,32,32,24,12,8,2,1};		//234°
+			disp.rdis->drawTile(x+2, y+3, 1, trait);		
+		}
+		if ((dirdegres>240)&&(dirdegres<247)) {
+			uint8_t trait[8]={32,32,16,8,4,2,1};			//240°
+			disp.rdis->drawTile(x+2, y+3, 1, trait);		
+		}
+		if ((dirdegres>246)&&(dirdegres<253)) {
+			uint8_t trait[8]={16,8,8,4,4,2,2,1};			//246°
+			disp.rdis->drawTile(x+2, y+3, 1, trait);		
+		}		
+		if ((dirdegres>252)&&(dirdegres<259)) {
+			uint8_t trait[8]={8,4,4,4,2,2,2,1};			//252°
+			disp.rdis->drawTile(x+2, y+3, 1, trait);		
+		}		
+		if ((dirdegres>258)&&(dirdegres<265)) {
+			uint8_t trait[8]={4,4,2,2,2,2,1,1};			//258°
+			disp.rdis->drawTile(x+2, y+3, 1, trait);		
+		}
+		if ((dirdegres>264)&&(dirdegres<271)) {
+			uint8_t trait[8]={1,1,1,1,1,1,1,1};			//264°
+			disp.rdis->drawTile(x+2, y+3, 1, trait);		
+		}
+
+		}
+		
+		// 270° à 360°
+		if ((dirdegres>270)&&(dirdegres<360)) {
+		if (dirdegres<277) {
+			uint8_t trait[8]={128,128,128,128,128,128,128,128};	//270°
+			disp.rdis->drawTile(x+2, y+2, 1, trait);
+		}
+		if ((dirdegres>276)&&(dirdegres<283)) {
+			uint8_t trait[8]={64,64,64,64,128,128,128,128};	//276°
+			disp.rdis->drawTile(x+2, y+2, 1, trait);		
+		}
+		if ((dirdegres>282)&&(dirdegres<289)) {
+			uint8_t trait[8]={32,32,64,64,64,64,128,128};		//282°
+			disp.rdis->drawTile(x+2, y+2, 1, trait);		
+		}		
+		if ((dirdegres>288)&&(dirdegres<295)) {
+			uint8_t trait[8]={16,32,32,32,64,64,64,128};		//288°
+			disp.rdis->drawTile(x+2, y+2, 1, trait);		
+		}
+		if ((dirdegres>294)&&(dirdegres<301)) {
+			uint8_t trait[8]={8,16,16,32,32,64,64,128};		//294°
+			disp.rdis->drawTile(x+2, y+2, 1, trait);		
+		}		
+		if ((dirdegres>300)&&(dirdegres<307)) {
+			uint8_t trait[8]={4,4,8,16,32,64,64,128};		//300°
+			disp.rdis->drawTile(x+2, y+2, 1, trait);		
+		}
+		if ((dirdegres>306)&&(dirdegres<313)) {
+			uint8_t trait[8]={2,4,4,24,48,32,64,128};		//306°
+			disp.rdis->drawTile(x+2, y+2, 1, trait);		
+		}		
+		if ((dirdegres>312)&&(dirdegres<319)) {
+			uint8_t trait[8]={1,2,4,8,16,32,64,128};		//312° à 319° dont 315°
+			disp.rdis->drawTile(x+2, y+2, 1, trait);		
+		}
+		if ((dirdegres>318)&&(dirdegres<325)) {
+			uint8_t trait[8]={0,1,6,8,24,32,96,128};		//318°
+			disp.rdis->drawTile(x+2, y+2, 1, trait);		
+		}		
+		if ((dirdegres>324)&&(dirdegres<331)) {
+			uint8_t trait[8]={0,1,2,6,24,32,64,128};		//324°
+			disp.rdis->drawTile(x+2, y+2, 1, trait);		
+		}		
+		if ((dirdegres>330)&&(dirdegres<337)) {
+			uint8_t trait[8]={0,0,1,6,8,16,96,128};		//330°
+			disp.rdis->drawTile(x+2, y+2, 1, trait);		
+		}
+		if ((dirdegres>336)&&(dirdegres<343)) {
+			uint8_t trait[8]={0,0,0,1,6,24,96,128};		//336°
+			disp.rdis->drawTile(x+2, y+2, 1, trait);		
+		}
+		if ((dirdegres>342)&&(dirdegres<349)) {
+			uint8_t trait[8]={0,0,0,0,1,6,112,128};		//342°
+			disp.rdis->drawTile(x+2, y+2, 1, trait);		
+		}
+		if ((dirdegres>348)&&(dirdegres<355)) {
+			uint8_t trait[8]={0,0,0,0,0,1,126,128};		//348°
+			disp.rdis->drawTile(x+2, y+2, 1, trait);		
+		}		
+		if ((dirdegres>354)&&(dirdegres<360)) {
+			uint8_t trait[8]={0,0,0,0,0,0,0,255};			//354°
+			disp.rdis->drawTile(x+2, y+2, 1, trait);		
+		}		
+		}
+				
+		}
+		break;
+	case 'E':
+		// elevation
+		float el,ele;
+		el=acos(cos(PI/180*(disp.gpsLon-disp.gpsDir))*cos(PI/180*(abs(disp.gpsLat))));
+		ele=180*atan((cos(el)-(EARTH_RADIUS/(EARTH_RADIUS+disp.gpsAlt)))/sin(el))/PI;
+		ele=abs(ele);
+		Serial.printf("\nElevation:%3.0f\n",ele);
+		snprintf(buf, 16, "%3.0f", ele);
+		buf[3]=0;
+		drawString(de, buf);
+		rdis->drawTile(de->x+3, de->y, 1, deg_tile);	
+		break;
+	}
+}
+
+void Display::drawBatt(DispEntry *de) {
+	float val, pwr, Dmax, Dact, r, GPIO_PIN=4,ADC_PIN = 35;
+	float vbatmax=atof(sonde.config.vbatmax), vbatmin=atof(sonde.config.vbatmin);
+	char buf[30];
+	//if(!axp192_found) return;
+
+	xSemaphoreTake( axpSemaphore, portMAX_DELAY );
+	switch(de->extra[0]) {
+	case 'V':
+		r = analogRead(ADC_PIN);
+        	val = r * (3.30 / 4094.00); //convert the value to a true voltage.
+		snprintf(buf, 30, "%.2f%s", val, de->extra+1);
+		break;
+	case 'C':
+		r = analogRead(GPIO_PIN);
+        	val = r * (3.30 / 4094.00); //convert the value to a true voltage.
+		snprintf(buf, 30, "%.2f%s", val, de->extra+1);
+		break;
+	case 'P':
+		r = analogRead(ADC_PIN);
+        	val = r * (3.30 / 4094.00); //convert the value to a true voltage.
+        	Dmax = vbatmax - vbatmin;
+		Dact = val - vbatmin;
+		val = (Dact / Dmax)*100;
+		val = (vbatmax * val) /100;
+        	pwr = (val * 0.40)*1000; 
+		snprintf(buf, 30, "%4.0f%s", pwr, de->extra+1);
+		break;
+		
+	default:
+		*buf=0;
+
+	}
+	xSemaphoreGive( axpSemaphore );
+        rdis->setFont(de->fmt);
+	drawString(de, buf);
+}
+
+void Display::drawText(DispEntry *de) {
+        rdis->setFont(de->fmt);
+	drawString(de, de->extra);
+}
+extern void buzzerLed(int temps);
+void Display::updateDisplayPos() {
+	for(DispEntry *di=layout->de; di->func != NULL; di++) {
+		if(di->func != disp.drawLat && di->func != disp.drawLon) continue;
+		di->func(di);
+	}
+}
+void Display::updateDisplayPos2() {
+	for(DispEntry *di=layout->de; di->func != NULL; di++) {
+		if(di->func != disp.drawAlt && di->func != disp.drawHS && di->func != disp.drawVS) continue;
+		di->func(di);
+	}
+}
+void Display::updateDisplayVBat() {
+	for(DispEntry *di=layout->de; di->func != NULL; di++) {
+		if(di->func != disp.drawVBat) continue;
+		di->func(di);
+	}
+}
+void Display::updateDisplayVBatt() {
+	for(DispEntry *di=layout->de; di->func != NULL; di++) {
+		if(di->func != disp.drawBatt) continue;
+		di->func(di);
+	}
+}
+void Display::updateDisplayID() {
+	for(DispEntry *di=layout->de; di->func != NULL; di++) {
+		if(di->func != disp.drawID) continue;
+		di->func(di);
+	}
+}
+void Display::updateDisplayRSSI() {
+	for(DispEntry *di=layout->de; di->func != NULL; di++) {
+		if(di->func != disp.drawRSSI) continue;
+		di->func(di);
+	}
+}
+void Display::updateStat() {
+	for(DispEntry *di=layout->de; di->func != NULL; di++) {
+		if(di->func != disp.drawQS) continue;
+		di->func(di);
+	}
+}
+
+void Display::updateDisplayRXConfig() {
+       for(DispEntry *di=layout->de; di->func != NULL; di++) {
+                if(di->func != disp.drawQS && di->func != disp.drawAFC) continue;
+                di->func(di);
+        }
+}
+
+void Display::updateDisplayIP() {
+       for(DispEntry *di=layout->de; di->func != NULL; di++) {
+                if(di->func != disp.drawIP) continue;
+		Serial.printf("updateDisplayIP: %d %d\n",di->x, di->y);
+                di->func(di);
+        }
+}
+
+void Display::updateDisplay() {
+	calcGPS();
+	for(DispEntry *di=layout->de; di->func != NULL; di++) {
+		di->func(di);
+	}
+}
+
+Display disp = Display();
\ No newline at end of file
diff --git a/libraries/SondeLib/Display.h b/libraries/SondeLib/Display.h
new file mode 100755
index 0000000..10533e7
--- /dev/null
+++ b/libraries/SondeLib/Display.h
@@ -0,0 +1,162 @@
+#ifndef Display_h
+#define Display_h
+#define FONT_LARGE 1
+#define FONT_SMALL 0
+
+#include <SPI.h>
+//#include <TFT22_ILI9225.h>
+#include "gfxfont.h"
+#include <U8x8lib.h>
+#include <SPIFFS.h>
+
+
+#define WIDTH_AUTO 9999
+struct DispEntry {
+	int16_t y;
+	int16_t x;
+	int16_t fmt, width;
+	uint16_t fg,bg;
+	void (*func)(DispEntry *de);
+	const char *extra;
+};
+
+#define GPSUSE_BASE 1
+#define GPSUSE_DIST 2
+#define GPSUSE_BEARING 4
+struct DispInfo {
+        DispEntry *de;
+        uint8_t *actions;
+        int16_t *timeouts;
+	const char *label;
+	uint8_t usegps;
+};
+
+struct StatInfo {
+	uint8_t len;
+	uint8_t size;
+};
+
+// Now starting towards supporting different Display types / libraries
+class RawDisplay {
+public:
+	virtual void begin() = 0;
+	virtual void clear() = 0;
+	virtual void setFont(uint8_t fontindex) = 0;
+	virtual void getDispSize(uint8_t *height, uint8_t *width, uint8_t *lineskip, uint8_t *colskip) = 0;
+	virtual void drawString(uint8_t x, uint8_t y, const char *s, int16_t width=WIDTH_AUTO, uint16_t fg=0xffff, uint16_t bg=0 ) = 0;
+	virtual void drawTile(uint8_t x, uint8_t y, uint8_t cnt, uint8_t *tile_ptr) = 0;
+	virtual void drawTriangle(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t x3, uint16_t y3, uint16_t color, bool fill) = 0;
+	virtual void drawBitmap(uint16_t x1, uint16_t y1, const uint16_t* bitmap, int16_t w, int16_t h) = 0;
+	virtual void welcome() = 0;
+	virtual void drawIP(uint8_t x, uint8_t y, int16_t width=WIDTH_AUTO, uint16_t fg=0xffff, uint16_t bg=0 ) = 0;
+	virtual void drawQS(uint8_t x, uint8_t y, uint8_t len, uint8_t size, uint8_t *stat, uint16_t fg=0xffff, uint16_t bg=0) = 0;
+};
+
+class U8x8Display : public RawDisplay {
+private:
+	U8X8 *u8x8 = NULL; // initialize later after reading config file
+	int _type;
+	const uint8_t **fontlist;
+	int nfonts;
+
+public:
+	U8x8Display(int type = 0) { _type = type; }
+	void begin();
+	void clear();
+	void setFont(uint8_t fontindex);
+	void getDispSize(uint8_t *height, uint8_t *width, uint8_t *lineskip, uint8_t *colskip);
+        void drawString(uint8_t x, uint8_t y, const char *s, int16_t width=WIDTH_AUTO, uint16_t fg=0xffff, uint16_t bg=0);
+        void drawTile(uint8_t x, uint8_t y, uint8_t cnt, uint8_t *tile_ptr);
+	void drawTriangle(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t x3, uint16_t y3, uint16_t color, bool fill);
+        void drawBitmap(uint16_t x1, uint16_t y1, const uint16_t* bitmap, int16_t w, int16_t h);
+	void welcome();
+	void drawIP(uint8_t x, uint8_t y, int16_t width=WIDTH_AUTO, uint16_t fg=0xffff, uint16_t bg=0);
+        void drawQS(uint8_t x, uint8_t y, uint8_t len, uint8_t size, uint8_t *stat, uint16_t fg=0xffff, uint16_t bg=0);
+};
+
+class Display {
+private:
+	void replaceLayouts(DispInfo *newlayout, int nnew);
+	int allocDispInfo(int entries, DispInfo *d, char *label);
+	void parseDispElement(char *text, DispEntry *de);
+	int xscale=13, yscale=22;
+	int fontsma=0, fontlar=1;
+	uint16_t colfg, colbg;
+	static void circ(int x, int y);
+	static int countEntries(File f);
+	void calcGPS();
+	boolean gpsValid;
+	float gpsLat, gpsLon;
+	int gpsAlt;
+	int gpsDist; // -1: invalid
+	int gpsCourse, gpsDir, gpsBear;   // 0..360; -1: invalid
+	boolean gpsCourseOld;
+	static const int LINEBUFLEN{ 255 };
+	static char lineBuf[LINEBUFLEN];
+	static const char *trim(char *s) {
+		char *ret = s;
+		while(*ret && isspace(*ret)) { ret++; }
+		int lastidx;
+		while(1) {
+			lastidx = strlen(ret)-1;
+			if(lastidx>=0 && isspace(ret[lastidx]))
+				ret[lastidx] = 0;
+			else
+				break;
+		}
+		return ret;
+	}
+public:
+	void initFromFile();
+
+	int layoutIdx;
+	DispInfo *layout;
+
+	DispInfo *layouts;
+	int nLayouts;
+	static RawDisplay *rdis;
+
+	Display();
+	void init();
+	static char buf[17];
+	static void drawLat(DispEntry *de);
+	static void drawLon(DispEntry *de);
+	static void drawAz(DispEntry *de);
+	static void drawVBat(DispEntry *de);
+	static void drawAlt(DispEntry *de);
+	static void drawHS(DispEntry *de);
+	static void drawVS(DispEntry *de);
+	static void drawID(DispEntry *de);
+	static void drawRSSI(DispEntry *de);
+	static void drawQS(DispEntry *de);
+	static void drawType(DispEntry *de);
+	static void drawFreq(DispEntry *de);
+	static void drawAFC(DispEntry *de);
+	static void drawIP(DispEntry *de);
+	static void drawSite(DispEntry *de);
+	static void drawTelemetry(DispEntry *de);
+	static void drawKilltimer(DispEntry *de);
+	static void drawGPS(DispEntry *de);
+	static void drawText(DispEntry *de);
+	static void drawBatt(DispEntry *de);
+	static void drawString(DispEntry *de, const char *str);
+	void clearIP();
+	void setIP(const char *ip, bool AP);
+	void updateDisplayPos();
+	void updateDisplayPos2();
+	void updateDisplayAz();
+	void updateDisplayVBat();
+	void updateDisplayID();
+	void updateDisplayRSSI();
+	void updateStat();
+	void updateDisplayRXConfig();
+	void updateDisplayIP();
+	void updateDisplay();
+	void updateDisplayVBatt();
+
+	void setLayout(int layout);
+};
+
+extern Display disp;
+
+#endif 
diff --git a/libraries/SondeLib/M10.cpp b/libraries/SondeLib/M10.cpp
new file mode 100755
index 0000000..88da155
--- /dev/null
+++ b/libraries/SondeLib/M10.cpp
@@ -0,0 +1,529 @@
+
+/* M10 decoder functions */
+#include "M10.h"
+#include "SX1278FSK.h"
+#include "rsc.h"
+#include "Sonde.h"
+#include <SPIFFS.h>
+
+// well...
+//#include "rs92gps.h"
+
+#define M10_DEBUG 1
+
+#if M10_DEBUG
+#define M10_DBG(x) x
+#else
+#define M10_DBG(x)
+#endif
+
+
+static byte data1[512];
+static byte *dataptr=data1;
+
+static uint8_t rxbitc;
+static uint16_t rxbyte;
+static int rxp=0;
+static int haveNewFrame = 0;
+static int lastFrame = 0;
+static int headerDetected = 0;
+
+int M10::setup(float frequency) 
+{
+#if M10_DEBUG
+	Serial.println("Setup sx1278 for M10 sonde");
+#endif
+	//if(!initialized) {
+		//Gencrctab();
+		//initrsc();
+        	// not here for now.... get_eph("/brdc.19n");
+	//	initialized = true;
+	//}
+
+	if(sx1278.ON()!=0) {
+		M10_DBG(Serial.println("Setting SX1278 power on FAILED"));
+		return 1;
+	}
+	if(sx1278.setFSK()!=0) {
+		M10_DBG(Serial.println("Setting FSJ mode FAILED"));
+		return 1;
+	}
+	if(sx1278.setBitrate(9600)!=0) {
+		M10_DBG(Serial.println("Setting bitrate 9600bit/s FAILED"));
+		return 1;
+	}
+#if M10_DEBUG
+	float br = sx1278.getBitrate();
+	Serial.print("Exact bitrate is ");
+	Serial.println(br);
+#endif
+        if(sx1278.setAFCBandwidth(sonde.config.rs92.rxbw)!=0) {
+                M10_DBG(Serial.printf("Setting AFC bandwidth %d Hz FAILED", sonde.config.rs92.rxbw));
+                return 1;
+        }
+        if(sx1278.setRxBandwidth(sonde.config.rs92.rxbw)!=0) {
+                M10_DBG(Serial.printf("Setting RX bandwidth to %d Hz FAILED", sonde.config.rs92.rxbw));
+                return 1;
+        }
+
+	// Enable auto-AFC, auto-AGC, RX Trigger by preamble
+	if(sx1278.setRxConf(0x1E)!=0) {
+		M10_DBG(Serial.println("Setting RX Config FAILED"));
+		return 1;
+	}
+	// Set autostart_RX to 01, preamble 0, SYNC detect==on, syncsize=3 (==4 byte
+	//char header[] = "0110.0101 0110.0110 1010.0101 1010.1010";
+
+	//const char *SYNC="\x10\xB6\xCA\x11\x22\x96\x12\xF8";
+	//const char *SYNC="\x08\x6D\x53\x88\x44\x69\x48\x1F";
+	// was 0x57
+	//const char *SYNC="\x99\x9A";
+#if 1
+	// version 1, working with continuous RX
+	const char *SYNC="\x66\x65";
+	if(sx1278.setSyncConf(0x70, 2, (const uint8_t *)SYNC)!=0) {
+		M10_DBG(Serial.println("Setting SYNC Config FAILED"));
+		return 1;
+	}
+	//if(sx1278.setPreambleDetect(0xA8)!=0) {
+	if(sx1278.setPreambleDetect(0x9F)!=0) {
+		M10_DBG(Serial.println("Setting PreambleDetect FAILED"));
+		return 1;
+	}
+#endif
+#if 0
+	// version 2, with per-packet rx start, untested
+	// header is 2a 10 65, i.e. with lsb first
+	// 0 0101 0100 1            0 0000 1000 1            0 1010 0110 1
+ 	// 10 10011001 10011010 01  10 10101010 01101010 01  10 01100110 10010110 01
+	//                             preamble 0x6A 0x66 0x6A
+	// i.e. preamble detector on (0x80), preamble detector size 1 (0x00), preample chip errors??? (0x0A)
+	// after 2a2a2a2a2a1065
+        if(sx1278.setPreambleDetect(0xA8)!=0) {
+                M10_DBG(Serial.println("Setting PreambleDetect FAILED"));
+                return 1;
+        }
+	// sync config: ato restart (01), preamble polarity AA (0), sync on (1), resevered (0), syncsize 2+1 (010) => 0x52
+	const char *SYNC="\x6A\x66\x69";
+        if(sx1278.setSyncConf(0x52, 3, (const uint8_t *)SYNC)!=0) {
+                M10_DBG(Serial.println("Setting SYNC Config FAILED"));
+                return 1;
+        }
+	// payload length is ((240 - 7)*10 +6)/8 = 292
+#endif
+
+	// Packet config 1: fixed len, no mancecer, no crc, no address filter
+	// Packet config 2: packet mode, no home ctrl, no beackn, msb(packetlen)=0)
+	if(sx1278.setPacketConfig(0x08, 0x40)!=0) {
+		M10_DBG(Serial.println("Setting Packet config FAILED"));
+		return 1;
+	}
+
+	Serial.print("M10: setting RX frequency to ");
+        Serial.println(frequency);
+        int res = sx1278.setFrequency(frequency);
+        // enable RX
+        sx1278.setPayloadLength(0);  // infinite for now...
+	//sx1278.setPayloadLength(292);
+        sx1278.writeRegister(REG_OP_MODE, FSK_RX_MODE);
+
+#if M10_DEBUG
+	M10_DBG(Serial.println("Setting SX1278 config for M10 finished\n"); Serial.println());
+#endif
+        return res;
+}
+
+#if 0
+int M10::setFrequency(float frequency) {
+	Serial.print("M10: setting RX frequency to ");
+	Serial.println(frequency);
+	int res = sx1278.setFrequency(frequency);
+	// enable RX
+        sx1278.setPayloadLength(0);  // infinite for now...
+
+	sx1278.writeRegister(REG_OP_MODE, FSK_RX_MODE);
+	return res;
+}
+#endif
+
+#if 0
+uint32_t M10::bits2val(const uint8_t *bits, int len) {
+	uint32_t val = 0;
+	for (int j = 0; j < len; j++) {
+		val |= (bits[j] << (len-1-j));
+	}
+	return val;
+}
+#endif
+
+M10::M10() {
+}
+
+#define M10_FRAMELEN 101
+#define M10_CRCPOS 99
+
+void M10::printRaw(uint8_t *data, int len)
+{
+	char buf[3];
+	int i;
+	for(i=0; i<len; i++) {
+		snprintf(buf, 3, "%02X ", data[i]);
+		Serial.print(buf);
+	}
+	Serial.println();
+}
+
+static int update_checkM10(int c, uint8_t b) {
+	int c0, c1, t, t6, t7, s;
+	c1 = c & 0xFF;
+	// B
+	b  = (b >> 1) | ((b & 1) << 7);
+	b ^= (b >> 2) & 0xFF;
+	// A1
+	t6 = ( c     & 1) ^ ((c >> 2) & 1) ^ ((c >> 4) & 1);
+	t7 = ((c >> 1) & 1) ^ ((c >> 3) & 1) ^ ((c >> 5) & 1);
+	t = (c & 0x3F) | (t6 << 6) | (t7 << 7);
+	// A2
+	s  = (c >> 7) & 0xFF;
+	s ^= (s >> 2) & 0xFF;
+	c0 = b ^ t ^ s;
+	return ((c1 << 8) | c0) & 0xFFFF;
+}
+static bool checkM10crc(uint8_t *msg) {
+	int i, cs, cs1;
+	cs = 0;
+	for (i = 0; i < M10_CRCPOS; i++) {
+		cs = update_checkM10(cs, msg[i]);
+	}
+	cs = cs & 0xFFFF;
+	cs1 = (msg[M10_CRCPOS] << 8) | msg[M10_CRCPOS+1];
+	return (cs1 == cs);
+}
+
+typedef uint32_t SET256[8];
+static SET256 sondeudp_VARSET = {0x03BBBBF0UL,0x80600000UL,0x06A001A0UL,
+                0x0000001CUL,0x00000000UL,0x00000000UL,0x00000000UL,
+                0x00000000UL};
+// VARSET=SET256{4..9,11..13,15..17,19..21,23..25,53..54,63,69,71,72,85,87,89,90,98..100}; 
+
+static uint8_t fixcnt[M10_FRAMELEN];
+static uint8_t fixbytes[M10_FRAMELEN];
+
+static int32_t getint32(uint8_t *data) {
+	return (int32_t)( data[3]|(data[2]<<8)|(data[1]<<16)|(data[0]<<24) );
+}
+static int16_t getint16(uint8_t *data) {
+	return (int16_t)(data[1]|((uint16_t)data[0]<<8));
+}
+
+static char dez(uint8_t nr) {
+	nr = nr%10;
+	return '0'+nr;
+}
+static char hex(uint8_t nr) {
+	nr = nr&0x0f;
+	if(nr<10) return '0'+nr;
+	else return 'A'+nr-10;
+}
+const static float DEGMUL = 1.0/0xB60B60;
+#define VMUL 0.005
+#ifndef PI
+#define  PI  (3.1415926535897932384626433832795)
+#endif
+#define RAD (PI/180)
+
+
+// ret: 1=frame ok; 2=frame with errors; 0=ignored frame (m10dop-alternativ)
+int M10::decodeframeM10(uint8_t *data) {
+	int repairstep = 16;
+	int repl = 0;
+	bool crcok;
+	// error correction, inspired by oe5dxl's sondeudp
+	do {
+		crcok = checkM10crc(data);
+		if(crcok) break;
+		repl = 0;
+		for(int i=0; i<M10_CRCPOS; i++) {
+			if( ((sondeudp_VARSET[i/32]&(1<<(i%32))) != 1)  && (fixcnt[i]>=repairstep) ) {
+				repl++;	
+				data[i] = fixbytes[i];
+			}
+		}
+		repairstep >>= 1;
+	} while(repairstep>0);
+	if(crcok) {
+		for(int i=0; i<M10_CRCPOS; i++) {
+			if(fixbytes[i]==data[i] &&fixcnt[i]<255) fixcnt[i]++;
+			else { fixcnt[i]=0; fixbytes[i]=data[i]; }
+		}
+	}
+	Serial.println(crcok?"CRC OK":"CRC NOT OK");
+
+	if(data[1]==0x9F && data[2]==0x20) {
+		Serial.println("Decoding...");
+		// Its a M10
+		// getid...
+		char ids[11];
+		ids[0] = 'M';
+		ids[1] = 'E';
+		ids[2] = hex(data[95]/16);
+		ids[3] = hex(data[95]);
+		ids[4] = hex(data[93]);
+		uint32_t id = data[96] + data[97]*256;
+		ids[5] = hex(id/4096);
+		ids[6] = hex(id/256);
+		ids[7] = hex(id/16);
+		ids[8] = hex(id);
+		ids[9] = 0;
+		strncpy(sonde.si()->id, ids, 10);
+		ids[0] = hex(data[95]/16);
+		ids[1] = dez((data[95]&0x0f)/10);
+		ids[2] = dez((data[95]&0x0f));
+		ids[3] = dez(data[93]);
+		ids[4] = dez(id>>13);
+		id &= 0x1fff;
+		ids[5] = dez(id/1000); 
+		ids[6] = dez((id/100)%10);
+		ids[7] = dez((id/10)%10);
+		ids[8] = dez(id%10);
+		strncpy(sonde.si()->ser, ids, 10);
+		sonde.si()->validID = true;
+		Serial.printf("ID is %s [%02x %02x %d]\n", ids, data[95], data[93], id);
+		// ID printed on sonde is ...-.-abbbb, with a=id>>13, bbbb=id&0x1fff in decimal
+		// position data
+		sonde.si()->lat = getint32(data+14) * DEGMUL;
+		sonde.si()->lon = getint32(data+18) * DEGMUL;
+		sonde.si()->alt = getint32(data+22) * 0.001;
+		float ve = getint16(data+4)*VMUL;
+		float vn = getint16(data+6)*VMUL;
+		sonde.si()->vs = getint16(data+8) * VMUL;
+		sonde.si()->hs = sqrt(ve*ve+vn*vn);
+		float dir = atan2(vn, ve)*(1.0/RAD);
+		if(dir<0) dir+=360;
+		sonde.si()->dir = dir;
+		sonde.si()->validPos = 0x3f;
+
+ 		uint32_t gpstime = getint32(data+10);
+                uint16_t gpsweek = getint16(data+32);
+                        // UTC is GPSTIME - 18s (24*60*60-18 = 86382)
+                        // one week = 7*24*60*60 = 604800 seconds
+                        // unix epoch starts jan 1st 1970 0:00
+                        // gps time starts jan 6, 1980 0:00. thats 315964800 epoch seconds.
+                        // subtracting 86400 yields 315878400UL
+                sonde.si()->time = (gpstime/1000) + 86382 + gpsweek*604800 + 315878400UL;
+                sonde.si()->validTime = true;
+	} else {
+		Serial.printf("data is %02x %02x %02x\n", data[0], data[1], data[2]);
+		return 0;
+	}
+	return crcok?1:2;
+}
+
+static uint32_t rxdata;
+static bool rxsearching=true;
+
+// search for
+// //101001100110011010011010011001100110100110101010100110101001
+// //1010011001100110100110100110 0110.0110 1001.1010 1010.1001 1010.1001 => 0x669AA9A9
+void M10::processM10data(uint8_t dt)
+{
+	for(int i=0; i<8; i++) {
+		uint8_t d = (dt&0x80)?1:0;
+		dt <<= 1;
+		rxdata = (rxdata<<1) | d;
+		//uint8_t value = ((rxdata>>1)^rxdata)&0x01;
+		//if((rxbitc&1)==1) { rxbyte = (rxbyte>>1) + ((value)<<8); } // mancester decoded data
+		//rxbyte = (rxbyte>>1) | (d<<8);
+		if( (rxbitc&1)==0 ) {
+			// "bit1"
+			rxbyte = (rxbyte<<1) | d;
+		} else {
+			// "bit2" ==> 01 or 10 => 1, otherweise => 0
+			rxbyte = rxbyte ^ d;
+		}
+		//
+		if(rxsearching) {
+			if( rxdata == 0xcccca64c || rxdata == 0x333359b3 ) {
+				rxsearching = false;
+				rxbitc = 0;
+				rxp = 0;
+#if 1
+                                int rssi=sx1278.getRSSI();
+                                int fei=sx1278.getFEI();
+                                int afc=sx1278.getAFC();
+                                Serial.print("Test: RSSI="); Serial.print(rssi);
+                                Serial.print(" FEI="); Serial.print(fei);
+                                Serial.print(" AFC="); Serial.println(afc);
+                                sonde.si()->rssi = rssi;
+                                sonde.si()->afc = afc;
+#endif
+			}
+		} else {
+			rxbitc = (rxbitc+1)%16; // 16;
+			if(rxbitc == 0) { // got 8 data bit
+				//Serial.printf("%03x ",rxbyte);
+				dataptr[rxp++] = rxbyte&0xff; // (rxbyte>>1)&0xff;
+#if 0
+				if(rxp==7 && dataptr[6] != 0x65) {
+					Serial.printf("wrong start: %02x\n",dataptr[6]);
+					rxsearching = true;
+				}
+#endif
+				if(rxp>=M10_FRAMELEN) {
+					rxsearching = true;
+					haveNewFrame = decodeframeM10(dataptr);
+				}
+			}
+		}
+	}
+}
+
+int M10::receive() {
+	unsigned long t0 = millis();
+	Serial.printf("M10::receive() start at %ld\n",t0);
+   	while( millis() - t0 < 1000 ) {
+		uint8_t value = sx1278.readRegister(REG_IRQ_FLAGS2);
+		if ( bitRead(value, 7) ) {
+			Serial.println("FIFO full");
+      		}
+      		if ( bitRead(value, 4) ) {
+        		Serial.println("FIFO overflow");
+      		}
+      		if ( bitRead(value, 2) == 1 ) {
+        		Serial.println("FIFO: ready()");
+        		sx1278.clearIRQFlags();
+      		}
+		if(bitRead(value, 6) == 0) { // while FIFO not empty
+      			byte data = sx1278.readRegister(REG_FIFO);
+			//Serial.printf("%02x",data);
+      			processM10data(data);
+      			value = sx1278.readRegister(REG_IRQ_FLAGS2);
+    		} else {
+			if(headerDetected) {
+				t0 = millis(); // restart timer... don't time out if header detected...
+				headerDetected = 0;
+			}
+    			if(haveNewFrame) {
+				Serial.printf("M10::receive(): new frame complete after %ldms\n", millis()-t0);
+				printRaw(dataptr, M10_FRAMELEN);
+				int retval = haveNewFrame==1 ? RX_OK: RX_ERROR;
+				haveNewFrame = 0;
+				return retval;
+			}
+			delay(2);
+    		}
+    	}
+	Serial.printf("M10::receive() timed out\n");
+    	return RX_TIMEOUT; // TODO RX_OK;
+}
+
+#define M10MAXLEN (240)
+int M10::waitRXcomplete() {
+	// called after complete...
+#if 0
+	Serial.printf("decoding frame %d\n", lastFrame);
+	print_frame(lastFrame==1?data1:data2, 240);
+	SondeInfo *si = sonde.sondeList+rxtask.receiveSonde;
+	si->lat = gpx.lat;
+	si->lon = gpx.lon;
+	si->alt = gpx.alt;
+	si->vs = gpx.vU;
+	si->hs = gpx.vH;
+	si->dir = gpx.vD;
+	si->validPos = 0x3f;
+	memcpy(si->id, gpx.id, 9);
+	si->validID = true;
+
+	int res=0;
+        uint32_t t0 = millis();
+        while( rxtask.receiveResult == 0xFFFF && millis()-t0 < 2000) { delay(20); }
+
+        if( rxtask.receiveResult<0 || rxtask.receiveResult==RX_TIMEOUT) {
+                res = RX_TIMEOUT;
+        } else if ( rxtask.receiveResult==0) {
+                res = RX_OK;
+        } else {
+                res = RX_ERROR;
+        }
+        rxtask.receiveResult = 0xFFFF;
+        Serial.printf("M10::waitRXcomplete returning %d (%s)\n", res, RXstr[res]);
+        return res;
+#endif
+	return 0;
+}
+
+
+#if 0
+int oldwaitRXcomplete() {
+	Serial.println("M10: receive frame...\n");
+	sx1278receiveData = true;
+	delay(6000); // done in other task....
+	//sx1278receiveData = false;
+#if 0
+	//sx1278.setPayloadLength(518-8);    // Expect 320-8 bytes or 518-8 bytes (8 byte header)
+	//sx1278.setPayloadLength(0);  // infinite for now...
+
+////// test code for continuous reception
+	//  sx1278.receive();  /// active FSK RX mode -- already done above...
+        uint8_t value = sx1278.readRegister(REG_IRQ_FLAGS2);
+        unsigned long previous = millis();
+
+        byte ready=0;
+	uint32_t wait = 8000;
+        // while not yet done or FIFO not yet empty
+	// bit 6: FIFO Empty
+	// bit 2 payload ready
+	int by=0;
+        while( (!ready || bitRead(value,6)==0) && (millis() - previous < wait) )
+        {
+		if( bitRead(value, 7) ) { Serial.println("FIFO full"); }
+		if( bitRead(value, 4) ) { Serial.println("FIFO overflow"); }
+                if( bitRead(value,2)==1 ) ready=1;
+                if( bitRead(value, 6) == 0 ) { // FIFO not empty
+                        byte data = sx1278.readRegister(REG_FIFO);
+			process8N1data(data);
+			by++;
+#if 0
+                        if(di==1) {
+                                int rssi=getRSSI();
+                                int fei=getFEI();
+                                int afc=getAFC();
+                                Serial.print("Test: RSSI="); Serial.println(rssi);
+                                Serial.print("Test: FEI="); Serial.println(fei);
+                                Serial.print("Test: AFC="); Serial.println(afc);
+                                sonde.si()->rssi = rssi;
+                                sonde.si()->afc = afc;
+                        }
+                        if(di>520) {
+                                // TODO
+                                Serial.println("TOO MUCH DATA");
+                                break;
+                        }
+                        previous = millis(); // reset timeout after receiving data
+#endif
+                }
+                value = sx1278.readRegister(REG_IRQ_FLAGS2);
+        }
+	Serial.printf("processed %d bytes before end/timeout\n", by);
+#endif
+
+
+
+/////
+#if 0
+	int e = sx1278.receivePacketTimeout(1000, data+8);
+	if(e) { Serial.println("TIMEOUT"); return RX_TIMEOUT; } //if timeout... return 1
+
+	printRaw(data, M10MAXLEN);
+	//for(int i=0; i<M10MAXLEN; i++) { data[i] = reverse(data[i]); }
+	//printRaw(data, MAXLEN);
+	//for(int i=0; i<M10MAXLEN; i++) { data[i] = data[i] ^ scramble[i&0x3F]; }
+	//printRaw(data, MAXLEN);
+	//int res = decode41(data, M10MAXLEN);
+#endif
+	int res=0;
+	return res==0 ? RX_OK : RX_ERROR;
+}
+#endif
+
+M10 m10 = M10();
diff --git a/libraries/SondeLib/M10.h b/libraries/SondeLib/M10.h
new file mode 100755
index 0000000..232ce31
--- /dev/null
+++ b/libraries/SondeLib/M10.h
@@ -0,0 +1,96 @@
+/*
+ * M10.h
+ * Functions for decoding Meteomodem M10 sondes with SX127x chips
+ * Copyright (C) 2019 Hansi Reiser, dl9rdz
+ *
+ * SPDX-License-Identifier:	GPL-2.0+
+ */
+
+#ifndef M10_h
+#define M10_h
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <Arduino.h>
+#ifndef inttypes_h
+        #include <inttypes.h>
+#endif
+
+#if 0
+struct CONTEXTR9 {
+   char calibdata[512];
+   uint32_t calibok;
+   char mesok;
+   char posok;
+   char framesent;
+   double lat;
+   double lon;
+   double heig;
+   double speed;
+   double dir;
+   double climb;
+   double lastlat;
+   double laslong;
+   double lastalt;
+   double lastspeed;
+   double lastdir;
+   double lastclb;
+   float hrmsc;
+   float vrmsc;
+   double hp;
+   double hyg;
+   double temp;
+   double ozontemp;
+   double ozon;
+   uint32_t goodsats;
+   uint32_t timems;
+   uint32_t framenum;
+};
+#endif
+
+/* Main class */
+class M10
+{
+private:
+	void printRaw(uint8_t *data, int len);
+	void processM10data(uint8_t data);
+        int decodeframeM10(uint8_t *data);
+#if 0
+	void stobyte92(uint8_t byte);
+	void dogps(const uint8_t *sf, int sf_len,
+                struct CONTEXTR9 * cont, uint32_t * timems,
+                uint32_t * gpstime);
+	uint32_t bits2val(const uint8_t *bits, int len);
+	int bitsToBytes(uint8_t *bits, uint8_t *bytes, int len);
+	int decode92(byte *data, int maxlen);
+
+	uint8_t hamming_conf[ 7*8];  //  7*8=56
+	uint8_t hamming_dat1[13*8];  // 13*8=104
+	uint8_t hamming_dat2[13*8];
+
+	uint8_t block_conf[ 7*4];  //  7*4=28
+	uint8_t block_dat1[13*4];  // 13*4=52
+	uint8_t block_dat2[13*4];
+
+	uint8_t H[4][8] =  // extended Hamming(8,4) particy check matrix
+             {{ 0, 1, 1, 1, 1, 0, 0, 0},
+              { 1, 0, 1, 1, 0, 1, 0, 0},
+              { 1, 1, 0, 1, 0, 0, 1, 0},
+              { 1, 1, 1, 0, 0, 0, 0, 1}};
+	uint8_t He[8] = { 0x7, 0xB, 0xD, 0xE, 0x8, 0x4, 0x2, 0x1};  // Spalten von H:
+                                                            // 1-bit-error-Syndrome
+	boolean initialized = false;
+#endif
+
+public:
+	M10();
+	int setup(float frequency);
+	int receive();
+	int waitRXcomplete();
+
+	//int use_ecc = 1;
+};
+
+extern M10 m10;
+
+#endif
diff --git a/libraries/SondeLib/RS41.cpp b/libraries/SondeLib/RS41.cpp
new file mode 100755
index 0000000..76ddc57
--- /dev/null
+++ b/libraries/SondeLib/RS41.cpp
@@ -0,0 +1,556 @@
+
+/* RS41 decoder functions */
+#include "RS41.h"
+#include "SX1278FSK.h"
+#include "rsc.h"
+#include "Sonde.h"
+
+#define RS41_DEBUG 0
+
+#if RS41_DEBUG
+#define RS41_DBG(x) x
+#else
+#define RS41_DBG(x)
+#endif
+
+#define RS41MAXLEN (320)
+static byte data[800];
+static int dpos = 0;
+
+static uint16_t CRCTAB[256];
+
+#define X2C_DIVR(a, b) ((b) != 0.0f ? (a)/(b) : (a))
+#define X2C_DIVL(a, b) ((a)/(b))
+static uint32_t X2C_LSH(uint32_t a, int32_t length, int32_t n)
+{
+	uint32_t m;
+
+	m = 0;
+	m = (length == 32) ? 0xFFFFFFFFl : (1 << length) - 1;
+	if (n > 0) {
+		if (n >= (int32_t)length)
+			return 0;
+		return (a << n) & m;
+	}
+
+	if (n <= (int32_t)-length)
+		return 0;
+	return (a >> -n) & m;
+}
+
+static double atang2(double x, double y)
+{
+   double w;
+   if (fabs(x)>fabs(y)) {
+      w = (double)atan((float)(X2C_DIVL(y,x)));
+      if (x<0.0) {
+         if (y>0.0) w = 3.1415926535898+w;
+         else w = w-3.1415926535898;
+      }
+   }
+   else if (y!=0.0) {
+      w = (double)(1.5707963267949f-atan((float)(X2C_DIVL(x,
+                y))));
+      if (y<0.0) w = w-3.1415926535898;
+   }
+   else w = 0.0;
+   return w;
+} /* end atang2() */
+
+
+static void Gencrctab(void)
+{
+   uint16_t j;
+   uint16_t i;
+   uint16_t crc;
+   for (i = 0U; i<=255U; i++) {
+      crc = (uint16_t)(i*256U);
+      for (j = 0U; j<=7U; j++) {
+         if ((0x8000U & crc)) crc = X2C_LSH(crc,16,1)^0x1021U;
+         else crc = X2C_LSH(crc,16,1);
+      } /* end for */
+      CRCTAB[i] = X2C_LSH(crc,16,-8)|X2C_LSH(crc,16,8);
+   } /* end for */
+} /* end Gencrctab() */
+
+int RS41::setup(float frequency) 
+{
+#if RS41_DEBUG
+	Serial.println("Setup sx1278 for RS41 sonde");
+#endif
+	if(!initialized) {
+		Gencrctab();
+		initrsc();
+		initialized = true;
+	}
+
+	if(sx1278.ON()!=0) {
+		RS41_DBG(Serial.println("Setting SX1278 power on FAILED"));
+		return 1;
+	}
+	if(sx1278.setFSK()!=0) {
+		RS41_DBG(Serial.println("Setting FSK mode FAILED"));
+		return 1;
+	}
+	if(sx1278.setBitrate(4800)!=0) {
+		RS41_DBG(Serial.println("Setting bitrate 4800bit/s FAILED"));
+		return 1;
+	}
+#if RS41_DEBUG
+	float br = sx1278.getBitrate();
+	Serial.print("Exact bitrate is ");
+	Serial.println(br);
+#endif
+
+	if(sx1278.setAFCBandwidth(sonde.config.rs41.agcbw)!=0) {
+		RS41_DBG(Serial.printf("Setting AFC bandwidth %d Hz FAILED", sonde.config.rs41.agcbw));
+		return 1;
+	}
+	if(sx1278.setRxBandwidth(sonde.config.rs41.rxbw)!=0) {
+		RS41_DBG(Serial.printf("Setting RX bandwidth to %d Hz FAILED", sonde.config.rs41.rxbw));
+		return 1;
+	}
+	// Enable auto-AFC, auto-AGC, RX Trigger by preamble
+	if(sx1278.setRxConf(0x1E)!=0) {
+		RS41_DBG(Serial.println("Setting RX Config FAILED"));
+		return 1;
+	}
+	// Set autostart_RX to 01, preamble 0, SYNC detect==on, syncsize=3 (==4 byte
+	//char header[] = "0110.0101 0110.0110 1010.0101 1010.1010";
+
+	//const char *SYNC="\x10\xB6\xCA\x11\x22\x96\x12\xF8";
+	const char *SYNC="\x08\x6D\x53\x88\x44\x69\x48\x1F";
+	if(sx1278.setSyncConf(0x57, 8, (const uint8_t *)SYNC)!=0) {
+		RS41_DBG(Serial.println("Setting SYNC Config FAILED"));
+		return 1;
+	}
+	if(sx1278.setPreambleDetect(0xA8)!=0) {
+		RS41_DBG(Serial.println("Setting PreambleDetect FAILED"));
+		return 1;
+	}
+
+	// Packet config 1: fixed len, no mancecer, no crc, no address filter
+	// Packet config 2: packet mode, no home ctrl, no beackn, msb(packetlen)=0)
+	if(sx1278.setPacketConfig(0x08, 0x40)!=0) {
+		RS41_DBG(Serial.println("Setting Packet config FAILED"));
+		return 1;
+	}
+	Serial.print("RS41: setting RX frequency to ");
+	Serial.println(frequency);
+	int retval = sx1278.setFrequency(frequency);
+	dpos = 0;
+
+#if RS41_DEBUG
+	RS41_DBG(Serial.println("Setting SX1278 config for RS41 finished\n"); Serial.println());
+#endif
+        sx1278.clearIRQFlags();
+
+	// the following is already done in receivePacketTimeout()
+	// sx1278.setPayloadLength(RS41MAXLEN-8);    // Expect 320-8 bytes or 518-8 bytes (8 byte header)
+        // sx1278.writeRegister(REG_OP_MODE, FSK_RX_MODE);
+	return retval;
+}
+
+uint32_t RS41::bits2val(const uint8_t *bits, int len) {
+	uint32_t val = 0;
+	for (int j = 0; j < len; j++) {
+		val |= (bits[j] << (len-1-j));
+	}
+	return val;
+}
+
+RS41::RS41() {
+}
+
+/* RS41 reed solomon decoder, from dxlAPRS
+ */
+static int32_t reedsolomon41(byte buf[], uint32_t buf_len, uint32_t len2)
+{
+   uint32_t i;
+   int32_t res1;
+   /*tb1, */
+   int32_t res;
+   char b1[256];
+   char b[256];
+   uint32_t eraspos[24];
+   uint32_t tmp;
+   for (i = 0UL; i<=255UL; i++) {
+      b[i] = 0;
+      b1[i] = 0;
+   } /* end for */
+   tmp = len2;
+   i = 0UL;
+   if (i<=tmp) for (;; i++) {
+      b[230UL-i] = buf[i*2UL+56UL];
+      b1[230UL-i] = buf[i*2UL+57UL];
+      if (i==tmp) break;
+   } /* end for */
+   for (i = 0UL; i<=23UL; i++) {
+      b[254UL-i] = buf[i+8UL];
+      b1[254UL-i] = buf[i+32UL];
+   } /* end for */
+   res = decodersc(b, eraspos, 0);
+   res1 = decodersc(b1, eraspos, 0);
+   if (res>0L && res<=12L) {
+      tmp = len2;
+      i = 0UL;
+      if (i<=tmp) for (;; i++) {
+         buf[i*2UL+56UL] = b[230UL-i];
+         if (i==tmp) break;
+      } /* end for */
+      for (i = 0UL; i<=23UL; i++) {
+         buf[i+8UL] = b[254UL-i];
+      } /* end for */
+   }
+   if (res1>0L && res1<=12L) {
+      tmp = len2;
+      i = 0UL;
+      if (i<=tmp) for (;; i++) {
+         buf[i*2UL+57UL] = b1[230UL-i];
+         if (i==tmp) break;
+      } /* end for */
+      for (i = 0UL; i<=23UL; i++) {
+         buf[i+32UL] = b1[254UL-i];
+      } /* end for */
+   }
+   if (res<0L || res1<0L) return -1L;
+   else return res+res1;
+   return 0;
+} /* end reedsolomon41() */
+
+
+
+
+static char crcrs(const byte frame[], uint32_t frame_len,
+                int32_t from, int32_t to)
+{
+   uint16_t crc;
+   int32_t i;
+   int32_t tmp;
+   crc = 0xFFFFU;
+   tmp = to-3L;
+   i = from;
+   if (i<=tmp) for (;; i++) {
+      crc = X2C_LSH(crc,16,-8)^CRCTAB[(uint32_t)((crc^(uint16_t)(uint8_t)frame[i])&0xFFU)];
+      if (i==tmp) break;
+   } /* end for */
+   return frame[to-1L]==(char)crc && frame[to-2L]==(char)X2C_LSH(crc,
+                16,-8);
+} /* end crcrs() */
+
+static int32_t getint32(const byte frame[], uint32_t frame_len,
+                uint32_t p)
+{
+   uint32_t n;
+   uint32_t i;
+   n = 0UL;
+   for (i = 3UL;; i--) {
+      n = n*256UL+(uint32_t)(uint8_t)frame[p+i];
+      if (i==0UL) break;
+   } /* end for */
+   return (int32_t)n;
+} /* end getint32() */
+
+
+static uint32_t getcard16(const byte frame[], uint32_t frame_len,
+                uint32_t p)
+{
+   return (uint32_t)(uint8_t)frame[p]+256UL*(uint32_t)(uint8_t)
+                frame[p+1UL];
+} /* end getcard16() */
+
+
+static int32_t getint16(const byte frame[], uint32_t frame_len,
+                uint32_t p)
+{
+   uint32_t n;
+   n = (uint32_t)(uint8_t)frame[p]+256UL*(uint32_t)(uint8_t)
+                frame[p+1UL];
+   if (n>=32768UL) return (int32_t)(n-65536UL);
+   return (int32_t)n;
+} /* end getint16() */
+
+static void wgs84r(double x, double y, double z,
+                double * lat, double * long0,
+                double * heig)
+{
+   double sl;
+   double ct;
+   double st;
+   double t;
+   double rh;
+   double xh;
+   double h;
+   h = x*x+y*y;
+   if (h>0.0) {
+      rh = (double)sqrt((float)h);
+      xh = x+rh;
+      *long0 = atang2(xh, y)*2.0;
+      if (*long0>3.1415926535898) *long0 = *long0-6.2831853071796;
+      t = (double)atan((float)(X2C_DIVL(z*1.003364089821,
+                rh)));
+      st = (double)sin((float)t);
+      ct = (double)cos((float)t);
+      *lat = (double)atan((float)
+                (X2C_DIVL(z+4.2841311513312E+4*st*st*st,
+                rh-4.269767270718E+4*ct*ct*ct)));
+      sl = (double)sin((float)*lat);
+      *heig = X2C_DIVL(rh,(double)cos((float)*lat))-(double)(X2C_DIVR(6.378137E+6f,
+                sqrt((float)(1.0-6.6943799901413E-3*sl*sl))));
+   }
+   else {
+      *lat = 0.0;
+      *long0 = 0.0;
+      *heig = 0.0;
+   }
+/*  lat:=atan(z/(rh*(1.0 - E2))); */
+/*  heig:=sqrt(h + z*z) - EARTHA; */
+} /* end wgs84r() */
+
+// returns: 0=ok, -1=error
+static void posrs41(const byte b[], uint32_t b_len, uint32_t p)
+{
+   double dir;
+   double vu;
+   double ve;
+   double vn;
+   double vz;
+   double vy;
+   double vx;
+   double heig;
+   double long0;
+   double lat;
+   double z;
+   double y;
+   double x;
+   x = (double)getint32(b, b_len, p)*0.01;
+   y = (double)getint32(b, b_len, p+4UL)*0.01;
+   z = (double)getint32(b, b_len, p+8UL)*0.01;
+   wgs84r(x, y, z, &lat, &long0, &heig);
+   Serial.print(" ");
+   sonde.si()->lat = (float)(X2C_DIVL(lat,1.7453292519943E-2));
+   Serial.print(sonde.si()->lat);
+   Serial.print(" ");
+   sonde.si()->lon = (float)(X2C_DIVL(long0,1.7453292519943E-2));
+   Serial.print(sonde.si()->lon);
+   if (heig<1.E+5 && heig>(-1.E+5)) {
+      Serial.print(" ");
+      Serial.print((uint32_t)heig);
+      Serial.print("m");
+   }
+   /*speed */
+   vx = (double)getint16(b, b_len, p+12UL)*0.01;
+   vy = (double)getint16(b, b_len, p+14UL)*0.01;
+   vz = (double)getint16(b, b_len, p+16UL)*0.01;
+   vn = (-(vx*(double)sin((float)lat)*(double)
+                cos((float)long0))-vy*(double)
+                sin((float)lat)*(double)sin((float)
+                long0))+vz*(double)cos((float)lat);
+   ve = -(vx*(double)sin((float)long0))+vy*(double)
+                cos((float)long0);
+   vu = vx*(double)cos((float)lat)*(double)
+                cos((float)long0)+vy*(double)
+                cos((float)lat)*(double)sin((float)
+                long0)+vz*(double)sin((float)lat);
+   dir = X2C_DIVL(atang2(vn, ve),1.7453292519943E-2);
+   if (dir<0.0) dir = 360.0+dir;
+   sonde.si()->dir = dir;
+   Serial.print(" ");
+   sonde.si()->hs = sqrt((float)(vn*vn+ve*ve))*3.6f;
+   Serial.print(sonde.si()->hs);
+   Serial.print("km/h ");
+   Serial.print(dir);
+   Serial.print("deg ");
+   Serial.print((float)vu);
+   sonde.si()->vs = vu;
+   Serial.print("m/s ");
+   uint8_t sats = getcard16(b, b_len, p+18UL)&255UL;
+   Serial.print(sats);
+   Serial.print("Sats");
+   sonde.si()->sats = sats;
+   sonde.si()->alt = heig;
+   if( 0==(int)(lat*10000) && 0==(int)(long0*10000) ) {
+      if(sonde.si()->validPos) {
+	// we have an old position, so keep previous position and mark it as old
+	sonde.si()->validPos |= 0x80;
+      }
+   }
+   else
+      sonde.si()->validPos = 0x7f;
+} /* end posrs41() */
+
+
+
+// returns: 0: ok, -1: rs or crc error
+int RS41::decode41(byte *data, int maxlen)
+{
+	char buf[128];	
+	int crcok = 0;
+
+	int32_t corr = reedsolomon41(data, 560, 131);  // try short frame first
+	if(corr<0) {
+		corr = reedsolomon41(data, 560, 230);  // try long frame
+	}
+#if 0
+	Serial.print("RS result:");
+	Serial.print(corr);
+	Serial.println();
+#endif
+	int p = 57; // 8 byte header, 48 byte RS 
+	while(p<maxlen) {  /* why 555? */
+		uint8_t typ = data[p++];
+		uint32_t len = data[p++]+2UL;
+		if(p+len>maxlen) break;
+
+#if 0
+		// DEBUG OUTPUT
+		Serial.print("@");
+		Serial.print(p-2);
+		Serial.print(": ID:");
+		Serial.print(typ, HEX);
+		Serial.print(", len=");
+		Serial.print(len);
+		Serial.print(": ");
+		for(int i=0; i<len-1; i++) {
+			char buf[3];
+			snprintf(buf, 4, "%02X|", data[p+i]);
+			Serial.print(buf);
+		}
+#endif
+		// check CRC
+		if(!crcrs(data, 560, p, p+len)) {
+			Serial.println("###CRC ERROR###");
+		} else {	
+		crcok = 1;
+		switch(typ) {
+		case 'y': // name
+			{
+			Serial.print("#");
+			uint16_t fnr = data[p]+(data[p+1]<<8);
+			Serial.print(fnr);
+			sonde.si()->frame = fnr;
+			Serial.print("; RS41 ID ");
+			snprintf(buf, 10, "%.8s ", data+p+2);
+			Serial.print(buf);
+			sonde.si()->type=STYPE_RS41;
+			strncpy(sonde.si()->id, (const char *)(data+p+2), 8);
+			sonde.si()->id[8]=0;
+			strncpy(sonde.si()->ser, (const char *)(data+p+2), 8);
+			sonde.si()->ser[8]=0;
+			sonde.si()->validID=true;
+			int calnr = data[p+23];
+			// not sure about this
+			if(calnr==0x31) {
+				uint16_t bt = data[p+30] + 256*data[p+31];
+				sonde.si()->burstKT = bt;
+			}
+			// this should be right...
+			if(calnr==0x02) {
+				uint16_t kt = data[p+31] + 256*data[p+32];
+				sonde.si()->launchKT = kt;
+			}
+			// and this seems fine as well...
+			if(calnr==0x32) {
+				uint16_t cntdown = data[p+24] + (data[p+25]<<8);
+				uint16_t min = cntdown - (cntdown/3600)*3600;
+				Serial.printf("Countdown value: %d\n [%2d:%02d:%02d]", cntdown, cntdown/3600, min/60, min-(min/60)*60);
+				sonde.si()->countKT = cntdown;
+				sonde.si()->crefKT = fnr;
+			}
+			}
+			// TODO: some more data
+			break;
+		case '|': // date
+			{
+			uint32_t gpstime = getint32(data, 560, p+2);
+			uint16_t gpsweek = getint16(data, 560, p);
+			// UTC is GPSTIME - 18s (24*60*60-18 = 86382)
+			// one week = 7*24*60*60 = 604800 seconds
+			// unix epoch starts jan 1st 1970 0:00
+			// gps time starts jan 6, 1980 0:00. thats 315964800 epoch seconds.
+			// subtracting 86400 yields 315878400UL
+			sonde.si()->time = (gpstime/1000) + 86382 + gpsweek*604800 + 315878400UL;
+			sonde.si()->validTime = true;
+			}
+			break;
+		case '{': // pos
+			posrs41(data+p, len, 0);
+			break;
+		default:
+			break;
+		}}
+		p += len;
+		Serial.println();
+	}
+	return crcok ? 0 : -1;
+}
+void RS41::printRaw(uint8_t *data, int len)
+{
+	char buf[3];
+	int i;
+	for(i=0; i<len; i++) {
+		snprintf(buf, 3, "%02X", data[i]);
+		Serial.print(buf);
+	}
+	Serial.println();
+}
+
+void RS41::bitsToBytes(uint8_t *bits, uint8_t *bytes, int len)
+{
+	int i;
+	for(i=0; i<len*4; i++) {
+	       	bytes[i/8] = (bytes[i/8]<<1) | (bits[i]?1:0);
+	}
+	bytes[(i-1)/8] &= 0x0F;
+}
+
+static unsigned char lookup[16] = {
+0x0, 0x8, 0x4, 0xc, 0x2, 0xa, 0x6, 0xe,
+0x1, 0x9, 0x5, 0xd, 0x3, 0xb, 0x7, 0xf, };
+
+static uint8_t reverse(uint8_t n) {
+   return (lookup[n&0x0f] << 4) | lookup[n>>4];
+}
+
+
+static uint8_t scramble[64] = {150U,131U,62U,81U,177U,73U,8U,152U,50U,5U,89U,
+                14U,249U,68U,198U,38U,33U,96U,194U,234U,121U,93U,109U,161U,
+                84U,105U,71U,12U,220U,232U,92U,241U,247U,118U,130U,127U,7U,
+                153U,162U,44U,147U,124U,48U,99U,245U,16U,46U,97U,208U,188U,
+                180U,182U,6U,170U,244U,35U,120U,110U,59U,174U,191U,123U,76U,
+		193U};
+
+
+int RS41::receive() {
+	sx1278.setPayloadLength(RS41MAXLEN-8); 
+	int e = sx1278.receivePacketTimeout(1000, data+8);
+	if(e) { Serial.println("TIMEOUT"); return RX_TIMEOUT; } 
+
+        for(int i=0; i<RS41MAXLEN; i++) { data[i] = reverse(data[i]); }
+        for(int i=0; i<RS41MAXLEN; i++) { data[i] = data[i] ^ scramble[i&0x3F]; }
+        return decode41(data, RS41MAXLEN);
+}
+
+int RS41::waitRXcomplete() {
+	// Currently not used. can be used for additinoal post-processing
+	// (required for RS92 to avoid FIFO overrun in rx task)
+#if 0
+	int res;
+	uint32_t t0 = millis();
+	while(rxtask.receiveResult<0 && millis()-t0 < 3000) { delay(50); }
+
+	if(rxtask.receiveResult<0 || rxtask.receiveResult==RX_TIMEOUT) { 
+		res = RX_TIMEOUT;
+	} else if (rxtask.receiveResult==0) {
+		res = RX_OK;
+	} else {
+		res = RX_ERROR;
+	}
+	rxtask.receiveResult = -1;
+	Serial.printf("waitRXcomplete returning %d\n", res);
+	return res;
+#endif
+	return 0;
+}
+
+RS41 rs41 = RS41();
diff --git a/libraries/SondeLib/RS41.h b/libraries/SondeLib/RS41.h
new file mode 100755
index 0000000..99639ba
--- /dev/null
+++ b/libraries/SondeLib/RS41.h
@@ -0,0 +1,67 @@
+/*
+ * RS41.h
+ * Functions for decoding RS41 sondes with SX127x chips
+ * Copyright (C) 2019 Hansi Reiser, dl9rdz
+ *
+ * SPDX-License-Identifier:	GPL-2.0+
+ */
+
+#ifndef RS41_h
+#define RS41_h
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <Arduino.h>
+#ifndef inttypes_h
+        #include <inttypes.h>
+#endif
+
+/* Main class */
+class RS41
+{
+private:
+	uint32_t bits2val(const uint8_t *bits, int len);
+	void printRaw(uint8_t *data, int len);
+	void bitsToBytes(uint8_t *bits, uint8_t *bytes, int len);
+	int decode41(byte *data, int maxlen);
+
+#define B 8
+#define S 4
+	uint8_t hamming_conf[ 7*B];  //  7*8=56
+	uint8_t hamming_dat1[13*B];  // 13*8=104
+	uint8_t hamming_dat2[13*B];
+
+	uint8_t block_conf[ 7*S];  //  7*4=28
+	uint8_t block_dat1[13*S];  // 13*4=52
+	uint8_t block_dat2[13*S];
+
+	uint8_t H[4][8] =  // extended Hamming(8,4) particy check matrix
+             {{ 0, 1, 1, 1, 1, 0, 0, 0},
+              { 1, 0, 1, 1, 0, 1, 0, 0},
+              { 1, 1, 0, 1, 0, 0, 1, 0},
+              { 1, 1, 1, 0, 0, 0, 0, 1}};
+	uint8_t He[8] = { 0x7, 0xB, 0xD, 0xE, 0x8, 0x4, 0x2, 0x1};  // Spalten von H:
+                                                            // 1-bit-error-Syndrome
+	boolean initialized = false;
+
+public:
+	RS41();
+	// New interface:
+	// setup() is called when channel is activated (sets mode and frequency and activates receiver)
+	int setup(float frequency);
+	// processRXbyte is called by background task for each received byte
+	// should be fast enough to not cause sx127x fifo buffer overflow
+    //    void processRXbyte(uint8_t data);
+	// is called approx. 1x per second, may do some post-processing of received data
+	// and update information in sonde data structure
+	// returns infomration about sucess/error (for timers and for quality bar in display)
+	int receive();
+	int waitRXcomplete();
+	//int receiveFrame();
+
+	int use_ecc = 1;
+};
+
+extern RS41 rs41;
+
+#endif
diff --git a/libraries/SondeLib/RS92.cpp b/libraries/SondeLib/RS92.cpp
new file mode 100755
index 0000000..72a4c2b
--- /dev/null
+++ b/libraries/SondeLib/RS92.cpp
@@ -0,0 +1,727 @@
+
+/* RS92 decoder functions */
+#include "RS92.h"
+#include "SX1278FSK.h"
+#include "rsc.h"
+#include "Sonde.h"
+#include <SPIFFS.h>
+
+// well...
+#include "rs92gps.h"
+
+#define RS92_DEBUG 1
+
+#if RS92_DEBUG
+#define RS92_DBG(x) x
+#else
+#define RS92_DBG(x)
+#endif
+
+//static uint16_t CRCTAB[256];
+uint16_t *CRCTAB = NULL;
+
+#define X2C_DIVR(a, b) ((b) != 0.0f ? (a)/(b) : (a))
+#define X2C_DIVL(a, b) ((a)/(b))
+static uint32_t X2C_LSH(uint32_t a, int32_t length, int32_t n)
+{
+	uint32_t m;
+
+	m = 0;
+	m = (length == 32) ? 0xFFFFFFFFl : (1 << length) - 1;
+	if (n > 0) {
+		if (n >= (int32_t)length)
+			return 0;
+		return (a << n) & m;
+	}
+
+	if (n <= (int32_t)-length)
+		return 0;
+	return (a >> -n) & m;
+}
+
+#if 0
+static double atang2(double x, double y)
+{
+   double w;
+   if (fabs(x)>fabs(y)) {
+      w = (double)atan((float)(X2C_DIVL(y,x)));
+      if (x<0.0) {
+         if (y>0.0) w = 3.1415926535898+w;
+         else w = w-3.1415926535898;
+      }
+   }
+   else if (y!=0.0) {
+      w = (double)(1.5707963267949f-atan((float)(X2C_DIVL(x,
+                y))));
+      if (y<0.0) w = w-3.1415926535898;
+   }
+   else w = 0.0;
+   return w;
+} /* end atang2() */
+#endif
+
+static void Gencrctab(void)
+{
+   uint16_t j;
+   uint16_t i;
+   uint16_t crc;
+   if(!CRCTAB) { CRCTAB=(uint16_t *)malloc(256*sizeof(uint16_t)); }
+   for (i = 0U; i<=255U; i++) {
+      crc = (uint16_t)(i*256U);
+      for (j = 0U; j<=7U; j++) {
+         if ((0x8000U & crc)) crc = X2C_LSH(crc,16,1)^0x1021U;
+         else crc = X2C_LSH(crc,16,1);
+      } /* end for */
+      CRCTAB[i] = X2C_LSH(crc,16,-8)|X2C_LSH(crc,16,8);
+   } /* end for */
+} /* end Gencrctab() */
+
+
+static byte data1[512]={0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x10};
+static byte data2[512]={0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x10};
+static byte *dataptr=data1;
+
+static uint8_t rxbitc;
+static int32_t asynst[10]={0};
+static uint16_t rxbyte;
+int rxp=0;
+
+static int haveNewFrame = 0;
+static int lastFrame = 0;
+static int headerDetected = 0;
+
+int RS92::setup(float frequency) 
+{
+#if RS92_DEBUG
+	Serial.println("Setup sx1278 for RS92 sonde");
+#endif
+	if(!initialized) {
+		Gencrctab();
+		initrsc();
+        	// not here for now.... get_eph("/brdc.19n");
+		initialized = true;
+	}
+
+	if(sx1278.ON()!=0) {
+		RS92_DBG(Serial.println("Setting SX1278 power on FAILED"));
+		return 1;
+	}
+	if(sx1278.setFSK()!=0) {
+		RS92_DBG(Serial.println("Setting FSJ mode FAILED"));
+		return 1;
+	}
+	if(sx1278.setBitrate(4800)!=0) {
+		RS92_DBG(Serial.println("Setting bitrate 4800bit/s FAILED"));
+		return 1;
+	}
+#if RS92_DEBUG
+	float br = sx1278.getBitrate();
+	Serial.print("Exact bitrate is ");
+	Serial.println(br);
+#endif
+        if(sx1278.setAFCBandwidth(sonde.config.rs92.rxbw)!=0) {
+                RS92_DBG(Serial.printf("Setting AFC bandwidth %d Hz FAILED", sonde.config.rs92.rxbw));
+                return 1;
+        }
+        if(sx1278.setRxBandwidth(sonde.config.rs92.rxbw)!=0) {
+                RS92_DBG(Serial.printf("Setting RX bandwidth to %d Hz FAILED", sonde.config.rs92.rxbw));
+                return 1;
+        }
+
+	// Enable auto-AFC, auto-AGC, RX Trigger by preamble
+	if(sx1278.setRxConf(0x1E)!=0) {
+		RS92_DBG(Serial.println("Setting RX Config FAILED"));
+		return 1;
+	}
+	// Set autostart_RX to 01, preamble 0, SYNC detect==on, syncsize=3 (==4 byte
+	//char header[] = "0110.0101 0110.0110 1010.0101 1010.1010";
+
+	//const char *SYNC="\x10\xB6\xCA\x11\x22\x96\x12\xF8";
+	//const char *SYNC="\x08\x6D\x53\x88\x44\x69\x48\x1F";
+	// was 0x57
+	//const char *SYNC="\x99\x9A";
+#if 1
+	// version 1, working with continuous RX
+	const char *SYNC="\x66\x65";
+	if(sx1278.setSyncConf(0x70, 2, (const uint8_t *)SYNC)!=0) {
+		RS92_DBG(Serial.println("Setting SYNC Config FAILED"));
+		return 1;
+	}
+	if(sx1278.setPreambleDetect(0xA8)!=0) {
+		RS92_DBG(Serial.println("Setting PreambleDetect FAILED"));
+		return 1;
+	}
+#endif
+#if 0
+	// version 2, with per-packet rx start, untested
+	// header is 2a 10 65, i.e. with lsb first
+	// 0 0101 0100 1            0 0000 1000 1            0 1010 0110 1
+ 	// 10 10011001 10011010 01  10 10101010 01101010 01  10 01100110 10010110 01
+	//                             preamble 0x6A 0x66 0x6A
+	// i.e. preamble detector on (0x80), preamble detector size 1 (0x00), preample chip errors??? (0x0A)
+	// after 2a2a2a2a2a1065
+        if(sx1278.setPreambleDetect(0xA8)!=0) {
+                RS92_DBG(Serial.println("Setting PreambleDetect FAILED"));
+                return 1;
+        }
+	// sync config: ato restart (01), preamble polarity AA (0), sync on (1), resevered (0), syncsize 2+1 (010) => 0x52
+	const char *SYNC="\x6A\x66\x69";
+        if(sx1278.setSyncConf(0x52, 3, (const uint8_t *)SYNC)!=0) {
+                RS92_DBG(Serial.println("Setting SYNC Config FAILED"));
+                return 1;
+        }
+	// payload length is ((240 - 7)*10 +6)/8 = 292
+#endif
+
+	// Packet config 1: fixed len, no mancecer, no crc, no address filter
+	// Packet config 2: packet mode, no home ctrl, no beackn, msb(packetlen)=0)
+	if(sx1278.setPacketConfig(0x08, 0x40)!=0) {
+		RS92_DBG(Serial.println("Setting Packet config FAILED"));
+		return 1;
+	}
+
+	Serial.print("RS92: setting RX frequency to ");
+        Serial.println(frequency);
+        int res = sx1278.setFrequency(frequency);
+        sx1278.clearIRQFlags();
+
+        // enable RX
+        sx1278.setPayloadLength(0);  // infinite for now...
+	//sx1278.setPayloadLength(292);
+        sx1278.writeRegister(REG_OP_MODE, FSK_RX_MODE);
+
+#if RS92_DEBUG
+	RS92_DBG(Serial.println("Setting SX1278 config for RS92 finished\n"); Serial.println());
+#endif
+        return res;
+}
+
+#if 0
+int RS92::setFrequency(float frequency) {
+	Serial.print("RS92: setting RX frequency to ");
+	Serial.println(frequency);
+	int res = sx1278.setFrequency(frequency);
+	// enable RX
+        sx1278.setPayloadLength(0);  // infinite for now...
+
+	sx1278.writeRegister(REG_OP_MODE, FSK_RX_MODE);
+	return res;
+}
+#endif
+
+uint32_t RS92::bits2val(const uint8_t *bits, int len) {
+	uint32_t val = 0;
+	for (int j = 0; j < len; j++) {
+		val |= (bits[j] << (len-1-j));
+	}
+	return val;
+}
+
+RS92::RS92() {
+}
+
+/* RS92 reed solomon decoder, from dxlAPRS
+ */
+
+
+#if 0
+static char crcrs(const byte frame[], uint32_t frame_len,
+                int32_t from, int32_t to)
+{
+   uint16_t crc;
+   int32_t i;
+   int32_t tmp;
+   crc = 0xFFFFU;
+   tmp = to-3L;
+   i = from;
+   if (i<=tmp) for (;; i++) {
+      crc = X2C_LSH(crc,16,-8)^CRCTAB[(uint32_t)((crc^(uint16_t)(uint8_t)frame[i])&0xFFU)];
+      if (i==tmp) break;
+   } /* end for */
+   return frame[to-1L]==(char)crc && frame[to-2L]==(char)X2C_LSH(crc,
+                16,-8);
+} /* end crcrs() */
+
+static int32_t getint32(const byte frame[], uint32_t frame_len,
+                uint32_t p)
+{
+   uint32_t n;
+   uint32_t i;
+   n = 0UL;
+   for (i = 3UL;; i--) {
+      n = n*256UL+(uint32_t)(uint8_t)frame[p+i];
+      if (i==0UL) break;
+   } /* end for */
+   return (int32_t)n;
+} /* end getint32() */
+
+
+static uint32_t getcard16(const byte frame[], uint32_t frame_len,
+                uint32_t p)
+{
+   return (uint32_t)(uint8_t)frame[p]+256UL*(uint32_t)(uint8_t)
+                frame[p+1UL];
+} /* end getcard16() */
+
+
+static int32_t getint16(const byte frame[], uint32_t frame_len,
+                uint32_t p)
+{
+   uint32_t n;
+   n = (uint32_t)(uint8_t)frame[p]+256UL*(uint32_t)(uint8_t)
+                frame[p+1UL];
+   if (n>=32768UL) return (int32_t)(n-65536UL);
+   return (int32_t)n;
+} /* end getint16() */
+
+static void wgs84r(double x, double y, double z,
+                double * lat, double * long0,
+                double * heig)
+{
+   double sl;
+   double ct;
+   double st;
+   double t;
+   double rh;
+   double xh;
+   double h;
+   h = x*x+y*y;
+   if (h>0.0) {
+      rh = (double)sqrt((float)h);
+      xh = x+rh;
+      *long0 = atang2(xh, y)*2.0;
+      if (*long0>3.1415926535898) *long0 = *long0-6.2831853071796;
+      t = (double)atan((float)(X2C_DIVL(z*1.003364089821,
+                rh)));
+      st = (double)sin((float)t);
+      ct = (double)cos((float)t);
+      *lat = (double)atan((float)
+                (X2C_DIVL(z+4.2841311513312E+4*st*st*st,
+                rh-4.269767270718E+4*ct*ct*ct)));
+      sl = (double)sin((float)*lat);
+      *heig = X2C_DIVL(rh,(double)cos((float)*lat))-(double)(X2C_DIVR(6.378137E+6f,
+                sqrt((float)(1.0-6.6943799901413E-3*sl*sl))));
+   }
+   else {
+      *lat = 0.0;
+      *long0 = 0.0;
+      *heig = 0.0;
+   }
+/*  lat:=atan(z/(rh*(1.0 - E2))); */
+/*  heig:=sqrt(h + z*z) - EARTHA; */
+} /* end wgs84r() */
+#endif
+
+
+static int32_t reedsolomon92(uint8_t *buf, uint32_t buf_len)
+{  
+   uint32_t i;
+   int32_t res;
+   uint8_t b[256];
+   uint32_t eraspos[24];
+   for (i = 0UL; i<=255UL; i++) {
+      b[i] = 0;
+   } /* end for */
+   for (i = 0UL; i<=209UL; i++) {
+      b[230UL-i] = buf[i+6UL];
+   } /* end for */
+   for (i = 0UL; i<=23UL; i++) {
+      b[254UL-i] = buf[i+216UL];
+   } /* end for */
+   res = decodersc((char *)b, eraspos, 0L);
+   if (res>0L && res<=12L) {
+      for (i = 0UL; i<=209UL; i++) {
+         buf[i+6UL] = b[230UL-i];
+      } /* end for */
+      for (i = 0UL; i<=23UL; i++) {
+         buf[i+216UL] = b[254UL-i];
+      } /* end for */
+   }
+   return res;
+} /* end reedsolomon92() */
+
+void printRaw(uint8_t *data, int len)
+{
+	char buf[3];
+	int i;
+	for(i=0; i<len; i++) {
+		snprintf(buf, 3, "%02X", data[i]);
+		Serial.print(buf);
+	}
+	Serial.println();
+}
+
+void RS92::decodeframe92(uint8_t *data)
+{
+	//uint32_t gpstime;
+	//uint32_t flen;
+	//uint32_t j;
+	int32_t corr;
+	corr = reedsolomon92(data, 301ul);
+	//int calok;
+	//int mesok;
+	//uint32_t calibok;
+	lastFrame = (dataptr==data1)?1:2;
+	Serial.printf("rs corr is %d --- data:%p data1:%p data2:%p lastframe=%d\n", corr, data, data1, data2, lastFrame);
+	dataptr = (dataptr==data1)?data2:data1;
+	//print_frame(data, 240);
+#if 0
+	/* from sondemod*/
+	int p=6;
+	while(1) {
+		uint8_t typ = data[p];
+		if(typ==0xff) break;
+		++p;
+		int len = ((uint32_t)data[p])*2 + 2;
+		Serial.printf("type %c: len=%d\n", typ, len);
+		//printRaw(data+p, len+2);
+		if(len>240) {
+			Serial.print("RS92 frame too long: ");
+			Serial.println(len);
+			break;
+		}
+		++p;
+		j=0;
+		uint16_t crc = 0xFFFF;
+		while(j<len) {
+			if(j < len-2) {
+				for(int ic = 0; ic<=7; ic++) {
+					if (((0x8000&crc)!=0) != ( ((1<<(7-ic))&data[p])!=0 )) {
+						crc <<= 1;
+						crc ^= 0x1021;
+					} else {
+						crc <<= 1;
+					}
+				}
+			}
+			++p;
+			++j;
+			if(p>240) {
+				Serial.println("eof");
+				return;
+			}
+		}
+		if ( (((uint8_t)(crc&0xff)) != data[p-2]) || (((uint8_t)(crc>>8)) != data[p-1])) {
+			Serial.printf("************ crc error: expected %04x\n",crc);
+			continue;
+		}
+		switch(typ) {
+		case 'e':
+			Serial.println("cal  "); 
+			//docalib(sf, 256, objname, 9, &contextr9, &mhz, &frameno);
+			// ...
+			break;
+		case 'i':
+			if(calok && calibok==0xffffffff) {
+				//domes(sf, 256, &hp, &hyg, &temp)
+				mesok = 1;
+			}
+			break;
+		case 'g':
+			Serial.println("gps  "); 
+			if(1||calok) {
+				//dogps(data+p-len, 256, &contextr9,  &contextr9.timems, &gpstime);
+			}
+			break;
+		case 'h':
+			Serial.println("data "); break;
+			if(data[p+2]!=3) Serial.println("aux ");
+			// ..
+			break;
+		}
+	}
+#endif
+} /* end decodeframe92() */
+
+
+
+
+
+void RS92::printRaw(uint8_t *data, int len)
+{
+	char buf[3];
+	int i;
+	for(i=0; i<len; i++) {
+		snprintf(buf, 3, "%02X", data[i]);
+		Serial.print(buf);
+	}
+	Serial.println();
+}
+
+#if 0
+// I guess this is old copy&paste stuff from RS41??
+int RS92::bitsToBytes(uint8_t *bits, uint8_t *bytes, int len)
+{
+	int i;
+	for(i=0; i<len*4; i++) {
+	       	bytes[i/8] = (bytes[i/8]<<1) | (bits[i]?1:0);
+	}
+	bytes[(i-1)/8] &= 0x0F;
+}
+
+static unsigned char lookup[16] = {
+0x0, 0x8, 0x4, 0xc, 0x2, 0xa, 0x6, 0xe,
+0x1, 0x9, 0x5, 0xd, 0x3, 0xb, 0x7, 0xf, };
+
+static uint8_t reverse(uint8_t n) {
+   return (lookup[n&0x0f] << 4) | lookup[n>>4];
+}
+
+
+static uint8_t scramble[64] = {150U,131U,62U,81U,177U,73U,8U,152U,50U,5U,89U,
+                14U,249U,68U,198U,38U,33U,96U,194U,234U,121U,93U,109U,161U,
+                84U,105U,71U,12U,220U,232U,92U,241U,247U,118U,130U,127U,7U,
+                153U,162U,44U,147U,124U,48U,99U,245U,16U,46U,97U,208U,188U,
+                180U,182U,6U,170U,244U,35U,120U,110U,59U,174U,191U,123U,76U,
+		193U};
+#endif
+
+
+void RS92::stobyte92(uint8_t b)
+{
+	dataptr[rxp] = b;
+	if(rxp>=5 || b=='*') rxp++; else rxp=0;
+	if(rxp==6) { // header detected
+		headerDetected = 1;	
+	}
+	if(rxp>=240) { // frame complete... (240 byte)
+		rxp=0;
+		//printRaw(data, 240);
+		decodeframe92(dataptr);
+		haveNewFrame = 1;
+	}
+} /* end stobyte92() */
+
+
+uint32_t rxdata;
+bool rxsearching=true;
+
+// search for
+// 101001100110011010011010011001100110100110101010100110101001
+// 1010011001100110100110100110 0110.0110 1001.1010 1010.1001 1010.1001 => 0x669AA9A9
+void RS92::process8N1data(uint8_t dt)
+{
+	for(int i=0; i<8; i++) {
+		uint8_t d = (dt&0x80)?1:0;
+		rxdata = (rxdata<<1) | d;
+		if((rxbitc&1)==1) { rxbyte = (rxbyte>>1) + (d<<9); } // mancester decoded data
+		dt <<= 1;
+		//
+		if(rxsearching) {
+			if(rxdata == 0x669AA9A9) {
+				rxsearching = false;
+				rxbitc = 0;
+				rxp = 6;
+                                int rssi=sx1278.getRSSI();
+                                int fei=sx1278.getFEI();
+                                int afc=sx1278.getAFC();
+                                Serial.print("Test: RSSI="); Serial.print(rssi);
+                                Serial.print(" FEI="); Serial.print(fei);
+                                Serial.print(" AFC="); Serial.println(afc);
+                                sonde.si()->rssi = rssi;
+                                sonde.si()->afc = afc;
+			}
+		} else {
+			rxbitc = (rxbitc+1)%20;
+			if(rxbitc == 0) { // got startbit, 8 data bit, stop bit
+				//Serial.printf("%03x ",rxbyte);
+				dataptr[rxp++] = (rxbyte>>1)&0xff;
+				if(rxp==7 && dataptr[6] != 0x65) {
+					Serial.printf("wrong start: %02x\n",dataptr[6]);
+					rxsearching = true;
+				}
+				if(rxp>=240) {
+					rxsearching = true;
+					decodeframe92(dataptr);
+					haveNewFrame = 1;
+				}
+			}
+		}
+	}
+}
+
+void process8N1dataOrig(uint8_t data)
+{
+	// data contains 8 bits (after mancester encoding; 4 real bit), big endian
+	for(int i=0; i<4; i++) {
+		uint8_t d = (data&0x80)?1:0;
+		data = data << 2;
+		rxbyte = (rxbyte>>1) + (d<<8);
+		int maxk = 0;
+		int max0 = 0;
+		for(int k = 0; k< 10; k++) {
+			int n = asynst[k] - asynst[(k+1)%10];
+			if(abs(n)>abs(max0)) {
+				max0 = n;
+				maxk = k;
+			}	
+		}
+		//Serial.printf("<%d,%d,%d>",max0,maxk,rxbitc);
+		if(rxbitc == maxk) {
+			if(max0<0) { rxbyte = rxbyte ^ 0xFF; }
+		/////TODO	stobyte92( rxbyte&0xff );
+		}
+		//Serial.printf("%d:",asynst[rxbitc]);
+		if(d) {
+			asynst[rxbitc] += (32767-asynst[rxbitc])/16;
+		} else {
+			asynst[rxbitc] -= (32767+asynst[rxbitc])/16;
+		}
+		//Serial.printf("%d ",asynst[rxbitc]);
+		rxbitc = (rxbitc+1) % 10;
+	}
+}
+
+int RS92::receive() {
+	unsigned long t0 = millis();
+	Serial.printf("RS92::receive() start at %ld\n",t0);
+   	while( millis() - t0 < 1000 ) {
+		uint8_t value = sx1278.readRegister(REG_IRQ_FLAGS2);
+		if ( bitRead(value, 7) ) {
+			Serial.println("FIFO full");
+      		}
+      		if ( bitRead(value, 4) ) {
+        		Serial.println("FIFO overflow");
+      		}
+      		if ( bitRead(value, 2) == 1 ) {
+        		Serial.println("FIFO: ready()");
+        		sx1278.clearIRQFlags();
+      		}
+		if(bitRead(value, 6) == 0) { // while FIFO not empty
+      			byte data = sx1278.readRegister(REG_FIFO);
+			//Serial.printf("%02x",data);
+      			process8N1data(data);
+      			value = sx1278.readRegister(REG_IRQ_FLAGS2);
+    		} else {
+			if(headerDetected) {
+				t0 = millis(); // restart timer... don't time out if header detected...
+				headerDetected = 0;
+			}
+    			if(haveNewFrame) {
+				Serial.printf("RS92::receive(): new frame complete after %ldms\n", millis()-t0);
+				haveNewFrame = 0;
+				return RX_OK;
+			}
+			delay(2);
+    		}
+    	}
+	Serial.printf("RS92::receive() timed out\n");
+    	return RX_TIMEOUT; // TODO RX_OK;
+}
+
+#define RS92MAXLEN (240)
+int RS92::waitRXcomplete() {
+	// called after complete...
+	Serial.printf("decoding frame %d\n", lastFrame);
+	print_frame(lastFrame==1?data1:data2, 240);
+
+	SondeInfo *si = sonde.sondeList+rxtask.receiveSonde;
+	si->lat = gpx.lat;
+	si->lon = gpx.lon;
+	si->alt = gpx.alt;
+	si->vs = gpx.vU;
+	si->hs = gpx.vH;
+	si->dir = gpx.vD;
+	si->validPos = 0x3f;
+	memcpy(si->id, gpx.id, 9);
+	memcpy(si->ser, gpx.id, 9);
+	si->validID = true;
+	si->frame = gpx.frnr;
+	si->sats = gpx.k;
+        si->time = (gpx.gpssec/1000) + 86382 + gpx.week*604800 + 315878400UL;
+        si->validTime = true;	
+
+#if 0
+	int res=0;
+        uint32_t t0 = millis();
+        while( rxtask.receiveResult == 0xFFFF && millis()-t0 < 2000) { delay(20); }
+
+        if( rxtask.receiveResult<0 || rxtask.receiveResult==RX_TIMEOUT) {
+                res = RX_TIMEOUT;
+        } else if ( rxtask.receiveResult==0) {
+                res = RX_OK;
+        } else {
+                res = RX_ERROR;
+        }
+        rxtask.receiveResult = 0xFFFF;
+        Serial.printf("RS92::waitRXcomplete returning %d (%s)\n", res, RXstr[res]);
+        return res;
+#endif
+	return 0;
+}
+
+
+#if 0
+int oldwaitRXcomplete() {
+	Serial.println("RS92: receive frame...\n");
+	sx1278receiveData = true;
+	delay(6000); // done in other task....
+	//sx1278receiveData = false;
+#if 0
+	//sx1278.setPayloadLength(518-8);    // Expect 320-8 bytes or 518-8 bytes (8 byte header)
+	//sx1278.setPayloadLength(0);  // infinite for now...
+
+////// test code for continuous reception
+	//  sx1278.receive();  /// active FSK RX mode -- already done above...
+        uint8_t value = sx1278.readRegister(REG_IRQ_FLAGS2);
+        unsigned long previous = millis();
+
+        byte ready=0;
+	uint32_t wait = 8000;
+        // while not yet done or FIFO not yet empty
+	// bit 6: FIFO Empty
+	// bit 2 payload ready
+	int by=0;
+        while( (!ready || bitRead(value,6)==0) && (millis() - previous < wait) )
+        {
+		if( bitRead(value, 7) ) { Serial.println("FIFO full"); }
+		if( bitRead(value, 4) ) { Serial.println("FIFO overflow"); }
+                if( bitRead(value,2)==1 ) ready=1;
+                if( bitRead(value, 6) == 0 ) { // FIFO not empty
+                        byte data = sx1278.readRegister(REG_FIFO);
+			process8N1data(data);
+			by++;
+#if 0
+                        if(di==1) {
+                                int rssi=getRSSI();
+                                int fei=getFEI();
+                                int afc=getAFC();
+                                Serial.print("Test: RSSI="); Serial.println(rssi);
+                                Serial.print("Test: FEI="); Serial.println(fei);
+                                Serial.print("Test: AFC="); Serial.println(afc);
+                                sonde.si()->rssi = rssi;
+                                sonde.si()->afc = afc;
+                        }
+                        if(di>520) {
+                                // TODO
+                                Serial.println("TOO MUCH DATA");
+                                break;
+                        }
+                        previous = millis(); // reset timeout after receiving data
+#endif
+                }
+                value = sx1278.readRegister(REG_IRQ_FLAGS2);
+        }
+	Serial.printf("processed %d bytes before end/timeout\n", by);
+#endif
+
+
+
+/////
+#if 0
+	int e = sx1278.receivePacketTimeout(1000, data+8);
+	if(e) { Serial.println("TIMEOUT"); return RX_TIMEOUT; } //if timeout... return 1
+
+	printRaw(data, RS92MAXLEN);
+	//for(int i=0; i<RS92MAXLEN; i++) { data[i] = reverse(data[i]); }
+	//printRaw(data, MAXLEN);
+	//for(int i=0; i<RS92MAXLEN; i++) { data[i] = data[i] ^ scramble[i&0x3F]; }
+	//printRaw(data, MAXLEN);
+	//int res = decode41(data, RS92MAXLEN);
+#endif
+	int res=0;
+	return res==0 ? RX_OK : RX_ERROR;
+}
+#endif
+
+RS92 rs92 = RS92();
diff --git a/libraries/SondeLib/RS92.h b/libraries/SondeLib/RS92.h
new file mode 100755
index 0000000..d2310c7
--- /dev/null
+++ b/libraries/SondeLib/RS92.h
@@ -0,0 +1,96 @@
+/*
+ * RS92.h
+ * Functions for decoding RS92 sondes with SX127x chips
+ * Copyright (C) 2019 Hansi Reiser, dl9rdz
+ *
+ * SPDX-License-Identifier:	GPL-2.0+
+ */
+
+#ifndef RS92_h
+#define RS92_h
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <Arduino.h>
+#ifndef inttypes_h
+        #include <inttypes.h>
+#endif
+
+
+struct CONTEXTR9 {
+   char calibdata[512];
+   uint32_t calibok;
+   char mesok;
+   char posok;
+   char framesent;
+   double lat;
+   double lon;
+   double heig;
+   double speed;
+   double dir;
+   double climb;
+   double lastlat;
+   double laslong;
+   double lastalt;
+   double lastspeed;
+   double lastdir;
+   double lastclb;
+   float hrmsc;
+   float vrmsc;
+   double hp;
+   double hyg;
+   double temp;
+   double ozontemp;
+   double ozon;
+   uint32_t goodsats;
+   uint32_t timems;
+   uint32_t framenum;
+};
+
+
+/* Main class */
+class RS92
+{
+private:
+	void process8N1data(uint8_t data);
+	void stobyte92(uint8_t byte);
+        void decodeframe92(uint8_t *data);
+#if 0
+	void dogps(const uint8_t *sf, int sf_len,
+                struct CONTEXTR9 * cont, uint32_t * timems,
+                uint32_t * gpstime);
+#endif
+	uint32_t bits2val(const uint8_t *bits, int len);
+	void printRaw(uint8_t *data, int len);
+	int bitsToBytes(uint8_t *bits, uint8_t *bytes, int len);
+	int decode92(byte *data, int maxlen);
+
+	uint8_t hamming_conf[ 7*8];  //  7*8=56
+	uint8_t hamming_dat1[13*8];  // 13*8=104
+	uint8_t hamming_dat2[13*8];
+
+	uint8_t block_conf[ 7*4];  //  7*4=28
+	uint8_t block_dat1[13*4];  // 13*4=52
+	uint8_t block_dat2[13*4];
+
+	uint8_t H[4][8] =  // extended Hamming(8,4) particy check matrix
+             {{ 0, 1, 1, 1, 1, 0, 0, 0},
+              { 1, 0, 1, 1, 0, 1, 0, 0},
+              { 1, 1, 0, 1, 0, 0, 1, 0},
+              { 1, 1, 1, 0, 0, 0, 0, 1}};
+	uint8_t He[8] = { 0x7, 0xB, 0xD, 0xE, 0x8, 0x4, 0x2, 0x1};  // Spalten von H:
+                                                            // 1-bit-error-Syndrome
+	boolean initialized = false;
+
+public:
+	RS92();
+	int setup(float frequency);
+	int receive();
+	int waitRXcomplete();
+
+	int use_ecc = 1;
+};
+
+extern RS92 rs92;
+
+#endif
diff --git a/libraries/SondeLib/Scanner.cpp b/libraries/SondeLib/Scanner.cpp
new file mode 100755
index 0000000..9706372
--- /dev/null
+++ b/libraries/SondeLib/Scanner.cpp
@@ -0,0 +1,113 @@
+#include "Scanner.h"
+#include <SX1278FSK.h>
+#include <U8x8lib.h>
+
+#include "Sonde.h"
+#include "Display.h"
+
+#define CHANBW 10
+#define PIXSAMPL (50/CHANBW)
+#define SMOOTH 3
+//#define STARTF 401000000
+#define NCHAN ((int)(6000/CHANBW))
+
+double STARTF = (sonde.config.startfreq * 1000000);
+//int CHANBW = (sonde.config.channelbw);
+//int NCHAN = ((int)(6000/CHANBW));
+//int PIXSAMPL = (50/CHANBW);
+
+int scanresult[NCHAN];
+int scandisp[NCHAN/PIXSAMPL];
+
+#define PLOT_N 128
+#define TICK1 (128/6)
+#define TICK2 (TICK1/4)
+//#define PLOT_MIN -250
+#define PLOT_MIN (sonde.config.noisefloor*2)
+#define PLOT_SCALE(x) (x<PLOT_MIN?0:(x-PLOT_MIN)/2)
+
+const byte tilepatterns[9]={0,0x80,0xC0,0xE0,0xF0,0xF8,0xFC,0xFE,0xFF};
+void Scanner::fillTiles(uint8_t *row, int value) {
+	for(int y=0; y<8; y++) {
+		int nbits = value - 8*(7-y);
+		if(nbits<0) { row[8*y]=0; continue; }
+		if(nbits>=8) { row[8*y]=255; continue; }
+		row[8*y] = tilepatterns[nbits];
+	}
+}
+/*
+ * There are 16*8 columns to plot, NPLOT must be lower than that
+ * currently, we use 128 * 50kHz channels
+ * There are 8*8 values to plot; MIN is bottom end, 
+ */
+uint8_t tiles[16] = { 0x0f,0x0f,0x0f,0x0f,0xf0,0xf0,0xf0,0xf0, 1, 3, 7, 15, 31, 63, 127, 255};
+void Scanner::plotResult()
+{
+	uint8_t row[8*8];
+	for(int i=0; i<PLOT_N; i+=8) {
+		for(int j=0; j<8; j++) {
+			fillTiles(row+j, PLOT_SCALE(scandisp[i+j]));
+		        if( ((i+j)%TICK1)==0) { row[j] |= 0x07; }
+		        if( ((i+j)%TICK2)==0) { row[j] |= 0x01; }
+		}
+		for(int y=0; y<8; y++) {
+			if(sonde.config.marker && y==1) {
+				// don't overwrite MHz marker text
+				if(i<3*8 || (i>=7*8&&i<10*8) || i>=13*8) continue;
+			}
+			disp.rdis->drawTile(i/8, y, 1, row+8*y);
+		}
+	}
+}
+
+void Scanner::scan()
+{
+	// Configure 
+	sx1278.writeRegister(REG_PLL_HOP, 0x80);   // FastHopOn
+	sx1278.setRxBandwidth(CHANBW*1000);
+	sx1278.writeRegister(REG_RSSI_CONFIG, SMOOTH&0x07);
+	sx1278.setFrequency(STARTF);
+	sx1278.writeRegister(REG_OP_MODE, FSK_RX_MODE);
+	delay(20);
+
+	unsigned long start = millis();
+	uint32_t lastfrf=-1;
+	for(int iter=0; iter<2; iter++) {   // two interations, to catch all RS41 transmissions
+	    for(int i=0; i<NCHAN; i++) {
+		float freq = STARTF + 1000.0*i*CHANBW;
+		uint32_t frf = freq * 1.0 * (1<<19) / SX127X_CRYSTAL_FREQ;
+		if( (lastfrf>>16)!=(frf>>16) ) {
+        		sx1278.writeRegister(REG_FRF_MSB, (frf&0xff0000)>>16);
+		}
+		if( ((lastfrf&0x00ff00)>>8) != ((frf&0x00ff00)>>8) ) {
+        		sx1278.writeRegister(REG_FRF_MID, (frf&0x00ff00)>>8);
+		}
+        	sx1278.writeRegister(REG_FRF_LSB, (frf&0x0000ff));
+		lastfrf = frf;
+		// Wait TS_HOP (20us) + TS_RSSI ( 2^(SMOOTH+1) / 4 / CHANBW us)
+		int wait = 20 + 1000*(1<<(SMOOTH+1))/4/CHANBW;
+		delayMicroseconds(wait+5);
+		int rssi = -(int)sx1278.readRegister(REG_RSSI_VALUE_FSK);
+		if(iter==0) { scanresult[i] = rssi; } else {
+			if(rssi>scanresult[i]) scanresult[i]=rssi;
+		}
+	    }
+	}
+	unsigned long duration = millis()-start;
+	Serial.print("Scan time: ");
+	Serial.println(duration);
+	for(int i=0; i<NCHAN; i+=PIXSAMPL) {
+		scandisp[i/PIXSAMPL]=scanresult[i];
+		for(int j=1; j<PIXSAMPL; j++) { scandisp[i/PIXSAMPL]+=scanresult[i+j]; }
+		//for(int j=1; j<PIXSAMPL; j++) { if(scanresult[i+j]>scandisp[i/PIXSAMPL]) scandisp[i/PIXSAMPL] = scanresult[i+j]; }
+		Serial.print(scanresult[i]); Serial.print(", ");
+	}
+	Serial.println("\n");
+	for(int i=0; i<NCHAN/PIXSAMPL; i++) { 
+		scandisp[i]/=PIXSAMPL;
+                Serial.print(scandisp[i]); Serial.print(", ");
+	}
+	Serial.println("\n");
+}
+
+Scanner scanner = Scanner();
diff --git a/libraries/SondeLib/Scanner.h b/libraries/SondeLib/Scanner.h
new file mode 100755
index 0000000..b8fcd3f
--- /dev/null
+++ b/libraries/SondeLib/Scanner.h
@@ -0,0 +1,24 @@
+
+
+#ifndef _SCANNER_H
+#define _SCANNER_H
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <Arduino.h>
+#ifndef inttypes_h
+        #include <inttypes.h>
+#endif
+
+class Scanner
+{
+private:
+	void fillTiles(uint8_t *row, int value);
+
+public:	
+	void plotResult();
+	void scan(void);
+};
+
+extern Scanner scanner;
+#endif
diff --git a/libraries/SondeLib/Sonde.cpp b/libraries/SondeLib/Sonde.cpp
new file mode 100755
index 0000000..fcb6698
--- /dev/null
+++ b/libraries/SondeLib/Sonde.cpp
@@ -0,0 +1,689 @@
+#include <U8x8lib.h>
+#include <U8g2lib.h>
+
+#include "Sonde.h"
+#include "RS41.h"
+#include "RS92.h"
+#include "DFM.h"
+#include "M10.h"
+#include "SX1278FSK.h"
+#include "Display.h"
+#include <Wire.h>
+
+#define SDCARD
+
+#ifdef SDCARD
+#include "sd.h"
+#endif
+
+int snOn=0;
+
+extern SX1278FSK sx1278;
+
+RXTask rxtask = { -1, -1, -1, 0xFFFF, 0 };
+
+const char *evstring[]={"NONE", "KEY1S", "KEY1D", "KEY1M", "KEY1L", "KEY2S", "KEY2D", "KEY2M", "KEY2L",
+                               "VIEWTO", "RXTO", "NORXTO", "(max)"};
+
+const char *RXstr[]={"RX_OK", "RX_TIMEOUT", "RX_ERROR", "RX_UNKNOWN"};
+
+int fingerprintValue[]={ 17, 31, 64, 4, 55, 48, 23, 128+23, -1 };
+const char *fingerprintText[]={
+  "TTGO T-Beam (new version 1.0),  I2C not working after powerup, assuming 0.9\" OLED@21,22",
+  "TTGO LORA32 v2.1_1.6 (0.9\" OLED@21,22)",
+  "TTGO LORA v1.0 (0.9\" OLED@4,15)",
+  "Heltec v1/v2 (0.9\"OLED@4,15)",
+  "TTGO T-Beam (old version), 0.9\" OLED@21,22",
+  "TTGO T-Beam (old version), SPI TFT@4,21,22",
+  "TTGO T-Beam (new version 1.0), 0.9\" OLED@21,22",
+  "TTGO T-Beam (new version 1.0), SPI TFT@4,13,14",
+};
+
+int getKeyPressEvent(); /* in RX_FSK.ino */
+
+/* Task model:
+ * There is a background task for all SX1278 interaction.
+ *  - On startup and on each mode/frequency change (requested by setting requestNextSonde
+ *    to an sonde index >=0) it calls Sonde::setup(), which will call the new decoder's
+ *    setup function.  Setup will update the value currentSonde.
+ *  - Periodically it calls Sonde::receive(), which calls the current decoder's receive()
+ *    function. It should return control to the SX1278 main loop at least once per second.
+ *    It will also set the internal variable receiveResult.  The decoder's receive function
+ *    must make sure that there are no FIFI overflows in the SX1278.
+ *  - the Arduino main loop will call the waitRXcomplete function, which should return as
+ *    soon as there is some new data to display, or no later than after 1s, returning the
+ *    value of receiveResult (or timeout, if receiveResult was not set within 1s). It
+ *    should also return immediately if there is some keyboard input.
+ */   
+int initlevels[40];
+
+Sonde::Sonde() {
+	for (int i = 0; i < 39; i++) {
+		initlevels[i] = gpio_get_level((gpio_num_t)i);
+  	}
+}
+
+void Sonde::defaultConfig() {
+	fingerprint = initlevels[4];
+	fingerprint = (fingerprint<<1) | initlevels[12];
+	fingerprint = (fingerprint<<1) | initlevels[16];
+	fingerprint = (fingerprint<<1) | initlevels[17];
+	fingerprint = (fingerprint<<1) | initlevels[21];
+	fingerprint = (fingerprint<<1) | initlevels[22];
+	fingerprint = (fingerprint<<1) | initlevels[23];
+	Serial.printf("Board fingerprint is %d\n", fingerprint);
+
+	sondeList = (SondeInfo *)malloc((MAXSONDE+1)*sizeof(SondeInfo));
+	memset(sondeList, 0, (MAXSONDE+1)*sizeof(SondeInfo));
+	config.touch_thresh = 70;
+	config.led_pout = -1;
+	config.power_pout = -1;
+	config.spectrum=10;
+	// Try autodetecting board type
+  	// Seems like on startup, GPIO4 is 1 on v1 boards, 0 on v2.1 boards?
+  	config.gpsOn=0;
+	config.gps_rxd = -1;
+	config.gps_txd = -1;
+	strcpy(config.gps_lat,"43.591");
+	strcpy(config.gps_lon,"7.100");
+	config.gps_alt=123;
+	config.oled_rst = 16;
+	config.disptype = 0;
+	config.oled_orient = 1;
+	config.button2_axp = 0;
+	config.norx_timeout = 20;
+	if(initlevels[16]==0) {
+		config.oled_sda = 4;
+		config.oled_scl = 15;
+		config.button_pin = 0;
+		config.button2_pin = T4 + 128;     // T4 == GPIO13
+		config.power_pout = 21;		   // for Heltec v2
+		config.led_pout = 2;	
+		Serial.println("Autoconfig: looks like TTGO v1 / Heltec v1/V2 board");
+	} else {
+		config.oled_sda = 21;
+		config.oled_scl = 22;
+		if(initlevels[17]==0) { // T-Beam
+			if(initlevels[12]==0) {  // T-Beam v1.0
+				Serial.println("Autoconfig: looks like T-Beam 1.0 board");
+				config.button_pin = 38;
+				config.button2_pin = 15 + 128; //T4 + 128;  // T4 = GPIO13
+				// Maybe in future use as default only PWR as button2?
+				//config.button2_pin = 255;
+				config.button2_axp = 1;
+				config.gps_rxd = 34;
+				// Check for I2C-Display@21,22
+#define SSD1306_ADDRESS 0x3c
+				Wire.begin(21, 22);
+			    	Wire.beginTransmission(SSD1306_ADDRESS);
+    				byte err = Wire.endTransmission();
+				delay(100);  // otherwise its too fast?!
+			    	Wire.beginTransmission(SSD1306_ADDRESS);
+    				err = Wire.endTransmission();
+				if(err!=0 && fingerprint!=17) {  // hmm. 17 after powerup with oled commected and no i2c answer!?!?
+					fingerprint |= 128;
+					Serial.println("no I2C display found, assuming large TFT display\n");
+					// CS=0, RST=14, RS=2, SDA=4, CLK=13
+					Serial.println("... with large TFT display\n");
+					config.disptype = 1;
+					config.oled_sda = 4;
+					config.oled_scl = 13;
+					config.oled_rst = 14;
+					config.spectrum = -1; // no spectrum for now on large display
+				} else {
+					// OLED display, pins 21,22 ok...
+					config.disptype = 0;
+					Serial.println("... with small OLED display\n");
+				}
+			} else {
+				Serial.println("Autoconfig: looks like T-Beam v0.7 board");
+				config.button_pin = 39;
+				config.button2_pin = T4 + 128;  // T4 == GPIO13
+				config.gps_rxd = 12;
+				// Check if we possibly have a large display
+				if(initlevels[21]==0) {
+					Serial.println("Autoconfig: looks like T-Beam v0.7 board with large TFT display");
+					config.disptype = 1;
+					config.oled_sda = 4;
+					config.oled_scl = 21;
+					config.oled_rst = 22;
+					config.spectrum = -1; // no spectrum for now on large display
+				}
+			}
+		} else {
+			config.button_pin = 2 + 128;     // GPIO2 / T2
+			config.button2_pin = 14 + 128;   // GPIO14 / T6
+			config.led_pout = 25;
+		}
+	}
+	//
+	config.noisefloor = -125;
+	strcpy(config.call,"NOCALL");
+	strcpy(config.passcode, "---");
+	strcpy(config.mdnsname, "radiosonde");
+	strcpy(config.vbatmax,"1.84");
+	strcpy(config.vbatmin,"1.64");
+	config.sdOn=0;
+	config.buzzerOn=0;
+	config.buzzerFreq=700;
+	config.buzzerPort=12;
+	config.dbsmetre=0;
+	config.maxsonde=15;
+	config.debug=0;
+	config.wifi=1;
+	config.wifiap=1;
+	config.display[0]=0;
+	config.display[1]=1;
+	config.display[2]=-1;
+	config.startfreq=400;
+	config.channelbw=10;
+	config.marker=0;
+	config.showafc=0;
+	config.freqofs=0;
+	config.rs41.agcbw=12500;
+	config.rs41.rxbw=6300;
+	config.rs92.rxbw=12500;
+	config.rs92.alt2d=480;
+	config.dfm.agcbw=20800;
+	config.dfm.rxbw=10400;
+	config.udpfeed.active = 1;
+	config.udpfeed.type = 0;
+	strcpy(config.udpfeed.host, "fra1od.fr.to");
+	strcpy(config.udpfeed.symbol, "/O");
+	config.udpfeed.port = 14580;
+	config.udpfeed.highrate = 1;
+	config.udpfeed.idformat = ID_DFMGRAW;
+	config.tcpfeed.active = 0;
+	config.tcpfeed.type = 1;
+	strcpy(config.tcpfeed.host, "radiosondy.info");
+	strcpy(config.tcpfeed.symbol, "/O");
+	config.tcpfeed.port = 14580;
+	config.tcpfeed.highrate = 10;
+	config.tcpfeed.idformat = ID_DFMDXL;
+	config.kisstnc.active = 0;
+}
+
+void Sonde::setConfig(const char *cfg) {
+	while(*cfg==' '||*cfg=='\t') cfg++;
+	if(*cfg=='#') return;
+	char *s = strchr(cfg,'=');
+	if(!s) return;
+	char *val = s+1;
+	*s=0; s--;
+	while(s>cfg && (*s==' '||*s=='\t')) { *s=0; s--; }
+	Serial.printf("configuration option '%s'=%s \n", cfg, val);
+	if(strcmp(cfg,"noisefloor")==0) {
+		config.noisefloor = atoi(val);
+		if(config.noisefloor==0) config.noisefloor=-130;
+	} else if(strcmp(cfg,"call")==0) {
+		strncpy(config.call, val, 9);
+		config.call[9]=0;
+	} else if(strcmp(cfg,"passcode")==0) {
+		strncpy(config.passcode, val, 9);
+	} else if(strcmp(cfg,"button_pin")==0) {
+		config.button_pin = atoi(val);
+	} else if(strcmp(cfg,"button2_pin")==0) {
+		config.button2_pin = atoi(val);
+	} else if(strcmp(cfg,"button2_axp")==0) {
+		config.button2_axp = atoi(val);
+	} else if(strcmp(cfg,"touch_thresh")==0) {
+		config.touch_thresh = atoi(val);
+	} else if(strcmp(cfg,"led_pout")==0) {
+		config.led_pout = atoi(val);
+	} else if(strcmp(cfg,"power_pout")==0) {
+		config.power_pout = atoi(val);
+	} else if(strcmp(cfg,"disptype")==0) {
+		config.disptype = atoi(val);
+	} else if(strcmp(cfg,"oled_sda")==0) {
+		config.oled_sda = atoi(val);
+	} else if(strcmp(cfg,"oled_scl")==0) {
+		config.oled_scl = atoi(val);
+	} else if(strcmp(cfg,"oled_rst")==0) {
+		config.oled_rst = atoi(val);
+	} else if(strcmp(cfg,"oled_orient")==0) {
+		config.oled_orient = atoi(val);
+	} else if(strcmp(cfg,"gpsOn")==0) {
+		config.gpsOn = atoi(val);
+	} else if(strcmp(cfg,"gps_rxd")==0) {
+		config.gps_rxd = atoi(val);
+	} else if(strcmp(cfg,"gps_txd")==0) {
+		config.gps_txd = atoi(val);
+	} else if(strcmp(cfg,"gps_lat")==0) {
+		strncpy(config.gps_lat, val, 8);
+	} else if(strcmp(cfg,"gps_lon")==0) {
+		strncpy(config.gps_lon, val, 8);
+	} else if(strcmp(cfg,"gps_alt")==0) {
+		config.gps_alt = atoi(val);
+	} else if(strcmp(cfg,"maxsonde")==0) {
+		config.maxsonde = atoi(val);
+		if(config.maxsonde>MAXSONDE) config.maxsonde=MAXSONDE;
+	} else if(strcmp(cfg,"debug")==0) {
+		config.debug = atoi(val);
+	} else if(strcmp(cfg,"wifi")==0) {
+		config.wifi = atoi(val);			
+	} else if(strcmp(cfg,"wifiap")==0) {
+		config.wifiap = atoi(val);
+	} else if(strcmp(cfg,"mdnsname")==0) {
+		strncpy(config.mdnsname, val, 14);
+	} else if(strcmp(cfg,"vbatmax")==0) {
+		strncpy(config.vbatmax,val,5);
+	} else if(strcmp(cfg,"vbatmin")==0) {
+		strncpy(config.vbatmin,val,5);
+	} else if(strcmp(cfg,"sdOn")==0) {
+		config.sdOn=atoi(val);
+	} else if(strcmp(cfg,"buzzerOn")==0) {
+		config.buzzerOn=atoi(val);
+	} else if(strcmp(cfg,"buzzerPort")==0) {
+		config.buzzerPort=atoi(val);
+	} else if(strcmp(cfg,"buzzerFreq")==0) {
+		config.buzzerFreq=atoi(val);
+	} else if(strcmp(cfg,"dbsmetre")==0) {
+		config.dbsmetre=atoi(val);
+	} else if(strcmp(cfg,"display")==0) {
+		int i = 0;
+		char *ptr;
+		while(val) {
+			ptr = strchr(val,',');
+			if(ptr) *ptr = 0;
+			config.display[i++] = atoi(val);
+			val = ptr?ptr+1:NULL;
+			Serial.printf("appending value %d  next is %s\n", config.display[i-1], val?val:"");
+		}
+		config.display[i] = -1;
+	} else if (strcmp(cfg, "norx_timeout")==0) {
+		config.norx_timeout = atoi(val);
+	} else if(strcmp(cfg,"startfreq")==0) {
+		config.startfreq = atoi(val);
+	} else if(strcmp(cfg,"channelbw")==0) {
+		config.channelbw = atoi(val);	
+	} else if(strcmp(cfg,"spectrum")==0) {
+		config.spectrum = atoi(val);
+	} else if(strcmp(cfg,"marker")==0) {
+		config.marker = atoi(val);					
+	} else if(strcmp(cfg,"showafc")==0) {
+		config.showafc = atoi(val);
+	} else if(strcmp(cfg,"freqofs")==0) {
+		config.freqofs = atoi(val);
+	} else if(strcmp(cfg,"rs41.agcbw")==0) {
+		config.rs41.agcbw = atoi(val);
+	} else if(strcmp(cfg,"rs41.rxbw")==0) {
+		config.rs41.rxbw = atoi(val);
+	} else if(strcmp(cfg,"dfm.agcbw")==0) {
+		config.dfm.agcbw = atoi(val);
+	} else if(strcmp(cfg,"dfm.rxbw")==0) {
+		config.dfm.rxbw = atoi(val);
+	} else if(strcmp(cfg,"rs92.alt2d")==0) {
+		config.rs92.alt2d= atoi(val);
+	} else if(strcmp(cfg,"kisstnc.active")==0) {
+		config.kisstnc.active = atoi(val);
+	} else if(strcmp(cfg,"kisstnc.idformat")==0) {
+		config.kisstnc.idformat = atoi(val);
+	} else if(strcmp(cfg,"rs92.rxbw")==0) {
+		config.rs92.rxbw = atoi(val);
+	} else if(strcmp(cfg,"axudp.active")==0) {
+		config.udpfeed.active = atoi(val)>0;
+	} else if(strcmp(cfg,"axudp.host")==0) {
+		strncpy(config.udpfeed.host, val, 63);
+	} else if(strcmp(cfg,"axudp.port")==0) {
+		config.udpfeed.port = atoi(val);
+	} else if(strcmp(cfg,"axudp.symbol")==0) {
+		strncpy(config.udpfeed.symbol, val, 3);
+	} else if(strcmp(cfg,"axudp.highrate")==0) {
+		config.udpfeed.highrate = atoi(val);
+	} else if(strcmp(cfg,"axudp.idformat")==0) {
+		config.udpfeed.idformat = atoi(val);
+	} else if(strcmp(cfg,"tcp.active")==0) {
+		config.tcpfeed.active = atoi(val)>0;
+	} else if(strcmp(cfg,"tcp.host")==0) {
+		strncpy(config.tcpfeed.host, val, 63);
+	} else if(strcmp(cfg,"tcp.port")==0) {
+		config.tcpfeed.port = atoi(val);
+	} else if(strcmp(cfg,"tcp.symbol")==0) {
+		strncpy(config.tcpfeed.symbol, val, 3);
+	} else if(strcmp(cfg,"tcp.highrate")==0) {
+		config.tcpfeed.highrate = atoi(val);
+	} else if(strcmp(cfg,"tcp.idformat")==0) {
+		config.tcpfeed.idformat = atoi(val);
+	} else {
+		Serial.printf("Invalid config option '%s'=%s \n", cfg, val);
+	}
+}
+
+void Sonde::setIP(String ip, bool AP) {
+	ipaddr = ip;
+	isAP = AP;
+}
+
+void Sonde::clearSonde() {
+	nSonde = 0;
+}
+void Sonde::addSonde(float frequency, SondeType type, int active, char *launchsite)  {
+	if(nSonde>=config.maxsonde) {
+		Serial.println("Cannot add another sonde, MAXSONDE reached");
+		return;
+	}
+	Serial.printf("Adding %f - %d - %d - %s\n", frequency, type, active, launchsite);
+	sondeList[nSonde].type = type;
+	sondeList[nSonde].freq = frequency;
+	sondeList[nSonde].active = active;
+	strncpy(sondeList[nSonde].launchsite, launchsite, 17);	
+	memcpy(sondeList[nSonde].rxStat, "\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3\x3", 18); // unknown/undefined
+	nSonde++;
+}
+
+// called by updateState (only)
+void Sonde::nextConfig() {
+	currentSonde++;
+	if(currentSonde>=nSonde) {
+		currentSonde=0;
+	}
+	// Skip non-active entries (but don't loop forever if there are no active ones)
+	for(int i=0; i<config.maxsonde; i++) {
+		if(!sondeList[currentSonde].active) {
+			currentSonde++;
+			if(currentSonde>=nSonde) currentSonde=0;
+		}
+	}
+}
+void Sonde::nextRxSonde() {
+	rxtask.currentSonde++;
+	if(rxtask.currentSonde>=nSonde) {
+		rxtask.currentSonde=0;
+	}
+	for(int i=0; i<config.maxsonde; i++) {
+		if(!sondeList[rxtask.currentSonde].active) {
+			rxtask.currentSonde++;
+			if(rxtask.currentSonde>=nSonde) rxtask.currentSonde=0;
+		}
+	}
+	Serial.printf("nextRxSonde: %d\n", rxtask.currentSonde);
+}
+void Sonde::nextRxFreq(int addkhz) {
+	// last entry is for the variable frequency
+        rxtask.currentSonde = nSonde - 1;
+	sondeList[rxtask.currentSonde].active = 1;
+	sondeList[rxtask.currentSonde].freq += addkhz*0.001;
+	if(sondeList[rxtask.currentSonde].freq>406)
+		sondeList[rxtask.currentSonde].freq = 400;
+        Serial.printf("nextRxFreq: %d\n", rxtask.currentSonde);
+}
+SondeInfo *Sonde::si() {
+	return &sondeList[currentSonde];
+}
+
+void Sonde::setup() {
+	if(rxtask.currentSonde<0 || rxtask.currentSonde>=config.maxsonde) {
+		Serial.print("Invalid rxtask.currentSonde: ");
+		Serial.println(rxtask.currentSonde);
+		rxtask.currentSonde = 0;
+	}
+
+	// update receiver config
+	Serial.print("\nSonde::setup() on sonde index ");
+	Serial.println(rxtask.currentSonde);
+	switch(sondeList[rxtask.currentSonde].type) {
+	case STYPE_RS41:
+		rs41.setup(sondeList[rxtask.currentSonde].freq * 1000000);
+		break;
+	case STYPE_DFM06:
+	case STYPE_DFM09:
+		dfm.setup( sondeList[rxtask.currentSonde].freq * 1000000, sondeList[rxtask.currentSonde].type==STYPE_DFM06?0:1 );
+		break;
+	case STYPE_RS92:
+		rs92.setup( sondeList[rxtask.currentSonde].freq * 1000000);
+		break;
+	case STYPE_M10:
+		m10.setup( sondeList[rxtask.currentSonde].freq * 1000000);
+		break;
+	}
+	// debug
+	float afcbw = sx1278.getAFCBandwidth();
+	float rxbw = sx1278.getRxBandwidth();
+	Serial.printf("AFC BW: %f  RX BW: %f\n", afcbw, rxbw);
+}
+
+extern void flashLed(int ms);
+extern void buzzerLed(int temps);
+void Sonde::receive() {
+	uint16_t res = 0;
+	SondeInfo *si = &sondeList[rxtask.currentSonde];
+	switch(si->type) {
+	case STYPE_RS41:
+		res = rs41.receive();
+		break;
+	case STYPE_RS92:
+		res = rs92.receive();
+		break;
+	case STYPE_M10:
+		res = m10.receive();
+		break;
+	case STYPE_DFM06:
+	case STYPE_DFM09:
+		res = dfm.receive();
+		break;
+	}
+
+	// state information for RX_TIMER / NORX_TIMER events
+        if(res==0) {  // RX OK
+		flashLed(700);
+		if(sonde.config.buzzerOn==1) buzzerLed(500);
+                if(si->lastState != 1) {
+                        si->rxStart = millis();
+                        si->lastState = 1;
+                }
+        } else { // RX not ok
+		if(res==RX_ERROR) {
+		  flashLed(100);
+		}
+		Serial.printf("RX result %d, laststate was %d\n", res, si->lastState);
+                if(si->lastState != 0) {
+                        si->norxStart = millis();
+                        si->lastState = 0;
+                }
+        }
+	// Serial.printf("debug: res was %d, now lastState is %d\n", res, si->lastState);
+
+
+	// we should handle timer events here, because after returning from receive,
+	// we'll directly enter setup
+	rxtask.receiveSonde = rxtask.currentSonde; // pass info about decoded sonde to main loop
+
+	int event = getKeyPressEvent();
+	if (!event) event = timeoutEvent(si);
+	int action = (event==EVT_NONE) ? ACT_NONE : disp.layout->actions[event];
+	Serial.printf("event %x: action is %x\n", event, action);
+	// If action is to move to a different sonde index, we do update things here, set activate
+	// to force the sx1278 task to call sonde.setup(), and pass information about sonde to
+	// main loop (display update...)
+	if(action == ACT_NEXTSONDE || action==ACT_PREVSONDE || (action>64&&action<128) ) {
+		// handled here...
+		if(action==ACT_NEXTSONDE||action==ACT_PREVSONDE)
+			nextRxSonde();
+		else
+			nextRxFreq( action-64 );
+		action = ACT_SONDE(rxtask.currentSonde);
+		if(rxtask.activate==-1) {
+			// race condition here. maybe better use mutex. TODO
+			rxtask.activate = action;
+		}
+	}
+	res = (action<<8) | (res&0xff);
+	Serial.printf("receive Result is %04x\n", res);
+	// let waitRXcomplete resume...
+	rxtask.receiveResult = res;
+	#ifdef SDCARD
+	if (sonde.config.sdOn==1){ 
+	   sdwrite();
+	}
+	#endif
+}
+
+// return (action<<8) | (rxresult)
+uint16_t Sonde::waitRXcomplete() {
+	uint16_t res=0;
+        uint32_t t0 = millis();
+rxloop:
+        while( rxtask.receiveResult==0xFFFF && millis()-t0 < 3000) { delay(50); }
+	if( rxtask.receiveResult == RX_UPDATERSSI ) {
+		rxtask.receiveResult = 0xFFFF;
+		Serial.print("RSSI update: ");
+		disp.updateDisplayRSSI();
+		goto rxloop;
+	}
+
+	if( rxtask.receiveResult==0xFFFF) {
+		Serial.println("TIMEOUT in waitRXcomplete. Should never happen!\n");
+		res = RX_TIMEOUT;
+	} else {
+		res = rxtask.receiveResult;
+	}
+        rxtask.receiveResult = 0xFFFF;
+	/// TODO: THis has caused an exception when swithcing back to spectrumm...
+        Serial.printf("waitRXcomplete returning %04x (%s)\n", res, (res&0xff)<4?RXstr[res&0xff]:"");
+	// currently used only by RS92
+	switch(sondeList[rxtask.receiveSonde].type) {
+	case STYPE_RS41:
+		rs41.waitRXcomplete();
+		break;
+	case STYPE_RS92:
+		rs92.waitRXcomplete();
+		break;
+	case STYPE_M10:
+		m10.waitRXcomplete();
+		break;
+	case STYPE_DFM06:
+	case STYPE_DFM09:
+		dfm.waitRXcomplete();
+		break;
+	}
+	memmove(sonde.si()->rxStat+1, sonde.si()->rxStat, 17);
+        sonde.si()->rxStat[0] = res;
+	return res;
+}
+
+uint8_t Sonde::timeoutEvent(SondeInfo *si) {
+	uint32_t now = millis();
+#if 1
+	Serial.printf("Timeout check: %d - %d vs %d; %d - %d vs %d; %d - %d vs %d\n",
+		now, si->viewStart, disp.layout->timeouts[0],
+		now, si->rxStart, disp.layout->timeouts[1],
+		now, si->norxStart, disp.layout->timeouts[2]);
+#endif
+	Serial.printf("lastState is %d\n", si->lastState);
+	if(disp.layout->timeouts[0]>=0 && now - si->viewStart >= disp.layout->timeouts[0]) {
+		Serial.println("View timer expired");
+		return EVT_VIEWTO;
+	}
+	if(si->lastState==1 && disp.layout->timeouts[1]>=0 && now - si->rxStart >= disp.layout->timeouts[1]) {
+		Serial.println("RX timer expired");
+		return EVT_RXTO;
+	}
+	if(si->lastState==0 && disp.layout->timeouts[2]>=0 && now - si->norxStart >= disp.layout->timeouts[2]) {
+		Serial.println("NORX timer expired");
+		return EVT_NORXTO;
+	}
+	return 0;
+}
+
+uint8_t Sonde::updateState(uint8_t event) {
+	Serial.printf("Sonde::updateState for event %d\n", event);
+	// No change
+	if(event==ACT_NONE) return 0xFF;
+
+	// In all cases (new display mode, new sonde) we reset the mode change timers
+	sonde.sondeList[sonde.currentSonde].viewStart = millis();
+        sonde.sondeList[sonde.currentSonde].lastState = -1;
+
+	// Moving to a different display mode
+	if (event==ACT_DISPLAY_SPECTRUM || event==ACT_DISPLAY_WIFI) {
+		// main loop will call setMode() and disable sx1278 background task
+		return event;
+	}
+	int n = event;
+	if(event==ACT_DISPLAY_DEFAULT) {
+		n = config.display[1];
+	} else if(event==ACT_DISPLAY_SCANNER) {
+		n= config.display[0];
+	} else if(event==ACT_DISPLAY_NEXT) {
+		int i;
+		for(i=0; config.display[i]!=-1; i++) {
+			if(config.display[i] == disp.layoutIdx) break;
+		}
+		if(config.display[i]==-1 || config.display[i+1]==-1) {
+			//unknown index, or end of list => loop to start
+			n = config.display[1];
+		} else {
+			n = config.display[i+1];
+		}
+	}
+	if(n>=0 && n<ACT_MAXDISPLAY) {
+		if(n>=disp.nLayouts) {
+			Serial.println("WARNNG: next layout out of range");
+			n = config.display[1];
+		}
+		Serial.printf("Setting display mode %d\n", n);
+		disp.setLayout(n);
+		sonde.clearDisplay();
+		return 0xFF;
+	}
+
+	// Moving to a different value for currentSonde
+	// TODO: THis should be done in sx1278 task, not in main loop!!!!!
+	if(event==ACT_NEXTSONDE) {
+		sonde.nextConfig();
+		Serial.printf("advancing to next sonde %d\n", sonde.currentSonde);
+		return event;
+	}
+	if (event==ACT_PREVSONDE) {
+		// TODO
+		Serial.printf("previous not supported, advancing to next sonde\n");
+		sonde.nextConfig();
+		return ACT_NEXTSONDE;
+	}
+	if(event&0x80) {
+		sonde.currentSonde = (event&0x7F);
+		return ACT_NEXTSONDE;
+	}
+	return 0xFF;
+}
+
+void Sonde::updateDisplayPos() {
+	disp.updateDisplayPos();	
+}
+
+void Sonde::updateDisplayPos2() {
+	disp.updateDisplayPos2();
+}
+
+void Sonde::updateDisplayID() {
+	disp.updateDisplayID();
+}
+	
+void Sonde::updateDisplayRSSI() {
+	disp.updateDisplayRSSI();
+}
+
+void Sonde::updateStat() {
+	disp.updateStat();
+}
+
+void Sonde::updateDisplayRXConfig() {
+	disp.updateDisplayRXConfig();
+}
+
+void Sonde::updateDisplayIP() {
+	disp.updateDisplayIP();
+}
+
+void Sonde::updateDisplay()
+{
+	int t = millis();
+	disp.updateDisplay();
+	Serial.printf("updateDisplay took %d ms\n", (int)(millis()-t));
+}
+
+void Sonde::clearDisplay() {
+	disp.rdis->clear();
+}
+
+Sonde sonde = Sonde();
diff --git a/libraries/SondeLib/Sonde.h b/libraries/SondeLib/Sonde.h
new file mode 100755
index 0000000..e5e5492
--- /dev/null
+++ b/libraries/SondeLib/Sonde.h
@@ -0,0 +1,265 @@
+
+#ifndef Sonde_h
+#define Sonde_h
+
+// RX_TIMEOUT: no header detected
+// RX_ERROR: header detected, but data not decoded (crc error, etc.)
+// RX_OK: header and data ok
+enum RxResult { RX_OK, RX_TIMEOUT, RX_ERROR, RX_UNKNOWN, RX_NOPOS };
+#define RX_UPDATERSSI 0xFFFE
+
+// Events that change what is displayed (mode, sondenr)
+// Keys:
+// 1  Button (short)  or Touch (short)
+// 2  Button (double) or Touch (double)
+// 3  Button (mid)    or Touch (mid)
+// 4  Button (long)   or Touch (long)
+// 5  Touch1/2 (short)
+// 6  Touch1/2 (double)
+// 7  Touch1/2 (mid)
+// 8  Touch1/2 (long)
+
+/* Keypress => Sonde++ / Sonde-- / Display:=N*/
+enum Events { EVT_NONE, EVT_KEY1SHORT, EVT_KEY1DOUBLE, EVT_KEY1MID, EVT_KEY1LONG,
+                        EVT_KEY2SHORT, EVT_KEY2DOUBLE, EVT_KEY2MID, EVT_KEY2LONG,
+                        EVT_VIEWTO, EVT_RXTO, EVT_NORXTO,
+              EVT_MAX };
+extern const char *evstring[];
+extern const char *RXstr[];
+#define EVENTNAME(s) evstring[s]
+
+//int8_t actions[EVT_MAX];
+#define ACT_NONE 255
+#define ACT_DISPLAY(n) (n)
+#define ACT_MAXDISPLAY 50
+#define ACT_DISPLAY_SCANNER 0
+#define ACT_DISPLAY_NEXT 64
+#define ACT_DISPLAY_DEFAULT 63
+#define ACT_DISPLAY_SPECTRUM 62
+#define ACT_DISPLAY_WIFI 61
+#define ACT_NEXTSONDE 65
+#define ACT_PREVSONDE 66
+#define ACT_ADDFREQ(n) ((n)+64)
+#define ACT_SONDE(n) ((n)+128)
+
+// 0000nnnn => goto display nnnn
+// 01000000 => goto sonde -1
+// 01000001 => goto sonde +1
+
+#define NSondeTypes 5
+enum SondeType { STYPE_DFM06, STYPE_DFM09, STYPE_RS41, STYPE_RS92, STYPE_M10 };
+extern const char *sondeTypeStr[NSondeTypes];
+
+typedef struct st_sondeinfo {
+        // receiver configuration
+	bool active;
+        SondeType type;
+        float freq;
+        // decoded ID
+        char id[10];
+	char ser[12];
+        bool validID;
+	char launchsite[18];		
+        // decoded position
+        float lat;			// latitude
+        float lon;			// longitude
+        float az;			// azimut
+        float vbat;			// vbat %
+        float alt;			// altitude
+        float vs;			// vertical speed
+        float hs;			// horizontal speed
+	float dir; 			// 0..360
+	uint8_t sats;			// number of sats
+        uint8_t validPos;   // bit pattern for validity of above 7 fields; 0x80: position is old
+	// decoded GPS time
+	uint32_t time;
+	uint16_t sec;
+	uint32_t frame;
+	bool validTime;
+        // RSSI from receiver
+        int rssi;			// signal strength
+	int32_t afc;			// afc correction value
+	// statistics
+	uint8_t rxStat[20];
+	uint32_t rxStart;    		// millis() timestamp of continuous rx start
+	uint32_t norxStart;		// millis() timestamp of continuous no rx start
+	uint32_t viewStart;		// millis() timestamp of viewinf this sonde with current display
+	int8_t lastState;		// -1: disabled; 0: norx; 1: rx
+	// shut down timers, currently only for RS41; -1=disabled
+	int16_t launchKT, burstKT, countKT;
+	uint16_t crefKT; // frame number in which countKT was last sent
+} SondeInfo;
+// rxStat: 3=undef[empty] 1=timeout[.] 2=errro[E] 0=ok[|] 4=no valid position[°]
+
+// Used for interacting with the RX background task
+typedef struct st_RXTask {
+	// Variables set by Arduino main loop to value >=0 for requesting
+	// mode change to sonde reception for sonde <value) in RXTask.
+	// Will be reset to -1 by RXTask
+	int activate;
+	// Variables set by RXTask, corresponding to mode ST_DECODER (if active) or something else,
+	// and currently received sonde
+	int mainState;
+	int currentSonde;
+	// Variable set by RXTask to communicate status to Arduino task
+	// via waitRXcomplete function
+	uint16_t receiveResult;
+	uint16_t receiveSonde;  // sonde inde corresponding to receiveResult
+	// status variabe set by decoder to indicate something is broken
+	// int fifoOverflow;
+} RXTask;
+
+extern RXTask rxtask;
+
+struct st_rs41config {
+	int agcbw;
+	int rxbw;
+};
+struct st_rs92config {
+	int rxbw;
+	int alt2d;
+};
+struct st_dfmconfig {
+	int agcbw;
+	int rxbw;
+};
+
+
+enum IDTYPE { ID_DFMDXL, ID_DFMGRAW, ID_DFMAUTO };
+
+struct st_feedinfo {
+        bool active;
+        int type;       // 0:UDP(axudp), 1:TCP(aprs.fi)
+        char host[64];
+        int port;
+        char symbol[3];
+        int lowrate;
+        int highrate;
+        int lowlimit;
+        int idformat;   // 0: dxl  1: real  2: auto
+};
+
+// maybe extend for external Bluetooth interface?
+// internal bluetooth consumes too much memory
+struct st_kisstnc {
+        bool active;
+        int idformat;
+};
+
+
+typedef struct st_rdzconfig {
+	// hardware configuration
+	int button_pin;			// PIN port number menu button (+128 for touch mode)
+	int button2_pin;		// PIN port number menu button (+128 for touch mode)
+	int button2_axp;		// Use AXP192 power button as button2
+	int touch_thresh;		// Threshold value (0..100) for touch input button
+	int led_pout;			// POUT port number of LED (used as serial monitor)
+	int power_pout;			// Power control pin (for Heltec v2)
+	int disptype;			// 0=OLED; 1=ILI9225
+	int oled_sda;			// OLED data pin 
+	int oled_scl;			// OLED clock pin
+	int oled_rst;			// OLED reset pin
+	int oled_orient;		// OLED orientation (default: 1)
+	int gpsOn;			// GPS Active On=1/Off=0
+	int gps_rxd;			// GPS module RXD pin. We expect 9600 baud NMEA data.
+	int gps_txd;			// GPS module TXD pin
+	char gps_lat[20];		// QTH no gps latitude
+	char gps_lon[20];		// QTH no gps longitude
+	int gps_alt;			// QTH no gps altitude
+	// software configuration
+	int debug;				// show port and config options after reboot
+	int wifi;				// connect to known WLAN 0=skip
+	int wifiap;				// enable/disable WiFi AccessPoint mode 0=disable
+	int8_t display[30];			// list of display mode (0:scanner, 1:default, 2,... additional modes)
+	int startfreq;			// spectrum display start freq (400, 401, ...)
+	int channelbw;			// spectrum channel bandwidth (valid: 5, 10, 20, 25, 50, 100 kHz)	
+	int spectrum;			// show freq spectrum for n seconds -1=disable; 0=forever
+	int marker;				// show freq marker in spectrum  0=disable
+	int maxsonde;			// number of max sonde in scan (range=1-99)
+	int norx_timeout;		// Time after which rx mode switches to scan mode (without rx signal)
+	int noisefloor;			// for spectrum display
+	char mdnsname[15];		// mDNS-Name, defaults to rdzsonde
+	char vbatmax[5];		// Vbat maxi when bat charged
+	char vbatmin[5];		// Vbat minimum discharged
+	int sdOn;			// Active SDCard
+	int buzzerPort;		// Buzzer port
+	int buzzerFreq;		// Buzzer Frequency
+	int buzzerOn;			// Buzzer On
+	int dbsmetre;			// Db or Smetre display
+	// receiver configuration
+	int showafc;			// show afc value in rx screen
+	int freqofs;			// frequency offset (tuner config = rx frequency + freqofs) in Hz
+	struct st_rs41config rs41;	// configuration options specific for RS41 receiver
+	struct st_rs92config rs92;
+	struct st_dfmconfig dfm;
+	// data feed configuration
+	// for now, one feed for each type is enough, but might get extended to more?
+	char call[10];			// APRS callsign
+	char passcode[9];		// APRS passcode
+	struct st_feedinfo udpfeed;	// target for AXUDP messages
+	struct st_feedinfo tcpfeed;	// target for APRS-IS TCP connections
+	struct st_kisstnc kisstnc;	// target for KISS TNC (via TCP, mainly for APRSdroid)
+} RDZConfig;
+
+
+#define MAXSONDE 99
+
+extern int fingerprintValue[];
+extern const char *fingerprintText[];
+
+class Sonde
+{
+private:
+public:
+	RDZConfig config;
+	int fingerprint = 0;
+	int currentSonde = 0;
+	int nSonde;
+	String ipaddr;
+	bool isAP;
+	// moved to heap, saving space in .bss
+	//SondeInfo sondeList[MAXSONDE+1];
+	SondeInfo *sondeList;
+
+	Sonde();
+	void defaultConfig();
+	void setConfig(const char *str);
+
+	void clearSonde();
+	void addSonde(float frequency, SondeType type, int active, char *launchsite);
+	void nextConfig();
+	void nextRxSonde();
+	void nextRxFreq(int addkhz);
+
+	/* new interface */
+	void setup();
+	void receive();
+	uint16_t waitRXcomplete();
+	/* old and temp interface */
+#if 0
+	void processRXbyte(uint8_t data);
+	int  receiveFrame();
+#endif
+
+	SondeInfo *si();
+
+	uint8_t timeoutEvent(SondeInfo *si);
+	uint8_t updateState(uint8_t event);
+
+	void updateDisplayPos();
+	void updateDisplayPos2();
+	void updateDisplayID();
+	void updateDisplayRSSI();
+	void updateDisplayRXConfig();
+	void updateStat();
+	void updateDisplayIP();
+	void updateDisplay();
+	void clearDisplay();
+
+	void setIP(String ip, bool isAP);
+};
+
+extern Sonde sonde;
+
+#endif
+
diff --git a/libraries/SondeLib/TFT22_ILI9225.cpp b/libraries/SondeLib/TFT22_ILI9225.cpp
new file mode 100755
index 0000000..bad6016
--- /dev/null
+++ b/libraries/SondeLib/TFT22_ILI9225.cpp
@@ -0,0 +1,1412 @@
+//        SPDX-License-Identifier:        GPL-3.0
+//	original source: https://github.com/Nkawu/TFT22_ILI9225
+
+
+#include "TFT22_ILI9225.h"
+
+//#define DEBUG
+#ifdef DEBUG
+    //#define DB_PRINT( x, ... ) { char dbgbuf[60]; sprintf_P( dbgbuf, (const char*) F( x ), __VA_ARGS__ ) ; Serial.print( dbgbuf ); }
+    #define DB_PRINT( ... ) { char dbgbuf[60]; sprintf( dbgbuf,   __VA_ARGS__ ) ; Serial.println( dbgbuf ); }
+    
+#else
+    #define DB_PRINT(  ... ) ;
+#endif
+
+
+
+#ifndef ARDUINO_STM32_FEATHER
+    #include "pins_arduino.h"
+    #ifndef RASPI
+        #include "wiring_private.h"
+    #endif
+#endif
+#include <limits.h>
+#ifdef __AVR__
+  #include <avr/pgmspace.h>
+#elif defined(ESP8266) || defined(ESP32)
+  #include <pgmspace.h>
+#endif
+
+// Many (but maybe not all) non-AVR board installs define macros
+// for compatibility with existing PROGMEM-reading AVR code.
+// Do our own checks and defines here for good measure...
+
+#ifndef pgm_read_byte
+ #define pgm_read_byte(addr) (*(const unsigned char *)(addr))
+#endif
+#ifndef pgm_read_word
+ #define pgm_read_word(addr) (*(const unsigned short *)(addr))
+#endif
+#ifndef pgm_read_dword
+ #define pgm_read_dword(addr) (*(const unsigned long *)(addr))
+#endif
+
+// Pointers are a peculiar case...typically 16-bit on AVR boards,
+// 32 bits elsewhere.  Try to accommodate both...
+
+#if !defined(__INT_MAX__) || (__INT_MAX__ > 0xFFFF)
+ #define pgm_read_pointer(addr) ((void *)pgm_read_dword(addr))
+#else
+ #define pgm_read_pointer(addr) ((void *)pgm_read_word(addr))
+#endif
+
+// Control pins
+
+#ifdef USE_FAST_PINIO
+    #define SPI_DC_HIGH()           *dcport |=  dcpinmask
+    #define SPI_DC_LOW()            *dcport &= ~dcpinmask
+    #define SPI_CS_HIGH()           *csport |=  cspinmask
+    #define SPI_CS_LOW()            *csport &= ~cspinmask
+#else
+    #define SPI_DC_HIGH()           digitalWrite(_rs, HIGH)
+    #define SPI_DC_LOW()            digitalWrite(_rs, LOW)
+    #define SPI_CS_HIGH()           digitalWrite(_cs, HIGH)
+    #define SPI_CS_LOW()            digitalWrite(_cs, LOW)
+#endif
+
+// Software SPI Macros
+
+#ifdef USE_FAST_PINIO
+    #define SSPI_MOSI_HIGH()        *mosiport |=  mosipinmask
+    #define SSPI_MOSI_LOW()         *mosiport &= ~mosipinmask
+    #define SSPI_SCK_HIGH()         *clkport |=  clkpinmask
+    #define SSPI_SCK_LOW()          *clkport &= ~clkpinmask
+#else
+    #define SSPI_MOSI_HIGH()        digitalWrite(_sdi, HIGH)
+    #define SSPI_MOSI_LOW()         digitalWrite(_sdi, LOW)
+    #define SSPI_SCK_HIGH()         digitalWrite(_clk, HIGH)
+    #define SSPI_SCK_LOW()          digitalWrite(_clk, LOW)
+#endif
+
+#define SSPI_BEGIN_TRANSACTION()
+#define SSPI_END_TRANSACTION()
+#define SSPI_WRITE(v)           _spiWrite(v)
+#define SSPI_WRITE16(s)         SSPI_WRITE((s) >> 8); SSPI_WRITE(s)
+#define SSPI_WRITE32(l)         SSPI_WRITE((l) >> 24); SSPI_WRITE((l) >> 16); SSPI_WRITE((l) >> 8); SSPI_WRITE(l)
+#define SSPI_WRITE_PIXELS(c,l)  for(uint32_t i=0; i<(l); i+=2){ SSPI_WRITE(((uint8_t*)(c))[i+1]); SSPI_WRITE(((uint8_t*)(c))[i]); }
+
+// Hardware SPI Macros
+#ifndef ESP32
+    #ifdef SPI_CHANNEL
+        extern SPIClass SPI_CHANNEL; 
+        #define SPI_OBJECT  SPI_CHANNEL
+    #else
+        #define SPI_OBJECT  SPI
+    #endif
+#else
+    #define SPI_OBJECT  _spi
+#endif
+
+#if defined (__AVR__) || defined(TEENSYDUINO) || defined(ARDUINO_ARCH_STM32F1)
+    #define HSPI_SET_CLOCK() SPI_OBJECT.setClockDivider(SPI_CLOCK_DIV2);
+#elif defined (__arm__)
+    #define HSPI_SET_CLOCK() SPI_OBJECT.setClockDivider(11);
+#elif defined(ESP8266) || defined(ESP32)
+    #define HSPI_SET_CLOCK() SPI_OBJECT.setFrequency(SPI_DEFAULT_FREQ);
+#elif defined(RASPI)
+    #define HSPI_SET_CLOCK() SPI_OBJECT.setClock(SPI_DEFAULT_FREQ);
+#elif defined(ARDUINO_ARCH_STM32F1)
+    #define HSPI_SET_CLOCK() SPI_OBJECT.setClock(SPI_DEFAULT_FREQ);
+#else
+    #define HSPI_SET_CLOCK()
+#endif
+
+#ifdef SPI_HAS_TRANSACTION
+    #define HSPI_BEGIN_TRANSACTION() SPI_OBJECT.beginTransaction(SPISettings(SPI_DEFAULT_FREQ, MSBFIRST, SPI_MODE0))
+    #define HSPI_END_TRANSACTION()   SPI_OBJECT.endTransaction()
+#else
+    #define HSPI_BEGIN_TRANSACTION() HSPI_SET_CLOCK(); SPI_OBJECT.setBitOrder(MSBFIRST); SPI_OBJECT.setDataMode(SPI_MODE0)
+    #define HSPI_END_TRANSACTION()
+#endif
+
+#ifdef ESP32
+    #define SPI_HAS_WRITE_PIXELS
+#endif
+#if defined(ESP8266) || defined(ESP32)
+    // Optimized SPI (ESP8266 and ESP32)
+    #define HSPI_READ()              SPI_OBJECT.transfer(0)
+    #define HSPI_WRITE(b)            SPI_OBJECT.write(b)
+    #define HSPI_WRITE16(s)          SPI_OBJECT.write16(s)
+    #define HSPI_WRITE32(l)          SPI_OBJECT.write32(l)
+    #ifdef SPI_HAS_WRITE_PIXELS
+        #define SPI_MAX_PIXELS_AT_ONCE  32
+        #define HSPI_WRITE_PIXELS(c,l)   SPI_OBJECT.writePixels(c,l)
+    #else
+        #define HSPI_WRITE_PIXELS(c,l)   for(uint32_t i=0; i<((l)/2); i++){ SPI_WRITE16(((uint16_t*)(c))[i]); }
+    #endif
+#elif defined ( __STM32F1__ )
+    #define HSPI_WRITE(b)            SPI_OBJECT.write(b)
+    #define HSPI_WRITE16(s)          SPI_OBJECT.write16(s)
+
+#else
+    // Standard Byte-by-Byte SPI
+
+    #if defined (__AVR__) || defined(TEENSYDUINO)
+    static inline uint8_t _avr_spi_read(void) __attribute__((always_inline));
+    static inline uint8_t _avr_spi_read(void) {
+        uint8_t r = 0;
+        SPDR = r;
+        while(!(SPSR & _BV(SPIF)));
+        r = SPDR;
+        return r;
+    }
+        #define HSPI_WRITE(b)        {SPDR = (b); while(!(SPSR & _BV(SPIF)));}
+        // #define HSPI_READ()          _avr_spi_read()
+    #else
+        #define HSPI_WRITE(b)        SPI_OBJECT.transfer((uint8_t)(b))
+        // #define HSPI_READ()          HSPI_WRITE(0)
+    #endif
+    // #define HSPI_WRITE16(s)          HSPI_WRITE((s) >> 8); HSPI_WRITE(s)
+    // #define HSPI_WRITE32(l)          HSPI_WRITE((l) >> 24); HSPI_WRITE((l) >> 16); HSPI_WRITE((l) >> 8); HSPI_WRITE(l)
+    // #define HSPI_WRITE_PIXELS(c,l)   for(uint32_t i=0; i<(l); i+=2){ HSPI_WRITE(((uint8_t*)(c))[i+1]); HSPI_WRITE(((uint8_t*)(c))[i]); }
+#endif
+
+// Final SPI Macros
+
+#if defined (ARDUINO_ARCH_ARC32)
+    #define SPI_DEFAULT_FREQ         16000000
+#elif defined (__AVR__) || defined(TEENSYDUINO)
+    #define SPI_DEFAULT_FREQ         8000000
+#elif defined(ESP8266) || defined(ESP32)
+    #define SPI_DEFAULT_FREQ         40000000
+#elif defined(RASPI)
+    #define SPI_DEFAULT_FREQ         80000000
+#elif defined(ARDUINO_ARCH_STM32F1)
+    #define SPI_DEFAULT_FREQ         18000000
+    //#define SPI_DEFAULT_FREQ         36000000
+#else
+    #define SPI_DEFAULT_FREQ         24000000
+#endif
+
+#define SPI_BEGIN()             if(_clk < 0){SPI_OBJECT.begin();}
+#define SPI_BEGIN_TRANSACTION() if(_clk < 0){HSPI_BEGIN_TRANSACTION();}
+#define SPI_END_TRANSACTION()   if(_clk < 0){HSPI_END_TRANSACTION();}
+// #define SPI_WRITE16(s)          if(_clk < 0){HSPI_WRITE16(s);}else{SSPI_WRITE16(s);}
+// #define SPI_WRITE32(l)          if(_clk < 0){HSPI_WRITE32(l);}else{SSPI_WRITE32(l);}
+// #define SPI_WRITE_PIXELS(c,l)   if(_clk < 0){HSPI_WRITE_PIXELS(c,l);}else{SSPI_WRITE_PIXELS(c,l);}
+
+// Constructor when using software SPI.  All output pins are configurable.
+TFT22_ILI9225::TFT22_ILI9225(int8_t rst, int8_t rs, int8_t cs, int8_t sdi, int8_t clk, int8_t led) {
+    _rst  = rst;
+    _rs   = rs;
+    _cs   = cs;
+    _sdi  = sdi;
+    _clk  = clk;
+    _led  = led;
+    _brightness = 255; // Set to maximum brightness
+    hwSPI = false;
+    writeFunctionLevel = 0;
+    gfxFont = NULL;
+}
+
+// Constructor when using software SPI.  All output pins are configurable. Adds backlight brightness 0-255
+TFT22_ILI9225::TFT22_ILI9225(int8_t rst, int8_t rs, int8_t cs, int8_t sdi, int8_t clk, int8_t led, uint8_t brightness) {
+    _rst  = rst;
+    _rs   = rs;
+    _cs   = cs;
+    _sdi  = sdi;
+    _clk  = clk;
+    _led  = led;
+    _brightness = brightness;
+    hwSPI = false;
+    writeFunctionLevel = 0;
+    gfxFont = NULL;
+}
+
+// Constructor when using hardware SPI.  Faster, but must use SPI pins
+// specific to each board type (e.g. 11,13 for Uno, 51,52 for Mega, etc.)
+TFT22_ILI9225::TFT22_ILI9225(int8_t rst, int8_t rs, int8_t cs, int8_t led) {
+    _rst  = rst;
+    _rs   = rs;
+    _cs   = cs;
+    _sdi  = _clk = -1;
+    _led  = led;
+    _brightness = 255; // Set to maximum brightness
+    hwSPI = true;
+    writeFunctionLevel = 0;
+    gfxFont = NULL;
+}
+
+// Constructor when using hardware SPI.  Faster, but must use SPI pins
+// specific to each board type (e.g. 11,13 for Uno, 51,52 for Mega, etc.)
+// Adds backlight brightness 0-255
+TFT22_ILI9225::TFT22_ILI9225(int8_t rst, int8_t rs, int8_t cs, int8_t led, uint8_t brightness) {
+    _rst  = rst;
+    _rs   = rs;
+    _cs   = cs;
+    _sdi  = _clk = -1;
+    _led  = led;
+    _brightness = brightness;
+    hwSPI = true;
+    writeFunctionLevel = 0;
+    gfxFont = NULL;
+}
+
+ 
+#ifdef ESP32
+void TFT22_ILI9225::begin(SPIClass &spi)
+#else
+void TFT22_ILI9225::begin()
+#endif
+{
+#ifdef ESP32
+    _spi = spi;
+#endif
+    // Set up reset pin
+    if (_rst > 0) {
+        pinMode(_rst, OUTPUT);
+        digitalWrite(_rst, LOW);
+    }
+   // Set up backlight pin, turn off initially
+    if (_led > 0) {
+        pinMode(_led, OUTPUT);
+        setBacklight(false);
+    }
+
+    // Control pins
+    pinMode(_rs, OUTPUT);
+    digitalWrite(_rs, LOW);
+    pinMode(_cs, OUTPUT);
+    digitalWrite(_cs, HIGH);
+
+    #ifdef USE_FAST_PINIO
+    csport    = portOutputRegister(digitalPinToPort(_cs));
+    cspinmask = digitalPinToBitMask(_cs);
+    dcport    = portOutputRegister(digitalPinToPort(_rs));
+    dcpinmask = digitalPinToBitMask(_rs);
+#endif
+
+    // Software SPI
+    if(_clk >= 0){
+        pinMode(_sdi, OUTPUT);
+        digitalWrite(_sdi, LOW);
+        pinMode(_clk, OUTPUT);
+        digitalWrite(_clk, HIGH);
+#ifdef USE_FAST_PINIO
+        clkport     = portOutputRegister(digitalPinToPort(_clk));
+        clkpinmask  = digitalPinToBitMask(_clk);
+        mosiport    = portOutputRegister(digitalPinToPort(_sdi));
+        mosipinmask = digitalPinToBitMask(_sdi);
+        SSPI_SCK_LOW();
+        SSPI_MOSI_LOW();
+    } else {
+        clkport     = 0;
+        clkpinmask  = 0;
+        mosiport    = 0;
+        mosipinmask = 0;
+#endif
+    }
+
+    // Hardware SPI
+   if(_clk < 0){
+    SPI_BEGIN();
+   } else {
+    SPI_OBJECT.begin(_clk, -1, _sdi, _cs);
+    _clk = -1;  // force use of hardware SPI
+   }
+
+    // Initialization Code
+    if (_rst > 0) {
+        digitalWrite(_rst, HIGH); // Pull the reset pin high to release the ILI9225C from the reset status
+        delay(1); 
+        digitalWrite(_rst, LOW); // Pull the reset pin low to reset ILI9225
+        delay(10);
+        digitalWrite(_rst, HIGH); // Pull the reset pin high to release the ILI9225C from the reset status
+        delay(50);
+    }
+
+    /* Start Initial Sequence */
+
+    /* Set SS bit and direction output from S528 to S1 */
+    startWrite();
+    _writeRegister(ILI9225_POWER_CTRL1, 0x0000); // Set SAP,DSTB,STB
+    _writeRegister(ILI9225_POWER_CTRL2, 0x0000); // Set APON,PON,AON,VCI1EN,VC
+    _writeRegister(ILI9225_POWER_CTRL3, 0x0000); // Set BT,DC1,DC2,DC3
+    _writeRegister(ILI9225_POWER_CTRL4, 0x0000); // Set GVDD
+    _writeRegister(ILI9225_POWER_CTRL5, 0x0000); // Set VCOMH/VCOML voltage
+    endWrite();
+    delay(40); 
+
+    // Power-on sequence
+    startWrite();
+    _writeRegister(ILI9225_POWER_CTRL2, 0x0018); // Set APON,PON,AON,VCI1EN,VC
+    _writeRegister(ILI9225_POWER_CTRL3, 0x6121); // Set BT,DC1,DC2,DC3
+    _writeRegister(ILI9225_POWER_CTRL4, 0x006F); // Set GVDD   /*007F 0088 */
+    _writeRegister(ILI9225_POWER_CTRL5, 0x495F); // Set VCOMH/VCOML voltage
+    _writeRegister(ILI9225_POWER_CTRL1, 0x0800); // Set SAP,DSTB,STB
+    endWrite();
+    delay(10);
+    startWrite();
+    _writeRegister(ILI9225_POWER_CTRL2, 0x103B); // Set APON,PON,AON,VCI1EN,VC
+    endWrite();
+    delay(50);
+
+    startWrite();
+    _writeRegister(ILI9225_DRIVER_OUTPUT_CTRL, 0x011C); // set the display line number and display direction
+    _writeRegister(ILI9225_LCD_AC_DRIVING_CTRL, 0x0100); // set 1 line inversion
+    _writeRegister(ILI9225_ENTRY_MODE, 0x1038); // set GRAM write direction and BGR=1.
+    _writeRegister(ILI9225_DISP_CTRL1, 0x0000); // Display off
+    _writeRegister(ILI9225_BLANK_PERIOD_CTRL1, 0x0808); // set the back porch and front porch
+    _writeRegister(ILI9225_FRAME_CYCLE_CTRL, 0x1100); // set the clocks number per line
+    _writeRegister(ILI9225_INTERFACE_CTRL, 0x0000); // CPU interface
+    _writeRegister(ILI9225_OSC_CTRL, 0x0D01); // Set Osc  /*0e01*/
+    _writeRegister(ILI9225_VCI_RECYCLING, 0x0020); // Set VCI recycling
+    _writeRegister(ILI9225_RAM_ADDR_SET1, 0x0000); // RAM Address
+    _writeRegister(ILI9225_RAM_ADDR_SET2, 0x0000); // RAM Address
+
+    /* Set GRAM area */
+    _writeRegister(ILI9225_GATE_SCAN_CTRL, 0x0000); 
+    _writeRegister(ILI9225_VERTICAL_SCROLL_CTRL1, 0x00DB); 
+    _writeRegister(ILI9225_VERTICAL_SCROLL_CTRL2, 0x0000); 
+    _writeRegister(ILI9225_VERTICAL_SCROLL_CTRL3, 0x0000); 
+    _writeRegister(ILI9225_PARTIAL_DRIVING_POS1, 0x00DB); 
+    _writeRegister(ILI9225_PARTIAL_DRIVING_POS2, 0x0000); 
+    _writeRegister(ILI9225_HORIZONTAL_WINDOW_ADDR1, 0x00AF); 
+    _writeRegister(ILI9225_HORIZONTAL_WINDOW_ADDR2, 0x0000); 
+    _writeRegister(ILI9225_VERTICAL_WINDOW_ADDR1, 0x00DB); 
+    _writeRegister(ILI9225_VERTICAL_WINDOW_ADDR2, 0x0000); 
+
+    /* Set GAMMA curve */
+    _writeRegister(ILI9225_GAMMA_CTRL1, 0x0000); 
+    _writeRegister(ILI9225_GAMMA_CTRL2, 0x0808); 
+    _writeRegister(ILI9225_GAMMA_CTRL3, 0x080A); 
+    _writeRegister(ILI9225_GAMMA_CTRL4, 0x000A); 
+    _writeRegister(ILI9225_GAMMA_CTRL5, 0x0A08); 
+    _writeRegister(ILI9225_GAMMA_CTRL6, 0x0808); 
+    _writeRegister(ILI9225_GAMMA_CTRL7, 0x0000); 
+    _writeRegister(ILI9225_GAMMA_CTRL8, 0x0A00); 
+    _writeRegister(ILI9225_GAMMA_CTRL9, 0x0710); 
+    _writeRegister(ILI9225_GAMMA_CTRL10, 0x0710); 
+
+    _writeRegister(ILI9225_DISP_CTRL1, 0x0012); 
+    endWrite();
+    delay(50); 
+    startWrite();
+    _writeRegister(ILI9225_DISP_CTRL1, 0x1017);
+    endWrite();
+
+    // Turn on backlight
+    setBacklight(true);
+    setOrientation(0);
+
+    // Initialize variables
+    setBackgroundColor( COLOR_BLACK );
+
+    clear();
+}
+
+
+void TFT22_ILI9225::_spiWrite(uint8_t b) {
+    if(_clk < 0){
+        HSPI_WRITE(b);
+        return;
+    }
+    // Fast SPI bitbang swiped from LPD8806 library
+    for(uint8_t bit = 0x80; bit; bit >>= 1){
+        if((b) & bit){
+            SSPI_MOSI_HIGH();
+        } else {
+            SSPI_MOSI_LOW();
+        }
+        SSPI_SCK_HIGH();
+        SSPI_SCK_LOW();
+    }
+}
+
+void TFT22_ILI9225::_spiWrite16(uint16_t s)
+{
+    // Attempt to use HSPI_WRITE16 if available
+    #ifdef HSPI_WRITE16
+    if(_clk < 0){
+        HSPI_WRITE16(s);
+        return;
+    }
+    #endif
+    // Fallback to SSPI_WRITE16 if HSPI_WRITE16 not available
+    SSPI_WRITE16(s);
+}
+
+void TFT22_ILI9225::_spiWriteCommand(uint8_t c) {
+    SPI_DC_LOW();
+    SPI_CS_LOW();
+    _spiWrite(c);
+    SPI_CS_HIGH();
+}
+
+
+void TFT22_ILI9225::_spiWriteData(uint8_t c) {
+    SPI_DC_HIGH();
+    SPI_CS_LOW();
+    _spiWrite(c);
+    SPI_CS_HIGH();
+}
+
+void TFT22_ILI9225::_orientCoordinates(uint16_t &x1, uint16_t &y1) {
+
+    switch (_orientation) {
+    case 0:  // ok
+        break;
+    case 1: // ok
+        y1 = _maxY - y1 - 1;
+        _swap(x1, y1);
+        break;
+    case 2: // ok
+        x1 = _maxX - x1 - 1;
+        y1 = _maxY - y1 - 1;
+        break;
+    case 3: // ok
+        x1 = _maxX - x1 - 1;
+        _swap(x1, y1);
+        break;
+    }
+}
+
+void TFT22_ILI9225::_setWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1) {
+    _setWindow( x0, y0, x1, y1, TopDown_L2R ); // default for drawing characters
+}
+
+void TFT22_ILI9225::_setWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, autoIncMode_t mode) {
+    DB_PRINT( "setWindows( x0=%d, y0=%d, x1=%d, y1=%d, mode=%d", x0,y0,x1,y1,mode );
+    // clip to TFT-Dimensions
+    x0 = min( x0, (uint16_t) (_maxX-1) );
+    x1 = min( x1, (uint16_t) (_maxX-1) );
+    y0 = min( y0, (uint16_t) (_maxY-1) );
+    y1 = min( y1, (uint16_t) (_maxY-1) );
+    _orientCoordinates(x0, y0);
+    _orientCoordinates(x1, y1);
+
+    if (x1<x0) _swap(x0, x1);
+    if (y1<y0) _swap(y0, y1);
+    
+    startWrite();
+    // autoincrement mode
+    if ( _orientation > 0 ) mode = modeTab[_orientation-1][mode];
+    _writeRegister(ILI9225_ENTRY_MODE, 0x1000 | ( mode<<3) );
+    _writeRegister(ILI9225_HORIZONTAL_WINDOW_ADDR1,x1);
+    _writeRegister(ILI9225_HORIZONTAL_WINDOW_ADDR2,x0);
+
+    _writeRegister(ILI9225_VERTICAL_WINDOW_ADDR1,y1);
+    _writeRegister(ILI9225_VERTICAL_WINDOW_ADDR2,y0);
+    DB_PRINT( "gedreht: x0=%d, y0=%d, x1=%d, y1=%d, mode=%d", x0,y0,x1,y1,mode );
+    // starting position within window and increment/decrement direction
+    switch ( mode>>1 ) {
+      case 0:
+        _writeRegister(ILI9225_RAM_ADDR_SET1,x1);
+        _writeRegister(ILI9225_RAM_ADDR_SET2,y1);
+        break;
+      case 1:
+        _writeRegister(ILI9225_RAM_ADDR_SET1,x0);
+        _writeRegister(ILI9225_RAM_ADDR_SET2,y1);
+        break;
+      case 2:
+        _writeRegister(ILI9225_RAM_ADDR_SET1,x1);
+        _writeRegister(ILI9225_RAM_ADDR_SET2,y0);
+        break;
+      case 3:
+        _writeRegister(ILI9225_RAM_ADDR_SET1,x0);
+        _writeRegister(ILI9225_RAM_ADDR_SET2,y0);
+        break;
+    }
+    _writeCommand16( ILI9225_GRAM_DATA_REG );
+
+    //_writeRegister(ILI9225_RAM_ADDR_SET1,x0);
+    //_writeRegister(ILI9225_RAM_ADDR_SET2,y0);
+
+    //_writeCommand(0x00, 0x22);
+
+    endWrite();
+}
+
+
+void TFT22_ILI9225::_resetWindow() {
+    _writeRegister(ILI9225_HORIZONTAL_WINDOW_ADDR1, 0x00AF); 
+    _writeRegister(ILI9225_HORIZONTAL_WINDOW_ADDR2, 0x0000); 
+    _writeRegister(ILI9225_VERTICAL_WINDOW_ADDR1, 0x00DB); 
+    _writeRegister(ILI9225_VERTICAL_WINDOW_ADDR2, 0x0000); 
+
+}
+
+void TFT22_ILI9225::clear() {
+    uint8_t old = _orientation;
+    setOrientation(0);
+    fillRectangle(0, 0, _maxX - 1, _maxY - 1, COLOR_BLACK);
+    setOrientation(old);
+    delay(10);
+}
+
+
+void TFT22_ILI9225::invert(boolean flag) {
+    startWrite();
+    _writeCommand16(flag ? ILI9225C_INVON : ILI9225C_INVOFF);
+    //_writeCommand(0x00, flag ? ILI9225C_INVON : ILI9225C_INVOFF);
+    endWrite();
+}
+
+
+void TFT22_ILI9225::setBacklight(boolean flag) {
+    blState = flag;
+#ifndef ESP32
+    if (_led) analogWrite(_led, blState ? _brightness : 0);
+#endif
+}
+
+
+void TFT22_ILI9225::setBacklightBrightness(uint8_t brightness) {
+    _brightness = brightness;
+    setBacklight(blState);
+}
+
+
+void TFT22_ILI9225::setDisplay(boolean flag) {
+    if (flag) {
+        startWrite();
+        _writeRegister(0x00ff, 0x0000);
+        _writeRegister(ILI9225_POWER_CTRL1, 0x0000);
+        endWrite();
+        delay(50);
+        startWrite();
+        _writeRegister(ILI9225_DISP_CTRL1, 0x1017);
+        endWrite();
+        delay(200);
+    } else {
+        startWrite();
+        _writeRegister(0x00ff, 0x0000);
+        _writeRegister(ILI9225_DISP_CTRL1, 0x0000);
+        endWrite();
+        delay(50);
+        startWrite();
+        _writeRegister(ILI9225_POWER_CTRL1, 0x0003);
+        endWrite();
+        delay(200);
+    }
+}
+
+
+void TFT22_ILI9225::setOrientation(uint8_t orientation) {
+
+    _orientation = orientation % 4;
+
+    switch (_orientation) {
+    case 0:
+        _maxX = ILI9225_LCD_WIDTH;
+        _maxY = ILI9225_LCD_HEIGHT;
+
+        break;
+    case 1:
+        _maxX = ILI9225_LCD_HEIGHT;
+        _maxY = ILI9225_LCD_WIDTH;
+        break;
+    case 2:
+        _maxX = ILI9225_LCD_WIDTH;
+        _maxY = ILI9225_LCD_HEIGHT;
+        break;
+    case 3:
+        _maxX = ILI9225_LCD_HEIGHT;
+        _maxY = ILI9225_LCD_WIDTH;
+        break;
+    }
+}
+
+
+uint8_t TFT22_ILI9225::getOrientation() {
+    return _orientation;
+}
+
+
+void TFT22_ILI9225::drawRectangle(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t color) {
+    startWrite();
+    drawLine(x1, y1, x1, y2, color);
+    drawLine(x1, y1, x2, y1, color);
+    drawLine(x1, y2, x2, y2, color);
+    drawLine(x2, y1, x2, y2, color);
+    endWrite();
+}
+
+
+void TFT22_ILI9225::fillRectangle(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t color) {
+
+    _setWindow(x1, y1, x2, y2);
+
+    startWrite();
+    for(uint16_t t=(y2 - y1 + 1) * (x2 - x1 + 1); t > 0; t--)
+        _writeData16(color);
+    endWrite();
+    _resetWindow();
+}
+
+
+void TFT22_ILI9225::drawCircle(uint16_t x0, uint16_t y0, uint16_t r, uint16_t color) {
+
+    int16_t f = 1 - r;
+    int16_t ddF_x = 1;
+    int16_t ddF_y = -2 * r;
+    int16_t x = 0;
+    int16_t y = r;
+
+    startWrite();
+
+    drawPixel(x0, y0 + r, color);
+    drawPixel(x0, y0-  r, color);
+    drawPixel(x0 + r, y0, color);
+    drawPixel(x0 - r, y0, color);
+
+    while (x<y) {
+        if (f >= 0) {
+            y--;
+            ddF_y += 2;
+            f += ddF_y;
+        }
+        x++;
+        ddF_x += 2;
+        f += ddF_x;
+
+        drawPixel(x0 + x, y0 + y, color);
+        drawPixel(x0 - x, y0 + y, color);
+        drawPixel(x0 + x, y0 - y, color);
+        drawPixel(x0 - x, y0 - y, color);
+        drawPixel(x0 + y, y0 + x, color);
+        drawPixel(x0 - y, y0 + x, color);
+        drawPixel(x0 + y, y0 - x, color);
+        drawPixel(x0 - y, y0 - x, color);
+    }
+    endWrite();
+}
+
+
+void TFT22_ILI9225::fillCircle(uint8_t x0, uint8_t y0, uint8_t radius, uint16_t color) {
+
+    int16_t f = 1 - radius;
+    int16_t ddF_x = 1;
+    int16_t ddF_y = -2 * radius;
+    int16_t x = 0;
+    int16_t y = radius;
+
+    startWrite();
+    while (x<y) {
+        if (f >= 0) {
+            y--;
+            ddF_y += 2;
+            f += ddF_y;
+        }
+        x++;
+        ddF_x += 2;
+        f += ddF_x;
+
+        drawLine(x0 + x, y0 + y, x0 - x, y0 + y, color); // bottom
+        drawLine(x0 + x, y0 - y, x0 - x, y0 - y, color); // top
+        drawLine(x0 + y, y0 - x, x0 + y, y0 + x, color); // right
+        drawLine(x0 - y, y0 - x, x0 - y, y0 + x, color); // left
+    }
+    endWrite();
+    fillRectangle(x0-x, y0-y, x0+x, y0+y, color);
+}
+
+
+void TFT22_ILI9225::drawLine(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t color) {
+
+    // Classic Bresenham algorithm
+    int16_t steep = abs((int16_t)(y2 - y1)) > abs((int16_t)(x2 - x1));
+
+    int16_t dx, dy;
+
+    if (steep) {
+        _swap(x1, y1);
+        _swap(x2, y2);
+    }
+
+    if (x1 > x2) {
+        _swap(x1, x2);
+        _swap(y1, y2);
+    }
+
+    dx = x2 - x1;
+    dy = abs((int16_t)(y2 - y1));
+
+    int16_t err = dx / 2;
+    int16_t ystep;
+
+    if (y1 < y2) ystep = 1;
+    else ystep = -1;
+
+    startWrite();
+    for (; x1<=x2; x1++) {
+        if (steep) drawPixel(y1, x1, color);
+        else       drawPixel(x1, y1, color);
+
+        err -= dy;
+        if (err < 0) {
+            y1 += ystep;
+            err += dx;
+        }
+    }
+    endWrite();
+}
+
+
+void TFT22_ILI9225::drawPixel(uint16_t x1, uint16_t y1, uint16_t color) {
+
+    if((x1 >= _maxX) || (y1 >= _maxY)) return;
+/*
+    _setWindow(x1, y1, x1+1, y1+1);
+    _orientCoordinates(x1, y1);
+    startWrite();
+    //_writeData(color >> 8, color);
+    _writeData16(color);
+    endWrite();
+*/
+    _orientCoordinates(x1, y1);
+    startWrite();
+    _writeRegister(ILI9225_RAM_ADDR_SET1,x1);
+    _writeRegister(ILI9225_RAM_ADDR_SET2,y1);
+    _writeRegister(ILI9225_GRAM_DATA_REG,color);
+    
+    endWrite();
+
+
+
+}
+
+
+uint16_t TFT22_ILI9225::maxX() {
+    return _maxX;
+}
+
+
+uint16_t TFT22_ILI9225::maxY() {
+    return _maxY;
+}
+
+
+uint16_t TFT22_ILI9225::setColor(uint8_t red8, uint8_t green8, uint8_t blue8) {
+    // rgb16 = red5 green6 blue5
+    return (red8 >> 3) << 11 | (green8 >> 2) << 5 | (blue8 >> 3);
+}
+
+
+void TFT22_ILI9225::splitColor(uint16_t rgb, uint8_t &red, uint8_t &green, uint8_t &blue) {
+    // rgb16 = red5 green6 blue5
+    red   = (rgb & 0b1111100000000000) >> 11 << 3;
+    green = (rgb & 0b0000011111100000) >>  5 << 2;
+    blue  = (rgb & 0b0000000000011111)       << 3;
+}
+
+
+void TFT22_ILI9225::_swap(uint16_t &a, uint16_t &b) {
+    uint16_t w = a;
+    a = b;
+    b = w;
+}
+
+// Utilities
+/*void TFT22_ILI9225::_writeCommand16(uint16_t command) {
+# ifdef HSPI_WRITE16
+    SPI_DC_LOW();
+    SPI_CS_LOW();
+    HSPI_WRITE16(command);
+    SPI_CS_HIGH();
+#else 
+    _spiWriteCommand(command >> 8);
+    _spiWriteCommand(0x00ff & command);
+#endif
+}
+
+void TFT22_ILI9225::_writeData16(uint16_t data) {
+# ifdef HSPI_WRITE16
+    SPI_DC_HIGH();
+    SPI_CS_LOW();
+    HSPI_WRITE16(data);
+    SPI_CS_HIGH();
+#else 
+    _spiWriteData(data >> 8);
+    _spiWriteData(0x00ff & data);
+#endif
+}
+*/
+void TFT22_ILI9225::_writeCommand16(uint16_t command) {
+    SPI_DC_LOW();
+    SPI_CS_LOW();
+    if ( _clk < 0 ) {
+        # ifdef HSPI_WRITE16
+        HSPI_WRITE16(command);
+    #else 
+        HSPI_WRITE(command >> 8);
+        HSPI_WRITE(0x00ff & command);
+    #endif
+    } else {
+        // Fast SPI bitbang swiped from LPD8806 library
+        for(uint16_t bit = 0x8000; bit; bit >>= 1){
+            if((command) & bit){
+                SSPI_MOSI_HIGH();
+            } else {
+                SSPI_MOSI_LOW();
+            }
+            SSPI_SCK_HIGH();
+            SSPI_SCK_LOW();
+        }
+    }
+    SPI_CS_HIGH();
+}
+
+void TFT22_ILI9225::_writeData16(uint16_t data) {
+    SPI_DC_HIGH();
+    SPI_CS_LOW();
+    if ( _clk < 0 ) {
+        # ifdef HSPI_WRITE16
+            HSPI_WRITE16(data);
+        #else 
+            HSPI_WRITE(data >> 8);
+            HSPI_WRITE(0x00ff & data);
+        #endif
+    } else {
+        // Fast SPI bitbang swiped from LPD8806 library
+        for(uint16_t bit = 0x8000; bit; bit >>= 1){
+            if((data) & bit){
+                SSPI_MOSI_HIGH();
+            } else {
+                SSPI_MOSI_LOW();
+            }
+            SSPI_SCK_HIGH();
+            SSPI_SCK_LOW();
+        }
+    }
+    SPI_CS_HIGH();
+}
+/*void TFT22_ILI9225::_writeData(uint8_t HI, uint8_t LO) {
+    _spiWriteData(HI);
+    _spiWriteData(LO);
+}
+
+void TFT22_ILI9225::_writeCommand(uint8_t HI, uint8_t LO) {
+    _spiWriteCommand(HI);
+    _spiWriteCommand(LO);
+}*/
+
+
+void TFT22_ILI9225::_writeRegister(uint16_t reg, uint16_t data) {
+    _writeCommand16(reg);
+    _writeData16(data);
+}
+
+
+void TFT22_ILI9225::drawTriangle(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t x3, uint16_t y3, uint16_t color) {
+    startWrite();
+    drawLine(x1, y1, x2, y2, color);
+    drawLine(x2, y2, x3, y3, color);
+    drawLine(x3, y3, x1, y1, color);
+    endWrite();
+}
+
+
+void TFT22_ILI9225::fillTriangle(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t x3, uint16_t y3, uint16_t color) {
+
+    uint16_t a, b, y, last;
+
+    // Sort coordinates by Y order (y3 >= y2 >= y1)
+    if (y1 > y2) {
+        _swap(y1, y2); _swap(x1, x2);
+    }
+    if (y2 > y3) {
+        _swap(y3, y2); _swap(x3, x2);
+    }
+    if (y1 > y2) {
+        _swap(y1, y2); _swap(x1, x2);
+    }
+
+    startWrite();
+    if (y1 == y3) { // Handle awkward all-on-same-line case as its own thing
+        a = b = x1;
+        if (x2 < a)      a = x2;
+        else if (x2 > b) b = x2;
+        if (x3 < a)      a = x3;
+        else if (x3 > b) b = x3;
+            drawLine(a, y1, b, y1, color);
+        return;
+    }
+
+    int16_t dx11 = x2 - x1,
+            dy11 = y2 - y1,
+            dx12 = x3 - x1,
+            dy12 = y3 - y1,
+            dx22 = x3 - x2,
+            dy22 = y3 - y2;
+    int32_t sa   = 0,
+            sb   = 0;
+
+    // For upper part of triangle, find scanline crossings for segments
+    // 0-1 and 0-2.  If y2=y3 (flat-bottomed triangle), the scanline y2
+    // is included here (and second loop will be skipped, avoiding a /0
+    // error there), otherwise scanline y2 is skipped here and handled
+    // in the second loop...which also avoids a /0 error here if y1=y2
+    // (flat-topped triangle).
+    if (y2 == y3) last = y2;   // Include y2 scanline
+    else          last = y2 - 1; // Skip it
+
+    for (y = y1; y <= last; y++) {
+        a   = x1 + sa / dy11;
+        b   = x1 + sb / dy12;
+        sa += dx11;
+        sb += dx12;
+        /* longhand:
+        a = x1 + (x2 - x1) * (y - y1) / (y2 - y1);
+        b = x1 + (x3 - x1) * (y - y1) / (y3 - y1);
+        */
+        if (a > b) _swap(a,b);
+        drawLine(a, y, b, y, color);
+    }
+
+    // For lower part of triangle, find scanline crossings for segments
+    // 0-2 and 1-2.  This loop is skipped if y2=y3.
+    sa = dx22 * (y - y2);
+    sb = dx12 * (y - y1);
+    for (; y<=y3; y++) {
+        a   = x2 + sa / dy22;
+        b   = x1 + sb / dy12;
+        sa += dx22;
+        sb += dx12;
+        /* longhand:
+        a = x2 + (x3 - x2) * (y - y2) / (y3 - y2);
+        b = x1 + (x3 - x1) * (y - y1) / (y3 - y1);
+        */
+        if (a > b) _swap(a,b);
+            drawLine(a, y, b, y, color);
+    }
+    endWrite();
+}
+
+
+void TFT22_ILI9225::setBackgroundColor(uint16_t color) {
+    _bgColor = color;
+}
+
+void TFT22_ILI9225::setFont(uint8_t* font, bool monoSp) {
+
+    cfont.font     = font;
+    cfont.width    = readFontByte(0);
+    cfont.height   = readFontByte(1);
+    cfont.offset   = readFontByte(2);
+    cfont.numchars = readFontByte(3);
+    cfont.nbrows   = cfont.height / 8;
+    cfont.monoSp   = monoSp;
+
+    if (cfont.height % 8) cfont.nbrows++;  // Set number of bytes used by height of font in multiples of 8
+}
+
+_currentFont TFT22_ILI9225::getFont() {
+    return cfont;
+}
+
+uint16_t TFT22_ILI9225::drawText(uint16_t x, uint16_t y, STRING s, uint16_t color) {
+
+    uint16_t currx = x;
+
+    // Print every character in string
+    #ifdef USE_STRING_CLASS
+    for (uint8_t k = 0; k < s.length(); k++) {
+        currx += drawChar(currx, y, s.charAt(k), color) + 1;
+    }
+    #else
+    for (uint8_t k = 0; k < strlen(s); k++) {
+        currx += drawChar(currx, y, s[k], color) + 1;
+    }
+    #endif
+    return currx;
+}
+
+uint16_t TFT22_ILI9225::getTextWidth( STRING s ) {
+
+    uint16_t width = 0;
+    // Count every character in string ( +1 for spacing )
+    #ifdef USE_STRING_CLASS
+    for (uint8_t k = 0; k < s.length(); k++) {
+        width += getCharWidth(s.charAt(k) ) + 1;
+    }
+    #else
+    for (uint8_t k = 0; k < strlen(s); k++) {
+        width += getCharWidth(s[k]) + 1;
+    }
+    #endif
+    return width;
+}
+
+uint16_t TFT22_ILI9225::drawChar(uint16_t x, uint16_t y, uint16_t ch, uint16_t color) {
+
+    uint8_t charData, charWidth;
+    uint8_t h, i, j;
+    uint16_t charOffset;
+    bool fastMode;
+    charOffset = (cfont.width * cfont.nbrows) + 1;  // bytes used by each character
+    charOffset = (charOffset * (ch - cfont.offset)) + FONT_HEADER_SIZE;  // char offset (add 4 for font header)
+    if ( cfont.monoSp ) charWidth = cfont.width;      // monospaced: get char width from font
+    else                charWidth  = readFontByte(charOffset);  // get chracter width from 1st byte
+    charOffset++;  // increment pointer to first character data byte
+
+    startWrite();
+    
+    // use autoincrement/decrement feature, if character fits completely on screen
+    fastMode = ( (x+charWidth+1) < _maxX && (y+cfont.height-1) < _maxY ) ;
+    
+    if ( fastMode )_setWindow( x,y,x+charWidth+1, y+cfont.height-1 );  // set character Window
+
+    for (i = 0; i <= charWidth; i++) {  // each font "column" (+1 blank column for spacing)
+        h = 0;  // keep track of char height
+        for (j = 0; j < cfont.nbrows; j++)     {  // each column byte
+            if (i == charWidth) charData = (uint8_t)0x0; // Insert blank column
+            else                charData = readFontByte(charOffset);
+            charOffset++;
+            
+            // Process every row in font character
+            for (uint8_t k = 0; k < 8; k++) {
+                if (h >= cfont.height ) break;  // No need to process excess bits
+                if (fastMode ) _writeData16( bitRead(charData, k)?color:_bgColor );
+                else drawPixel( x + i, y + (j * 8) + k, bitRead(charData, k)?color:_bgColor );
+                h++;
+            }
+        }
+    }
+    endWrite();
+    _resetWindow();
+    return charWidth;
+}
+
+uint16_t TFT22_ILI9225::getCharWidth(uint16_t ch) {
+    uint16_t charOffset;
+    charOffset = (cfont.width * cfont.nbrows) + 1;  // bytes used by each character
+    charOffset = (charOffset * (ch - cfont.offset)) + FONT_HEADER_SIZE;  // char offset (add 4 for font header)
+
+    return readFontByte(charOffset);  // get font width from 1st byte
+}
+
+// Draw a 1-bit image (bitmap) at the specified (x,y) position from the
+// provided bitmap buffer (must be PROGMEM memory) using the specified
+// foreground color (unset bits are transparent).
+void TFT22_ILI9225::drawBitmap(int16_t x, int16_t y,
+const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) {
+    _drawBitmap( x,  y, bitmap,  w,  h, color,  0, true, true, false );
+}
+
+// Draw a 1-bit image (bitmap) at the specified (x,y) position from the
+// provided bitmap buffer (must be PROGMEM memory) using the specified
+// foreground (for set bits) and background (for clear bits) colors.
+void TFT22_ILI9225::drawBitmap(int16_t x, int16_t y,
+const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg) {
+    _drawBitmap( x,  y, bitmap,  w,  h, color,  bg, false, true, false );
+}
+
+// drawBitmap() variant for RAM-resident (not PROGMEM) bitmaps.
+void TFT22_ILI9225::drawBitmap(int16_t x, int16_t y,
+uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) {
+    _drawBitmap( x,  y, bitmap,  w,  h, color,  0, true, false, false );
+}
+
+// drawBitmap() variant w/background for RAM-resident (not PROGMEM) bitmaps.
+void TFT22_ILI9225::drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg) {
+    _drawBitmap( x,  y, bitmap,  w,  h, color,  bg, false, false, false );
+}
+
+//Draw XBitMap Files (*.xbm), exported from GIMP,
+//Usage: Export from GIMP to *.xbm, rename *.xbm to *.c and open in editor.
+//C Array can be directly used with this function
+void TFT22_ILI9225::drawXBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) {
+    _drawBitmap( x,  y, bitmap,  w,  h, color,  0, true, true, true );
+}
+
+void TFT22_ILI9225::drawXBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg) {
+    _drawBitmap( x,  y, bitmap,  w,  h, color,  bg, false, true, true );
+}
+
+
+// internal function for drawing bitmaps with/without transparent bg, or from ram or progmem
+void TFT22_ILI9225::_drawBitmap(int16_t x, int16_t y,
+const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg, bool transparent, bool progmem,bool Xbit) {
+    bool noAutoInc = false;     // Flag set when transparent pixel was 'written'
+    int16_t i, j, byteWidth = (w + 7) / 8;
+    int16_t wx0,wy0,wx1,wy1,wh;//,ww;  // Window-position and size
+    uint8_t byte=0, maskBit;
+    maskBit = Xbit? 0x01:0x80;
+    // adjust window hight/width to displaydimensions
+    DB_PRINT( "DrawBitmap.. maxX=%d, maxY=%d", _maxX,_maxY );
+    wx0 = x<0?0:x;
+    wy0 = y<0?0:y;
+    wx1 = (x+w>_maxX?_maxX:x+w)-1;
+    wy1 = (y+h>_maxY?_maxY:y+h)-1;
+    wh  = wy1-wy0 +1;
+    //ww  = wx1-wx0 +1;
+    _setWindow( wx0,wy0,wx1,wy1,L2R_TopDown);
+    startWrite();
+    for (j = y>=0?0:-y; j < (y>=0?0:-y)+wh; j++) {
+        for (i = 0; i < w; i++ ) {
+            if (i & 7) { if ( Xbit ) byte >>=1; else byte <<= 1; }
+            else {  if ( progmem ) byte   = pgm_read_byte(bitmap + j * byteWidth + i / 8);
+                    else      byte   = bitmap[j * byteWidth + i / 8];
+            }
+            if ( x+i >= wx0 && x+i <= wx1 ) {
+                // write only if pixel is within window
+                if (byte & maskBit) {
+                    if (noAutoInc) {
+                        //there was a transparent area, set pixelkoordinates again
+                        drawPixel(x + i, y + j, color);
+                        noAutoInc = false;
+                    }
+                    else  { 
+                        _writeData16(color);
+                    }
+                }
+                else  {
+                    if (transparent) noAutoInc = true; // no autoincrement in transparent area!
+                    else _writeData16( bg);
+                }
+            }
+        }
+    }
+    endWrite();
+}
+
+
+
+//Draw XBitMap Files (*.xbm), exported from GIMP,
+//Usage: Export from GIMP to *.xbm, rename *.xbm to *.c and open in editor.
+//C Array can be directly used with this function
+/*void TFT22_ILI9225::drawXBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color) {
+
+    int16_t i, j, byteWidth = (w + 7) / 8;
+    uint8_t byte;
+
+    startWrite();
+    for (j = 0; j < h; j++) {
+        for (i = 0; i < w; i++ ) {
+            if (i & 7) byte >>= 1;
+            else      byte   = pgm_read_byte(bitmap + j * byteWidth + i / 8);
+            if (byte & 0x01) drawPixel(x + i, y + j, color);
+        }
+    }
+    endWrite();
+}
+*/
+
+//High speed color bitmap
+void TFT22_ILI9225::drawBitmap(uint16_t x1, uint16_t y1, 
+const uint16_t** bitmap, int16_t w, int16_t h) {
+    _setWindow(x1, y1, x1+w-1, y1+h-1,L2R_TopDown);
+    startWrite();
+    SPI_DC_HIGH();
+    SPI_CS_LOW();
+    for (uint16_t y = 0; y < h; y++) {
+        #ifdef HSPI_WRITE_PIXELS
+        if (_clk < 0) {
+            HSPI_WRITE_PIXELS(bitmap[y], w * sizeof(uint16_t));
+            continue;
+        }
+        #endif
+        for (uint16_t x = 0; x < w; x++) {
+            _spiWrite16(bitmap[y][x]);
+        }
+    }
+    SPI_CS_HIGH();
+    endWrite();
+}
+
+//High speed color bitmap
+void TFT22_ILI9225::drawBitmap(uint16_t x1, uint16_t y1, 
+uint16_t** bitmap, int16_t w, int16_t h) {
+    _setWindow(x1, y1, x1+w-1, y1+h-1,L2R_TopDown);
+    startWrite();
+    SPI_DC_HIGH();
+    SPI_CS_LOW();
+    for (uint16_t y = 0; y < h; y++) {
+        #ifdef HSPI_WRITE_PIXELS
+        if (_clk < 0) {
+            HSPI_WRITE_PIXELS(bitmap[y], w * sizeof(uint16_t));
+            continue;
+        }
+        #endif
+        for (uint16_t x = 0; x < w; x++) {
+            _spiWrite16(bitmap[y][x]);
+        }
+    }
+    SPI_CS_HIGH();
+    endWrite();
+}
+
+//1-D array High speed color bitmap
+void TFT22_ILI9225::drawBitmap(uint16_t x1, uint16_t y1, 
+const uint16_t* bitmap, int16_t w, int16_t h) {
+    _setWindow(x1, y1, x1+w-1, y1+h-1,L2R_TopDown);
+    startWrite();
+    SPI_DC_HIGH();
+    SPI_CS_LOW();
+    #ifdef HSPI_WRITE_PIXELS
+    if (_clk < 0) {
+        HSPI_WRITE_PIXELS(bitmap, w * h * sizeof(uint16_t));
+    } else
+    #endif
+    for (uint16_t i = 0; i < h * w; ++i) {
+        _spiWrite16(bitmap[i]);
+    }
+    SPI_CS_HIGH();
+    endWrite();
+}
+
+//1-D array High speed color bitmap
+void TFT22_ILI9225::drawBitmap(uint16_t x1, uint16_t y1, 
+uint16_t* bitmap, int16_t w, int16_t h) {
+    _setWindow(x1, y1, x1+w-1, y1+h-1,L2R_TopDown);
+    startWrite();
+    SPI_DC_HIGH();
+    SPI_CS_LOW();
+    #ifdef HSPI_WRITE_PIXELS
+    if (_clk < 0) {
+        HSPI_WRITE_PIXELS(bitmap, w * h * sizeof(uint16_t));
+    } else
+    #endif
+    for (uint16_t i = 0; i < h * w; ++i) {
+        _spiWrite16(bitmap[i]);
+    }
+    SPI_CS_HIGH();
+    endWrite();
+}
+
+void TFT22_ILI9225::startWrite(void){
+    if (writeFunctionLevel++ == 0) {
+        SPI_BEGIN_TRANSACTION();
+        SPI_CS_LOW();
+    }
+}
+
+
+void TFT22_ILI9225::endWrite(void){
+    if (--writeFunctionLevel == 0) {
+        SPI_CS_HIGH();
+        SPI_END_TRANSACTION();
+    }
+}
+
+
+// TEXT- AND CHARACTER-HANDLING FUNCTIONS ----------------------------------
+
+void TFT22_ILI9225::setGFXFont(const GFXfont *f) {
+    gfxFont = (GFXfont *)f;
+}
+
+
+// Draw a string
+void TFT22_ILI9225::drawGFXText(int16_t x, int16_t y, STRING s, uint16_t color) {
+
+    int16_t currx = x;
+
+    if(gfxFont) {
+        // Print every character in string
+        #ifdef USE_STRING_CLASS
+        for (uint8_t k = 0; k < s.length(); k++) {
+            currx += drawGFXChar(currx, y, s.charAt(k), color) + 1;
+        }
+        #else
+        for (uint8_t k = 0; k < strlen(s); k++) {
+            currx += drawGFXChar(currx, y, s[k], color) + 1;
+        }
+        #endif
+    }
+}
+
+
+// Draw a character
+uint16_t TFT22_ILI9225::drawGFXChar(int16_t x, int16_t y, unsigned char c, uint16_t color) {
+
+    c -= (uint8_t)pgm_read_byte(&gfxFont->first);
+    GFXglyph *glyph  = &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c]);
+    uint8_t  *bitmap = (uint8_t *)pgm_read_pointer(&gfxFont->bitmap);
+
+    uint16_t bo = pgm_read_word(&glyph->bitmapOffset);
+    uint8_t  w  = pgm_read_byte(&glyph->width),
+             h  = pgm_read_byte(&glyph->height),
+             xa = pgm_read_byte(&glyph->xAdvance);
+    int8_t   xo = pgm_read_byte(&glyph->xOffset),
+             yo = pgm_read_byte(&glyph->yOffset);
+    uint8_t  xx, yy, bits = 0, bit = 0;
+
+    // Add character clipping here one day
+
+    startWrite();
+    for(yy=0; yy<h; yy++) {
+        for(xx=0; xx<w; xx++) {
+            if(!(bit++ & 7)) {
+                bits = pgm_read_byte(&bitmap[bo++]);
+            }
+            if(bits & 0x80) {
+                drawPixel(x+xo+xx, y+yo+yy, color);
+            }
+            bits <<= 1;
+        }
+    }
+    endWrite();
+
+    return (uint16_t)xa;
+}
+
+// Write a character to a bitmap
+uint16_t TFT22_ILI9225::drawGFXcharBM(int16_t x, int16_t y, unsigned char c, uint16_t color, uint16_t *bm, int bmwd) {
+    c -= (uint8_t)pgm_read_byte(&gfxFont->first);
+    GFXglyph *glyph  = &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c]);
+    uint8_t  *bitmap = (uint8_t *)pgm_read_pointer(&gfxFont->bitmap);
+
+    uint16_t bo = pgm_read_word(&glyph->bitmapOffset);
+    uint8_t  w  = pgm_read_byte(&glyph->width),
+             h  = pgm_read_byte(&glyph->height),
+             xa = pgm_read_byte(&glyph->xAdvance);
+    int8_t   xo = pgm_read_byte(&glyph->xOffset),
+             yo = pgm_read_byte(&glyph->yOffset);
+    uint8_t  xx, yy, bits = 0, bit = 0;
+
+    for(yy=0; yy<h; yy++) {
+	if(y+yo+yy>=bmwd) continue;
+	if(y+yo+yy<0) continue;		// yo can be negative
+        for(xx=0; xx<w; xx++) {
+	    if(x+xo+xx>=bmwd) continue;
+            if(!(bit++ & 7)) {
+                bits = pgm_read_byte(&bitmap[bo++]);
+            }
+            if(bits & 0x80) {
+		bm[x+xo+xx + bmwd*(y+yo+yy)] = color;
+            }
+            bits <<= 1;
+        }
+    }
+
+    return (uint16_t)xa;
+}
+
+
+void TFT22_ILI9225::getGFXCharExtent(uint8_t c, int16_t *gw, int16_t *gh, int16_t *xa) {
+    uint8_t first = pgm_read_byte(&gfxFont->first),
+            last  = pgm_read_byte(&gfxFont->last);
+    // Char present in this font?
+    if((c >= first) && (c <= last)) {
+        GFXglyph *glyph = &(((GFXglyph *)pgm_read_pointer(&gfxFont->glyph))[c - first]);
+        *gw = pgm_read_byte(&glyph->width);
+        *gh = pgm_read_byte(&glyph->height);
+        *xa = pgm_read_byte(&glyph->xAdvance);
+        // int8_t  xo = pgm_read_byte(&glyph->xOffset),
+        //         yo = pgm_read_byte(&glyph->yOffset);
+    }
+}
+
+
+void TFT22_ILI9225::getGFXTextExtent(STRING str, int16_t x, int16_t y, int16_t *w, int16_t *h) {
+    *w  = *h = 0;
+    #ifdef USE_STRING_CLASS
+    for (uint8_t k = 0; k < str.length(); k++) {
+        uint8_t c = str.charAt(k);
+    #else
+    for (uint8_t k = 0; k < strlen(str); k++) {
+        uint8_t c = str[k];
+    #endif
+        int16_t gw, gh, xa;
+        getGFXCharExtent(c, &gw, &gh, &xa);
+        if(gh > *h) {
+            *h = gh;
+        }
+        *w += xa + 1;
+    }
+    if(*w>0) (*w)--;
+}
+
diff --git a/libraries/SondeLib/TFT22_ILI9225.h b/libraries/SondeLib/TFT22_ILI9225.h
new file mode 100755
index 0000000..9e049f7
--- /dev/null
+++ b/libraries/SondeLib/TFT22_ILI9225.h
@@ -0,0 +1,468 @@
+//        SPDX-License-Identifier:        GPL-3.0
+//      original source: https://github.com/Nkawu/TFT22_ILI9225
+
+#ifndef TFT22_ILI9225_h
+#define TFT22_ILI9225_h
+
+#ifdef __STM32F1__
+#define ARDUINO_STM32_FEATHER
+#define  PROGMEM
+// if 'SPI_CHANNEL' is not defined, 'SPI' is used, only valid for STM32F1
+//#define SPI_CHANNEL SPI_2
+#endif
+
+#define USE_STRING_CLASS
+
+#ifdef USE_STRING_CLASS
+    #define STRING String
+#else
+    #define STRING const char *
+#endif
+
+#if ARDUINO >= 100
+    #include "Arduino.h"
+#else
+    #include "WProgram.h"
+#endif
+#include <SPI.h>
+#include "gfxfont.h"
+
+#if defined(ARDUINO_STM32_FEATHER) || defined(ARDUINO_ARCH_STM32) || defined(ARDUINO_ARCH_STM32F1) || defined(STM32F1)
+typedef volatile uint32 RwReg;
+#endif
+#if defined(ARDUINO_FEATHER52)
+typedef volatile uint32_t RwReg;
+#endif
+
+/* ILI9225 screen size */
+#define ILI9225_LCD_WIDTH  176
+#define ILI9225_LCD_HEIGHT 220
+
+/* ILI9225 LCD Registers */
+#define ILI9225_DRIVER_OUTPUT_CTRL      (0x01u)  // Driver Output Control
+#define ILI9225_LCD_AC_DRIVING_CTRL     (0x02u)  // LCD AC Driving Control
+#define ILI9225_ENTRY_MODE              (0x03u)  // Entry Mode
+#define ILI9225_DISP_CTRL1              (0x07u)  // Display Control 1
+#define ILI9225_BLANK_PERIOD_CTRL1      (0x08u)  // Blank Period Control
+#define ILI9225_FRAME_CYCLE_CTRL        (0x0Bu)  // Frame Cycle Control
+#define ILI9225_INTERFACE_CTRL          (0x0Cu)  // Interface Control
+#define ILI9225_OSC_CTRL                (0x0Fu)  // Osc Control
+#define ILI9225_POWER_CTRL1             (0x10u)  // Power Control 1
+#define ILI9225_POWER_CTRL2             (0x11u)  // Power Control 2
+#define ILI9225_POWER_CTRL3             (0x12u)  // Power Control 3
+#define ILI9225_POWER_CTRL4             (0x13u)  // Power Control 4
+#define ILI9225_POWER_CTRL5             (0x14u)  // Power Control 5
+#define ILI9225_VCI_RECYCLING           (0x15u)  // VCI Recycling
+#define ILI9225_RAM_ADDR_SET1           (0x20u)  // Horizontal GRAM Address Set
+#define ILI9225_RAM_ADDR_SET2           (0x21u)  // Vertical GRAM Address Set
+#define ILI9225_GRAM_DATA_REG           (0x22u)  // GRAM Data Register
+#define ILI9225_GATE_SCAN_CTRL          (0x30u)  // Gate Scan Control Register
+#define ILI9225_VERTICAL_SCROLL_CTRL1   (0x31u)  // Vertical Scroll Control 1 Register
+#define ILI9225_VERTICAL_SCROLL_CTRL2   (0x32u)  // Vertical Scroll Control 2 Register
+#define ILI9225_VERTICAL_SCROLL_CTRL3   (0x33u)  // Vertical Scroll Control 3 Register
+#define ILI9225_PARTIAL_DRIVING_POS1    (0x34u)  // Partial Driving Position 1 Register
+#define ILI9225_PARTIAL_DRIVING_POS2    (0x35u)  // Partial Driving Position 2 Register
+#define ILI9225_HORIZONTAL_WINDOW_ADDR1 (0x36u)  // Horizontal Address Start Position
+#define ILI9225_HORIZONTAL_WINDOW_ADDR2 (0x37u)  // Horizontal Address End Position
+#define ILI9225_VERTICAL_WINDOW_ADDR1   (0x38u)  // Vertical Address Start Position
+#define ILI9225_VERTICAL_WINDOW_ADDR2   (0x39u)  // Vertical Address End Position
+#define ILI9225_GAMMA_CTRL1             (0x50u)  // Gamma Control 1
+#define ILI9225_GAMMA_CTRL2             (0x51u)  // Gamma Control 2
+#define ILI9225_GAMMA_CTRL3             (0x52u)  // Gamma Control 3
+#define ILI9225_GAMMA_CTRL4             (0x53u)  // Gamma Control 4
+#define ILI9225_GAMMA_CTRL5             (0x54u)  // Gamma Control 5
+#define ILI9225_GAMMA_CTRL6             (0x55u)  // Gamma Control 6
+#define ILI9225_GAMMA_CTRL7             (0x56u)  // Gamma Control 7
+#define ILI9225_GAMMA_CTRL8             (0x57u)  // Gamma Control 8
+#define ILI9225_GAMMA_CTRL9             (0x58u)  // Gamma Control 9
+#define ILI9225_GAMMA_CTRL10            (0x59u)  // Gamma Control 10
+
+#define ILI9225C_INVOFF  0x20
+#define ILI9225C_INVON   0x21
+
+// autoincrement modes (register ILI9225_ENTRY_MODE, bit 5..3 )
+enum autoIncMode_t { R2L_BottomUp, BottomUp_R2L, L2R_BottomUp, BottomUp_L2R, R2L_TopDown, TopDown_R2L, L2R_TopDown, TopDown_L2R };
+
+/* RGB 16-bit color table definition (RG565) */
+#define COLOR_BLACK          0x0000      /*   0,   0,   0 */
+#define COLOR_WHITE          0xFFFF      /* 255, 255, 255 */
+#define COLOR_BLUE           0x001F      /*   0,   0, 255 */
+#define COLOR_GREEN          0x07E0      /*   0, 255,   0 */
+#define COLOR_RED            0xF800      /* 255,   0,   0 */
+#define COLOR_NAVY           0x000F      /*   0,   0, 128 */
+#define COLOR_DARKBLUE       0x0011      /*   0,   0, 139 */
+#define COLOR_DARKGREEN      0x03E0      /*   0, 128,   0 */
+#define COLOR_DARKCYAN       0x03EF      /*   0, 128, 128 */
+#define COLOR_CYAN           0x07FF      /*   0, 255, 255 */
+#define COLOR_TURQUOISE      0x471A      /*  64, 224, 208 */
+#define COLOR_INDIGO         0x4810      /*  75,   0, 130 */
+#define COLOR_DARKRED        0x8000      /* 128,   0,   0 */
+#define COLOR_OLIVE          0x7BE0      /* 128, 128,   0 */
+#define COLOR_GRAY           0x8410      /* 128, 128, 128 */
+#define COLOR_GREY           0x8410      /* 128, 128, 128 */
+#define COLOR_SKYBLUE        0x867D      /* 135, 206, 235 */
+#define COLOR_BLUEVIOLET     0x895C      /* 138,  43, 226 */
+#define COLOR_LIGHTGREEN     0x9772      /* 144, 238, 144 */
+#define COLOR_DARKVIOLET     0x901A      /* 148,   0, 211 */
+#define COLOR_YELLOWGREEN    0x9E66      /* 154, 205,  50 */
+#define COLOR_BROWN          0xA145      /* 165,  42,  42 */
+#define COLOR_DARKGRAY       0x7BEF      /* 128, 128, 128 */
+#define COLOR_DARKGREY       0x7BEF      /* 128, 128, 128 */
+#define COLOR_SIENNA         0xA285      /* 160,  82,  45 */
+#define COLOR_LIGHTBLUE      0xAEDC      /* 172, 216, 230 */
+#define COLOR_GREENYELLOW    0xAFE5      /* 173, 255,  47 */
+#define COLOR_SILVER         0xC618      /* 192, 192, 192 */
+#define COLOR_LIGHTGRAY      0xC618      /* 192, 192, 192 */
+#define COLOR_LIGHTGREY      0xC618      /* 192, 192, 192 */
+#define COLOR_LIGHTCYAN      0xE7FF      /* 224, 255, 255 */
+#define COLOR_VIOLET         0xEC1D      /* 238, 130, 238 */
+#define COLOR_AZUR           0xF7FF      /* 240, 255, 255 */
+#define COLOR_BEIGE          0xF7BB      /* 245, 245, 220 */
+#define COLOR_MAGENTA        0xF81F      /* 255,   0, 255 */
+#define COLOR_TOMATO         0xFB08      /* 255,  99,  71 */
+#define COLOR_GOLD           0xFEA0      /* 255, 215,   0 */
+#define COLOR_ORANGE         0xFD20      /* 255, 165,   0 */
+#define COLOR_SNOW           0xFFDF      /* 255, 250, 250 */
+#define COLOR_YELLOW         0xFFE0      /* 255, 255,   0 */
+
+
+/* Font defines */
+#define FONT_HEADER_SIZE 4 // 1: pixel width of 1 font character, 2: pixel height, 
+#define readFontByte(x) pgm_read_byte(&cfont.font[x])  
+
+extern uint8_t Terminal6x8[];
+extern uint8_t Terminal11x16[];
+extern uint8_t Terminal12x16[];
+extern uint8_t Trebuchet_MS16x21[];
+
+struct _currentFont
+{
+    uint8_t* font;
+    uint8_t width;
+    uint8_t height;
+    uint8_t offset;
+    uint8_t numchars;
+    uint8_t nbrows;
+    bool    monoSp;
+};
+#define MONOSPACE   1
+
+#if defined (ARDUINO_STM32_FEATHER)
+    #undef USE_FAST_PINIO
+#elif defined (__AVR__) || defined(TEENSYDUINO) || defined(ESP8266) || defined(__arm__)
+    #define USE_FAST_PINIO
+#endif
+
+/// Main and core class
+class TFT22_ILI9225 {
+
+    public:
+
+        TFT22_ILI9225(int8_t RST, int8_t RS, int8_t CS, int8_t SDI, int8_t CLK, int8_t LED);
+        TFT22_ILI9225(int8_t RST, int8_t RS, int8_t CS, int8_t LED);
+        TFT22_ILI9225(int8_t RST, int8_t RS, int8_t CS, int8_t SDI, int8_t CLK, int8_t LED, uint8_t brightness);
+        TFT22_ILI9225(int8_t RST, int8_t RS, int8_t CS, int8_t LED, uint8_t brightness);
+
+        /// Initialization
+#ifndef ESP32
+        void begin(void);
+#else
+        void begin(SPIClass &spi=SPI);
+#endif
+
+        /// Clear the screen
+        void clear(void); 
+
+        /// Invert screen
+        /// @param     flag true to invert, false for normal screen
+        void invert(boolean flag);
+
+        /// Switch backlight on or off
+        /// @param     flag true=on, false=off
+        void setBacklight(boolean flag); 
+
+        /// Set backlight brightness
+        /// @param     brightness sets backlight brightness 0-255
+        void setBacklightBrightness(uint8_t brightness); 
+
+        /// Switch display on or off
+        /// @param     flag true=on, false=off
+        void setDisplay(boolean flag);  
+
+        /// Set orientation
+        /// @param     orientation orientation, 0=portrait, 1=right rotated landscape, 2=reverse portrait, 3=left rotated landscape
+        void setOrientation(uint8_t orientation);  
+
+        /// Get orientation
+        /// @return    orientation orientation, 0=portrait, 1=right rotated landscape, 2=reverse portrait, 3=left rotated landscape
+        uint8_t getOrientation(void); 
+
+        /// Font size, x-axis
+        /// @return    horizontal size of current font, in pixels
+        // uint8_t fontX(void);
+
+        /// Font size, y-axis
+        /// @return    vertical size of current font, in pixels
+        // uint8_t fontY(void); 
+
+        /// Screen size, x-axis
+        /// @return   horizontal size of the screen, in pixels
+        /// @note     240 means 240 pixels and thus 0..239 coordinates (decimal)
+        uint16_t maxX(void);
+
+        /// Screen size, y-axis
+        /// @return   vertical size of the screen, in pixels
+        /// @note     220 means 220 pixels and thus 0..219 coordinates (decimal)
+        uint16_t maxY(void);
+
+        /// Draw circle
+        /// @param    x0 center, point coordinate, x-axis
+        /// @param    y0 center, point coordinate, y-axis
+        /// @param    radius radius
+        /// @param    color 16-bit color
+        void drawCircle(uint16_t x0, uint16_t y0, uint16_t radius, uint16_t color);  
+
+        /// Draw solid circle
+        /// @param    x0 center, point coordinate, x-axis
+        /// @param    y0 center, point coordinate, y-axis
+        /// @param    radius radius
+        /// @param    color 16-bit color
+        void fillCircle(uint8_t x0, uint8_t y0, uint8_t radius, uint16_t color); 
+
+        /// Set background color
+        /// @param    color background color, default=black
+        void setBackgroundColor(uint16_t color = COLOR_BLACK);  
+
+        /// Draw line, rectangle coordinates
+        /// @param    x1 start point coordinate, x-axis
+        /// @param    y1 start point coordinate, y-axis
+        /// @param    x2 end point coordinate, x-axis
+        /// @param    y2 end point coordinate, y-axis
+        /// @param    color 16-bit color
+        void drawLine(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t color); 
+
+        /// Draw rectangle, rectangle coordinates
+        /// @param    x1 top left coordinate, x-axis
+        /// @param    y1 top left coordinate, y-axis
+        /// @param    x2 bottom right coordinate, x-axis
+        /// @param    y2 bottom right coordinate, y-axis
+        /// @param    color 16-bit color
+        void drawRectangle(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t color); 
+
+        /// Draw solid rectangle, rectangle coordinates
+        /// @param    x1 top left coordinate, x-axis
+        /// @param    y1 top left coordinate, y-axis
+        /// @param    x2 bottom right coordinate, x-axis
+        /// @param    y2 bottom right coordinate, y-axis
+        /// @param    color 16-bit color
+        void fillRectangle(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t color);
+
+        /// Draw pixel
+        /// @param    x1 point coordinate, x-axis
+        /// @param    y1 point coordinate, y-axis
+        /// @param    color 16-bit color
+        void drawPixel(uint16_t x1, uint16_t y1, uint16_t color);  
+
+        /// Draw ASCII Text (pixel coordinates)
+        /// @param    x point coordinate, x-axis
+        /// @param    y point coordinate, y-axis
+        /// @param    s text string
+        /// @param    color 16-bit color, default=white
+        /// @return   x-position behind text
+        uint16_t  drawText(uint16_t x, uint16_t y, STRING s, uint16_t color = COLOR_WHITE);
+        
+        /// width of an ASCII Text (pixel )
+        /// @param    s text string
+        uint16_t getTextWidth( STRING s ) ;
+        
+        /// Calculate 16-bit color from 8-bit Red-Green-Blue components
+        /// @param    red red component, 0x00..0xff
+        /// @param    green green component, 0x00..0xff
+        /// @param    blue blue component, 0x00..0xff
+        /// @return   16-bit color
+        uint16_t setColor(uint8_t red, uint8_t green, uint8_t blue);
+
+        /// Calculate 8-bit Red-Green-Blue components from 16-bit color
+        /// @param    rgb 16-bit color
+        /// @param    red red component, 0x00..0xff
+        /// @param    green green component, 0x00..0xff
+        /// @param    blue blue component, 0x00..0xff
+        void splitColor(uint16_t rgb, uint8_t &red, uint8_t &green, uint8_t &blue);
+
+        /// Draw triangle, triangle coordinates
+        /// @param    x1 corner 1 coordinate, x-axis
+        /// @param    y1 corner 1 coordinate, y-axis
+        /// @param    x2 corner 2 coordinate, x-axis
+        /// @param    y2 corner 2 coordinate, y-axis
+        /// @param    x3 corner 3 coordinate, x-axis
+        /// @param    y3 corner 3 coordinate, y-axis
+        /// @param    color 16-bit color
+        void drawTriangle(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t x3, uint16_t y3, uint16_t color); 
+
+        /// Draw solid triangle, triangle coordinates
+        /// @param    x1 corner 1 coordinate, x-axis
+        /// @param    y1 corner 1 coordinate, y-axis
+        /// @param    x2 corner 2 coordinate, x-axis
+        /// @param    y2 corner 2 coordinate, y-axis
+        /// @param    x3 corner 3 coordinate, x-axis
+        /// @param    y3 corner 3 coordinate, y-axis
+        /// @param    color 16-bit color
+        void fillTriangle(uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t x3, uint16_t y3, uint16_t color);
+
+        /// Set current font
+        /// @param    font Font name
+        void setFont(uint8_t* font, bool monoSp=false ); // default = proportional
+        
+        /// Get current font
+        _currentFont getFont();
+        
+        /// Draw single character (pixel coordinates)
+        /// @param    x point coordinate, x-axis
+        /// @param    y point coordinate, y-axis
+        /// @param    ch ASCII character
+        /// @param    color 16-bit color, default=white
+        /// @return   width of character in display pixels
+        uint16_t drawChar(uint16_t x, uint16_t y, uint16_t ch, uint16_t color = COLOR_WHITE);
+
+        /// width of an ASCII character (pixel )
+        /// @param    ch ASCII character
+        uint16_t getCharWidth( uint16_t ch ) ;
+        
+        /// Draw bitmap
+        /// @param    x point coordinate, x-axis
+        /// @param    y point coordinate, y-axis
+        /// @param    bitmap 
+        /// @param    w width
+        /// @param    h height
+        /// @param    color 16-bit color, default=white
+        /// @param    bg 16-bit color, background
+        void drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color);
+        void drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg);
+        void drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h, uint16_t color);
+        void drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg);
+
+        void drawXBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color);
+        void drawXBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg);
+        
+        /// Draw bitmap
+        /// @param    x point coordinate, x-axis
+        /// @param    y point coordinate, y-axis
+        /// @param    bitmap, 2D 16bit color bitmap 
+        /// @param    w width
+        /// @param    h height
+        void drawBitmap(uint16_t x, uint16_t y, const uint16_t** bitmap, int16_t w, int16_t h);
+        void drawBitmap(uint16_t x, uint16_t y, uint16_t** bitmap, int16_t w, int16_t h);
+
+        /// Draw bitmap
+        /// @param    x point coordinate, x-axis
+        /// @param    y point coordinate, y-axis
+        /// @param    bitmap, 1D 16bit color bitmap
+        /// @param    w width
+        /// @param    h height
+        void drawBitmap(uint16_t x, uint16_t y, const uint16_t* bitmap, int16_t w, int16_t h);
+        void drawBitmap(uint16_t x, uint16_t y, uint16_t* bitmap, int16_t w, int16_t h);
+
+        /// Set current GFX font
+        /// @param    f GFX font name defined in include file
+        void setGFXFont(const GFXfont *f = NULL);
+
+        /// Draw a string with the current GFX font
+        /// @param    x point coordinate, x-axis
+        /// @param    y point coordinate, y-axis
+        /// @param    s string to print
+        /// @param    color 16-bit color
+        void drawGFXText(int16_t x, int16_t y, STRING s, uint16_t color);
+        
+        /// Get the width & height of a text string with the current GFX font
+        /// @param    str string to analyze
+        /// @param    x point coordinate, x-axis
+        /// @param    y point coordinate, y-axis
+        /// @param    w width in pixels of string 
+        /// @param    h height in pixels of string
+        void getGFXTextExtent(STRING str, int16_t x, int16_t y, int16_t *w, int16_t *h);
+        
+        /// Draw a single character with the current GFX font
+        /// @param    x point coordinate, x-axis
+        /// @param    y point coordinate, y-axis
+        /// @param    c character to draw
+        /// @param    color 16-bit color
+        /// @return   width of character in display pixels
+        uint16_t drawGFXChar(int16_t x, int16_t y, unsigned char c, uint16_t color);
+
+	uint16_t drawGFXcharBM(int16_t x, int16_t y, unsigned char c, uint16_t color, uint16_t *bm, int bmwd);
+
+        void getGFXCharExtent(uint8_t c, int16_t *gw, int16_t *gh, int16_t *xa);
+
+    private:
+
+        void _spiWrite(uint8_t v);
+        void _spiWrite16(uint16_t v);
+        void _spiWriteCommand(uint8_t c);
+        void _spiWriteData(uint8_t d);
+
+        void _swap(uint16_t &a, uint16_t &b);
+        void _setWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1);
+        void _setWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, autoIncMode_t mode);
+        void _resetWindow();
+        void _drawBitmap(int16_t x, int16_t y, const uint8_t *bitmap, int16_t w, int16_t h, 
+                            uint16_t color, uint16_t bg, bool transparent, bool progmem, bool Xbit );
+        void _orientCoordinates(uint16_t &x1, uint16_t &y1);
+        void _writeRegister(uint16_t reg, uint16_t data);
+        void _writeData(uint8_t HI, uint8_t LO);
+        void _writeData16(uint16_t HILO);
+        void _writeCommand(uint8_t HI, uint8_t LO);
+        void _writeCommand16(uint16_t HILO);
+        uint16_t _maxX, _maxY, _bgColor;
+
+#if defined (__AVR__) || defined(TEENSYDUINO)
+        int8_t  _rst, _rs, _cs, _sdi, _clk, _led;
+    #ifdef USE_FAST_PINIO
+        volatile uint8_t *mosiport, *clkport, *dcport, *rsport, *csport;
+        uint8_t  mosipinmask, clkpinmask, cspinmask, dcpinmask;
+    #endif
+#elif defined (__arm__)
+        int32_t  _rst, _rs, _cs, _sdi, _clk, _led;
+    #ifdef USE_FAST_PINIO
+        volatile RwReg *mosiport, *clkport, *dcport, *rsport, *csport;
+        uint32_t  mosipinmask, clkpinmask, cspinmask, dcpinmask;
+    #endif
+#elif defined (ESP8266) || defined (ESP32)
+        int8_t  _rst, _rs, _cs, _sdi, _clk, _led;
+    #ifdef USE_FAST_PINIO
+        volatile uint32_t *mosiport, *clkport, *dcport, *rsport, *csport;
+        uint32_t  mosipinmask, clkpinmask, cspinmask, dcpinmask;
+    #endif
+#else
+        int8_t  _rst, _rs, _cs, _sdi, _clk, _led;
+#endif
+
+        uint8_t  _orientation, _brightness;
+        
+        // correspondig modes if orientation changed:
+        const autoIncMode_t modeTab [3][8] = {
+        //          { R2L_BottomUp, BottomUp_R2L, L2R_BottomUp, BottomUp_L2R, R2L_TopDown,  TopDown_R2L,  L2R_TopDown,  TopDown_L2R }//
+        /* 90° */   { BottomUp_L2R, L2R_BottomUp, TopDown_L2R,  L2R_TopDown,  BottomUp_R2L, R2L_BottomUp, TopDown_R2L,  R2L_TopDown },   
+        /*180° */   { L2R_TopDown , TopDown_L2R,  R2L_TopDown,  TopDown_R2L,  L2R_BottomUp, BottomUp_L2R, R2L_BottomUp, BottomUp_R2L}, 
+        /*270° */   { TopDown_R2L , R2L_TopDown,  BottomUp_R2L, R2L_BottomUp, TopDown_L2R,  L2R_TopDown,  BottomUp_L2R, L2R_BottomUp}
+                };
+ 
+
+        bool  hwSPI, blState;
+
+        _currentFont cfont;
+
+#ifdef ESP32
+        SPIClass _spi;
+#endif
+
+    protected:
+
+        uint32_t writeFunctionLevel;
+        void startWrite(void);
+        void endWrite(void);
+
+        
+        GFXfont *gfxFont;
+};
+
+#endif
diff --git a/libraries/SondeLib/aprs.cpp b/libraries/SondeLib/aprs.cpp
new file mode 100755
index 0000000..0b7b14b
--- /dev/null
+++ b/libraries/SondeLib/aprs.cpp
@@ -0,0 +1,350 @@
+/* Copyright (C) Hansi Reiser, dl9rdz
+ *
+ * partially based on dxlAPRS toolchain
+ *
+ * Copyright (C) Christian Rabler <oe5dxl@oevsv.at>
+ *
+ * SPDX-License-Identifier:     GPL-2.0+
+ */
+
+#include <stdio.h>
+#include <WString.h>
+#include <stdlib.h>
+//#include <arpa/inet.h>
+//#include <sys/socket.h>
+#include <math.h>
+#include <unistd.h>
+#include <inttypes.h>
+#include "aprs.h"
+
+#if 0
+int openudp(const char *ip, int port, struct sockaddr_in *si) {
+	int fd;
+	if((fd=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP))==-1) return -1;
+	memset((char *)&si, 0, sizeof(si));
+	si->sin_family = AF_INET;
+	si->sin_port = htons(port);
+	if(inet_aton(ip, &(si->sin_addr))==0) {
+		return -1;
+	}
+	return fd;
+}
+
+int sendudp(int fd, struct sockaddr_in *si, char *frame, int framelen)
+{
+	if(sendto(fd, frame, framelen, 0, (struct sockaddr *)si, sizeof(struct sockaddr_in))==-1)  {
+		return -1;
+	}	
+	return 0;
+}
+#endif
+
+
+
+void aprsstr_append(char *b, const char *data)
+{
+	int blen=strlen(b);
+	int len=strlen(data);
+	if(blen+len>APRS_MAXLEN) len=APRS_MAXLEN-blen;
+	strncat(b, data, len);
+}
+
+uint32_t realcard(float x) {
+	if(x<0) return 0;
+	else return (uint32_t)x;
+}
+
+
+/* CRC for AXUDP frames */
+
+#define APRSCRC_POLY 0x8408 
+static uint8_t CRCL[256];
+static uint8_t CRCH[256];
+
+void aprs_gencrctab(void)
+{
+   uint32_t c;
+   uint32_t crc;
+   uint32_t i;
+   for (c = 0UL; c<=255UL; c++) {
+      crc = 255UL-c;
+      for (i = 0UL; i<=7UL; i++) {
+         if ((crc&1)) crc = (uint32_t)((uint32_t)(crc>>1)^APRSCRC_POLY);
+         else crc = crc>>1;
+      } /* end for */
+      CRCL[c] = (uint8_t)crc;
+      CRCH[c] = (uint8_t)(255UL-(crc>>8));
+   } /* end for */
+} /* end Gencrctab() */
+
+static void aprsstr_appcrc(char frame[], uint32_t frame_len, int32_t size)
+{
+   uint8_t h;
+   uint8_t l;
+   uint8_t b;
+   int32_t i;
+   int32_t tmp;
+   l = 0U;
+   h = 0U;
+   tmp = size-1L;
+   i = 0L;
+   if (i<=tmp) for (;; i++) {
+      b = (uint8_t)((uint8_t)(uint8_t)frame[i]^l);
+      l = CRCL[b]^h;
+      h = CRCH[b];
+      if (i==tmp) break;
+   } /* end for */
+   frame[size] = (char)l;
+   frame[size+1L] = (char)h;
+} /* end aprsstr_appcrc() */
+
+
+static int mkaprscall(int32_t * p, char raw[],
+                uint32_t * i, const char mon[],
+                char sep1, char sep2, char sep3,
+                uint32_t sbase)
+{
+   uint32_t s;
+   uint32_t l;
+   l = 0UL;
+   while ((((mon[*i] && mon[*i]!=sep1) && mon[*i]!=sep2) && mon[*i]!=sep3)
+                && mon[*i]!='-') {
+      s = (uint32_t)(uint8_t)mon[*i]*2UL&255UL;
+      if (s<=64UL) return 0;
+      raw[*p] = (char)s;
+      ++*p;
+      ++*i;
+      ++l;
+      if (l>=7UL) return 0;
+   }
+   while (l<6UL) {
+      raw[*p] = '@';
+      ++*p;
+      ++l;
+   }
+   s = 0UL;
+   if (mon[*i]=='-') {
+      ++*i;
+      while ((uint8_t)mon[*i]>='0' && (uint8_t)mon[*i]<='9') {
+         s = (s*10UL+(uint32_t)(uint8_t)mon[*i])-48UL;
+         ++*i;
+      }
+      if (s>15UL) return 0;
+   }
+   raw[*p] = (char)((s+sbase)*2UL);
+   ++*p;
+   return 1;
+} /* end call() */
+
+
+
+// returns raw len, 0 in case of error
+extern int aprsstr_mon2raw(const char *mon, char raw[], int raw_len)
+{
+   uint32_t r;
+   uint32_t n;
+   uint32_t i;
+   uint32_t tmp;
+   int p = 7L;
+   i = 0UL;
+   fprintf(stderr,"mon2raw for %s\n", mon);
+   if (!mkaprscall(&p, raw, &i, mon, '>', 0, 0, 48UL)) {
+      return 0;
+   }
+   p = 0L;
+   if (mon[i]!='>') return 0;
+   /* ">" */
+   ++i;
+   if (!mkaprscall(&p, raw, &i, mon, ':', ',', 0, 112UL)) {
+      return 0;
+   }
+   p = 14L;
+   n = 0UL;
+   while (mon[i]==',') {
+      ++i;
+      if (!mkaprscall(&p, raw, &i, mon, ':', ',', '*', 48UL)) {
+         return 0;
+      }
+      ++n;
+      if (n>8UL) {
+         return 0;
+      }
+      if (mon[i]=='*') {
+         /* "*" has repeatet sign */
+         ++i;
+         r = (uint32_t)p;
+         if (r>=21UL) for (tmp = (uint32_t)(r-21UL)/7UL;;) {
+            raw[r-1UL] = (char)((uint32_t)(uint8_t)raw[r-1UL]+128UL);
+                 /* set "has repeated" flags */
+            if (!tmp) break;
+            --tmp;
+            r -= 7UL;
+         } /* end for */
+      }
+   }
+ if (p==0L || mon[i]!=':') {
+	return 0;
+   }
+   raw[p-1L] = (char)((uint32_t)(uint8_t)raw[p-1L]+1UL);
+                /* end address field mark */
+   raw[p] = '\003';
+   ++p;
+   raw[p] = '\360';
+   ++p;
+   ++i;
+   n = 256UL;
+   while (mon[i]) {
+      /* copy info part */
+      if (p>=(int32_t)(raw_len-1)-2L || n==0UL) {
+         return 0;
+      }
+      raw[p] = mon[i];
+      ++p;
+      ++i;
+      --n;
+   }
+   aprsstr_appcrc(raw, raw_len, p);
+   fprintf(stderr,"results in %s\n",raw);
+   return p+2;
+} /* end mon2raw() */
+
+extern int aprsstr_mon2kiss(const char *mon, char raw[], int raw_len)
+{
+	char tmp[201];
+	int len = aprsstr_mon2raw(mon, tmp, 201);
+	if(len==0) return 0;
+	int idx=0;
+	raw[idx++] = '\xC0';
+	for(int i=0; i<len-2; i++) { // -2: discard CRC, not used in KISS
+		if(tmp[i]=='\xC0') {	
+			raw[idx++] = '\xDB';
+			raw[idx++] = '\xDC';
+		} else if (tmp[i]=='\xDB') {
+			raw[idx++] = '\xDB';
+			raw[idx++] = '\xDD';
+		} else {
+			raw[idx++] = tmp[i];
+		}
+		if(idx>=raw_len)
+			return 0;
+	}
+	return idx;
+}
+
+#define FEET (1.0/0.3048)
+#define KNOTS (1.851984)
+
+#define X2C_max_longcard		0xFFFFFFFFUL
+static uint32_t X2C_TRUNCC(double x, uint32_t min0, uint32_t max0)
+{
+        uint32_t i;
+
+        if (x < (double)min0)
+                i = (uint32_t)min0;
+        if (x > (double)max0)
+                i = (uint32_t)max0;
+
+        i = (uint32_t)x;
+        if ((double)i > x)
+                --i;
+        return i;
+}
+
+
+static uint32_t truncc(double r)
+{
+   if (r<=0.0) return 0UL;
+   else if (r>=2.E+9) return 2000000000UL;
+   else return (uint32_t)X2C_TRUNCC(r,0UL,X2C_max_longcard);
+   return 0;
+} /* end truncc() */
+
+
+
+static uint32_t dao91(double x)
+/* radix91(xx/1.1) of dddmm.mmxx */
+{
+   double a;
+   a = fabs(x);
+   return ((truncc((a-(double)(float)truncc(a))*6.E+5)%100UL)
+                *20UL+11UL)/22UL;
+} /* end dao91() */
+
+
+char b[201];
+char raw[201];
+
+char *aprs_senddata(SondeInfo *s, const char *usercall, const char *sym) {
+// float lat, float lon, float alt, float speed, float dir, float climb, const char *type, const char *objname, const char *usercall, const char *sym, const char *comm)
+	*b=0;
+	aprsstr_append(b, usercall);
+	aprsstr_append(b, ">");
+	const char *destcall="APZRDZ";
+	aprsstr_append(b, destcall);
+	// uncompressed
+	aprsstr_append(b, ":;");
+	char tmp[10];
+	snprintf(tmp,10,"%s         ",s->id);
+	aprsstr_append(b, tmp);
+	aprsstr_append(b, "*");
+	// time
+	int i = strlen(b);
+	int sec = s->time % 86400;
+	snprintf(b+i, APRS_MAXLEN-1, "%02d%02d%02dz", sec/(60*60), (sec%(60*60))/60, sec%60);
+	i = strlen(b);
+	//aprsstr_append_data(time, ds);
+	int lati = abs((int)s->lat);
+	int latm = (fabs(s->lat)-lati)*6000;
+	snprintf(b+i, APRS_MAXLEN-i, "%02d%02d.%02d%c%c", lati, latm/100, latm%100, s->lat<0?'S':'N', sym[0]);
+	i = strlen(b);
+	int loni = abs((int)s->lon);
+	int lonm = (fabs(s->lon)-loni)*6000;
+	snprintf(b+i, APRS_MAXLEN-i, "%03d%02d.%02d%c%c", loni, lonm/100, lonm%100, s->lon<0?'W':'E', sym[1]);
+	if(s->hs>0.5) {
+		i=strlen(b);
+		snprintf(b+i, APRS_MAXLEN-i, "%03d/%03d", realcard(s->dir+1.5), realcard(s->hs*1.0/KNOTS+0.5));
+	}
+	if(s->alt>0.5) {
+		i=strlen(b);
+		snprintf(b+i, APRS_MAXLEN-i, "/A=%06d", realcard(s->alt*FEET+0.5));
+	}
+	int dao=1;
+	if(dao) {
+		i=strlen(b);
+		snprintf(b+i, APRS_MAXLEN-i, "!w%c%c!", 33+dao91(s->lat), 33+dao91(s->lon));
+	}
+	strcat(b, "&");
+	char comm[100];
+        snprintf(comm, 100, "Clb=%.1fm/s %.3fMHz Type=%s", s->vs, s->freq, sondeTypeStr[s->type]);
+	strcat(b, comm);
+	if(s->type==STYPE_M10||s->type==STYPE_DFM06||s->type==STYPE_DFM09) {
+		snprintf(comm, 100, " ser=%s", s->ser);
+		strcat(b, comm);
+	}
+	return b;
+}
+
+
+#if 0
+int main(int argc, char *argv[])
+{
+	Gencrctab();
+
+	struct sockaddr_in si;
+	int fd = openudp("127.0.0.1",9002,&si);
+	if(fd<0) { fprintf(stderr,"open failed\n"); return 1; }
+
+	float lat=48, lon=10;
+	while(1) {
+	const char *str = aprs_senddata(lat, lon, 543, 5, 180, 1.5, "RS41", "TE0ST", "TE1ST", "EO");
+	int rawlen = aprsstr_mon2raw(str, raw, APRS_MAXLEN);
+	sendudp(fd, raw, rawlen);
+
+	str = "OE3XKC>APMI06,qAR,OE3XLR:;ER-341109*111111z4803.61NE01532.39E0145.650MHz R15k OE3XPA";
+	rawlen = aprsstr_mon2raw(str, raw, APRS_MAXLEN);
+	sendudp(fd, &si, raw, rawlen);
+	lat += 0.002; lon += 0.01;
+	sleep(5);
+	}
+}
+#endif
diff --git a/libraries/SondeLib/aprs.h b/libraries/SondeLib/aprs.h
new file mode 100755
index 0000000..6ac8b8e
--- /dev/null
+++ b/libraries/SondeLib/aprs.h
@@ -0,0 +1,14 @@
+
+#ifndef _aprs_h
+#define _aprs_h
+#include "Sonde.h"
+
+
+#define APRS_MAXLEN 201
+void aprs_gencrctab(void);
+int aprsstr_mon2raw(const char *mon, char raw[], int raw_len);
+int aprsstr_mon2kiss(const char *mon, char raw[], int raw_len);
+char *aprs_senddata(SondeInfo *s, const char *usercall, const char *sym);
+
+
+#endif
diff --git a/libraries/SondeLib/autodetect-infos b/libraries/SondeLib/autodetect-infos
new file mode 100755
index 0000000..02cf2de
--- /dev/null
+++ b/libraries/SondeLib/autodetect-infos
@@ -0,0 +1,68 @@
+Heltec board v1 => fingerprint 0000100 => 4
+(sda,scl: 4,15) (same as LORA v1.0)
+0:1 1:0 2:0 3:1 4:0 5:1 6:0 7:1 8:0 9:1 10:1 11:1 12:0 13:0 14:1 15:0 16:0 17:0 18:0 19:0 20:0 21:1 22:0 23:0 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 
+
+Heltec board v2
+(sda,scl: 4,15) (similar to v1.0, but GPIO21 switches 3V3) => fingerprint 4
+0:1 1:0 2:0 3:1 4:0 5:1 6:0 7:1 8:0 9:1 10:1 11:1 12:0 13:0 14:1 15:0 16:0 17:0 18:0 19:0 20:0 21:1 22:0 23:0 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 
+0:1 1:1 2:0 3:1 4:0 5:1 6:0 7:1 8:0 9:1 10:1 11:1 12:0 13:0 14:1 15:0 16:0 17:0 18:0 19:0 20:0 21:1 22:0 23:0 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0  (before setup
+
+TTGO LORA32 v2.1_1.6 (button1: touch gpio 2 => 130; button2: touch gpio14 => 142)  fingerprint 0011111 => 31
+(sda,scl: 21,22)
+0:1 1:0 2:0 3:1 4:0 5:1 6:0 7:1 8:0 9:1 10:1 11:1 12:0 13:0 14:1 15:1 16:1 17:1 18:0 19:0 20:0 21:1 22:1 23:1 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 
+0:4 1:4 2:0 3:4 4:0 5:4 6:0 7:4 8:0 9:4 10:4 11:4 12:0 13:0 14:4 15:4 16:4 17:4 18:0 19:0 20:0 21:4 22:4 23:4 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0  (in Sonde())
+
+TTGO LORA v1.0 => fingerprint  1000000   => 64
+(sda,scl: 4,15) (button1: 0)  (button2: touch gpio13 = 141)
+0:1 1:0 2:0 3:1 4:1 5:1 6:0 7:1 8:0 9:1 10:1 11:1 12:0 13:0 14:1 15:1 16:0 17:0 18:0 19:0 20:0 21:0 22:0 23:0 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 
+0:4 1:4 2:0 3:4 4:4 5:4 6:0 7:4 8:0 9:4 10:4 11:4 12:0 13:0 14:4 15:4 16:0 17:0 18:0 19:0 20:0 21:0 22:0 23:0 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0  (in Sonde())
+
+TTGO T-Beam => fingerprint 0110111 => 55 
+(sda,scl: 21,22) (button1: 39) (button2: touch gpio13 = 141) (gps rx: 12)
+0:1 1:0 2:0 3:1 4:0 5:1 6:0 7:1 8:0 9:1 10:1 11:1 12:1 13:0 14:1 15:1 16:1 17:0 18:0 19:0 20:0 21:1 22:1 23:1 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 
+0:4 1:4 2:0 3:4 4:0 5:4 6:0 7:4 8:0 9:4 10:4 11:4 12:4 13:0 14:4 15:4 16:4 17:0 18:0 19:0 20:0 21:4 22:4 23:4 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0  (before setup)
+
+TTGO T-Beam with extern 2" ILI9225 Display => fingerprint 0110000 => 48
+0:1 1:0 2:0 3:1 4:0 5:1 6:0 7:1 8:0 9:1 10:1 11:1 12:1 13:0 14:1 15:1 16:1 17:0 18:0 19:0 20:0 21:0 22:0 23:1 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 
+0:4 1:4 2:0 3:4 4:0 5:4 6:0 7:4 8:0 9:4 10:4 11:4 12:4 13:0 14:4 15:4 16:4 17:0 18:0 19:0 20:0 21:0 22:0 23:4 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0  (before setup)
+
+TTGO T-Beam 1.0 with OLED display => fingerprint 0010111 => 23
+0:1 1:0 2:0 3:1 4:0 5:1 6:0 7:1 8:0 9:1 10:1 11:1 12:0 13:0 14:1 15:1 16:1 17:0 18:0 19:0 20:0 21:1 22:1 23:1 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0 
+0:4 1:4 2:0 3:4 4:0 5:4 6:0 7:4 8:0 9:4 10:4 11:4 12:0 13:0 14:4 15:4 16:4 17:0 18:0 19:0 20:0 21:4 22:4 23:4 24:0 25:0 26:0 27:0 28:0 29:0 30:0 31:0 32:0 33:0 34:0 35:0 36:0 37:0 38:0  (before setup)
+
+1
+
+Fingerprint GPIOs:   4, 12, 16, 17, 21, 22, 23, 
+
+Current autodetect strategy:
+RST always set to 16
+
+GPIO16=0  (GPio22,23 would also work):
+  ==Heltec or TTGO LORA v1.0==
+  SDA,SCL set to (4,15)
+  Button 1 set to GPIO 0
+  Button 2 set to Touch in GPIO 13 (141)
+
+
+otherwise
+  ==LORA32 v2.1 or T-Beam==
+  GPIO17=0:
+    == T-BEAM =
+    GPIO12==0:  v1 (or check PMU via I2C?)
+      GPS RX set to 34
+      Button 1 set to GPIO28
+      BUtton 2 set to Touch GPIO13
+    else: 
+      GPS RX set to 12
+      Button 1 set to GPIO39
+      Button 2 set to Touch GPIO13 (141)
+      GPIO21=0:
+         large display connected (use ILI9225 contig: SDA4 CLK21 RS2 RST22 CS0)
+      else:
+         small display connected, set SDA,SCL to (21,22)
+  otherweise:
+    SDA,SCL set to (21,22)
+    GPS disabled
+    Button 1 set to Touch GPIO2 (130)
+    Button 2 set to Touch GPIO14 (142)
+  
diff --git a/libraries/SondeLib/geteph.cpp b/libraries/SondeLib/geteph.cpp
new file mode 100755
index 0000000..ba78522
--- /dev/null
+++ b/libraries/SondeLib/geteph.cpp
@@ -0,0 +1,226 @@
+#include "time.h"
+#include "geteph.h"
+#include <SPIFFS.h>
+#include <WiFi.h>
+#include <rom/miniz.h>
+#include <inttypes.h>
+#include <WiFi.h>
+#include "Display.h"
+
+
+extern WiFiClient client;
+
+static const char *ftpserver = "www.ngs.noaa.gov";
+char outbuf[128];
+
+uint8_t getreply() {
+	String s = client.readStringUntil('\n');
+	Serial.println(s);
+	const char *str = s.c_str();
+	if(strlen(str)<4) return 255; // something unusual...
+	if(str[3]=='-') { // multi-line resonse...
+		String s2;
+		const char *str2;
+		do {
+			s2 = client.readStringUntil('\n');
+			Serial.println(s2);
+			str2 = s2.c_str();
+			if(strlen(str2)<4) return 255; // something is wrong
+		} while( str[0]!=str2[0] || str[1]!=str2[1] || str[2]!=str2[2] || str2[3]!=' ' );
+	}
+	return str[0];
+}
+
+void writeFully(File &file, uint8_t *buf, size_t len)
+{
+	size_t olen;
+
+	while(len) {
+		olen = file.write(buf, len);
+		Serial.printf("written: %d of %d\n", olen, len);
+		len -= olen;
+		buf += olen;
+	}
+}
+
+void geteph() {
+	// Set current time via network...	
+	struct tm tinfo;
+	configTime(0, 0, "pool.ntp.org");
+	bool ok = getLocalTime(&tinfo, 2000);  // wait max 2 seconds to get current time via ntp
+	if(!ok) {
+		Serial.println("Failed to get current date/time");
+		return;
+	}
+
+	// Check time of last update
+	int year = tinfo.tm_year + 1900;
+	int day = tinfo.tm_yday + 1;
+	Serial.printf("year %d, day %d\n", year, day);
+	char nowstr[20];
+	snprintf(nowstr, 20, "%04d%03d%02d", year, day, tinfo.tm_hour);
+	File status = SPIFFS.open("/brdc.time", "r");
+	if(status) {
+		String ts = status.readStringUntil('\n');
+		const char *tsstr = ts.c_str();
+		if(tsstr && strlen(tsstr)>=9) {
+			if(strcmp(nowstr, ts.c_str())<=0) {
+				Serial.println("local brdc is up to date\n");
+				return;
+			}
+		}
+		Serial.printf("now: %s, existing: %s => updating\n", nowstr, tsstr);
+	}
+	status.close();
+	disp.rdis->clear();
+	disp.rdis->setFont(FONT_SMALL);
+	disp.rdis->drawString(0, 0, "FTP ngs.noaa.gov");
+	// fetch rinex from server
+	File fh = SPIFFS.open("/brdc.gz","w");
+	if(!fh) {	
+		Serial.println("cannot open file\n");
+		return;
+	}
+	char buf[252];
+	snprintf(buf, 128, "/cors/rinex/%04d/%03d/brdc%03d0.%02dn.gz", year, day, day, year-2000);
+	Serial.println("running geteph\n");
+	disp.rdis->drawString(0, 1, buf+21);
+	
+	if(!client.connect(ftpserver, 21)) {
+		Serial.println("FTP connection to www.ngs.noaa.gov failed");
+		return;
+	}
+#if 0
+	while(!client.available()) delay(1);
+	while(client.available()) {
+		String s = client.readStringUntil('\n');
+		Serial.println(s);
+	}
+#endif
+	if(getreply()>='4') { Serial.println("connected failed"); return; }
+	client.print("USER anonymous\r\n");
+	if(getreply()>='4') { Serial.println("USER failed"); return; }
+	client.print("PASS anonymous\r\n");
+	if(getreply()>='4') { Serial.println("PASS failed"); return; }
+	client.print("TYPE I\r\n");
+	if(getreply()>='4') { Serial.println("TYPE I failed"); return; }
+	client.print("PASV\r\n");
+	String s = client.readStringUntil('\n');
+	Serial.println(s);
+	if(s.c_str()[0]>='4') { Serial.println("PASV failed"); return; }
+	int array_pasv[6];
+	char *tStr = strtok((char *)s.c_str(), "(,");
+	for(int i=0; i<6; i++) {
+		tStr = strtok(NULL, "(,");
+		if(tStr==NULL) {
+			Serial.println("strange response to PASV");
+			return;
+		}
+		array_pasv[i] = atoi(tStr);  
+		Serial.println(array_pasv[i]);
+	}
+	uint16_t port = (array_pasv[4]<<8) | (array_pasv[5]&0xff);
+	WiFiClient dclient;
+	Serial.printf("connecting to %s:%d\n", ftpserver,port);
+	dclient.connect(ftpserver, port);
+	if(!dclient) {
+		Serial.println("data connection failed");
+		return;
+	}
+	client.print("RETR ");
+	Serial.printf("fetching %s with FTP...\n", buf);
+	client.println(buf);
+	s = client.readStringUntil('\n');
+	Serial.println(s);
+	if(s.c_str()[0]>='4') { Serial.println("RETR failed"); return; }
+	int len=0;
+	while(dclient.connected()) {
+		while(dclient.available()) {
+			char c = dclient.read();
+			fh.write(c);
+			len++;
+		}
+	}
+	Serial.printf("fetched %d bytes\n", len);
+	fh.close();
+	snprintf(buf, 16, "Fetched %d B    ",len);
+	buf[16]=0;
+	disp.rdis->drawString(0,2,buf);
+
+	disp.rdis->drawString(0,4,"Decompressing...");
+	// decompression
+	tinfl_decompressor *decomp = (tinfl_decompressor *)malloc(sizeof(tinfl_decompressor));
+	tinfl_init(decomp);
+	File file = SPIFFS.open("/brdc.gz","r");
+	if(!file) {	
+		Serial.println("cannot open file\n");
+		return;
+	}
+	File ofile = SPIFFS.open("/brdc", "w");
+	if(!ofile) {
+		Serial.println("cannot open file /brdc for writing");
+		return;
+	}
+	file.readBytes(buf, 10);  // skip gzip header
+	char flags = buf[3];
+	if(flags&0x07) {
+		Serial.println("Unsupported flags in gzip header, may or may not cause a problem");
+	}
+	if(flags&0x08) { // skip file name extra header
+		do {
+			int res=file.readBytes(buf, 1);
+			if(res!=1) return;
+		} while(*buf);
+	}
+	if(flags&0x10) { // skip file name extra header
+		do {
+			int res=file.readBytes(buf, 1);
+			if(res!=1) return;
+		} while(*buf);
+	}
+	int opos = 0;
+	int total = 0;
+	Serial.println("Decompressing ephemeris data...\n");
+	char *obuf =(char *)malloc(32768);
+	char *ibuf =(char *)malloc(8192);
+	while(file.available()) {
+		size_t len = file.readBytes(ibuf, 8192);
+		size_t inofs = 0;
+		size_t inlen = len;
+		while(inofs<len) {
+			size_t outlen=32768-opos;
+			int res = tinfl_decompress(decomp, (const mz_uint8 *)ibuf+inofs, &inlen, (uint8_t *)obuf, (mz_uint8 *)obuf+opos, &outlen, TINFL_FLAG_HAS_MORE_INPUT);
+			if(res<0) break;
+			if(outlen==0) break;
+			Serial.printf("... (res=%d) decompressed %d into %d bytes\n", res, inlen, outlen);
+			inofs += inlen;
+			inlen = len - inofs;
+			//size_t retv = ofile.write((uint8_t *)(obuf+opos), outlen);
+			//Serial.printf("write %d bytes\n", retv);
+			writeFully(ofile, (uint8_t *)(obuf+opos), outlen);
+			//Serial.write((uint8_t *)(obuf+opos), outlen);
+			total += outlen;
+			opos += outlen;
+			if(res==0) break; // done indication
+			if(opos>=32768) {
+				Serial.printf("... decompressed %d bytes\n", total);
+				opos=0;
+			}
+		}
+	}
+	// maybe todo: check crc?!?
+	Serial.printf("done extracing content (total length: %d)\n", total);
+	status = SPIFFS.open("/brdc.time","w");
+	status.println(nowstr);
+	status.close();
+        snprintf(buf, 16, "Done: %d B    ",total);
+        buf[16]=0;
+        disp.rdis->drawString(0,5,buf);
+	delay(1000);
+
+	free(obuf);
+	free(ibuf);
+	free(decomp);
+	file.close();
+	ofile.close();
+}
diff --git a/libraries/SondeLib/geteph.h b/libraries/SondeLib/geteph.h
new file mode 100755
index 0000000..f985417
--- /dev/null
+++ b/libraries/SondeLib/geteph.h
@@ -0,0 +1,3 @@
+
+void geteph();
+
diff --git a/libraries/SondeLib/gfxfont.h b/libraries/SondeLib/gfxfont.h
new file mode 100755
index 0000000..f99a757
--- /dev/null
+++ b/libraries/SondeLib/gfxfont.h
@@ -0,0 +1,26 @@
+//        SPDX-License-Identifier:        GPL-3.0
+//      original source: https://github.com/Nkawu/TFT_22_ILI9225
+
+// Font structures like Adafruit_GFX (1.1 and later).
+// Example fonts are included in 'fonts' directory.
+// To use a font in your Arduino sketch, #include the corresponding .h
+// file and pass address of GFXfont struct to setFont().
+
+#ifndef _GFFFONT_H_
+#define _GFFFONT_H_
+
+typedef struct { // Data stored PER GLYPH
+	uint16_t bitmapOffset;     // Pointer into GFXfont->bitmap
+	uint8_t  width, height;    // Bitmap dimensions in pixels
+	uint8_t  xAdvance;         // Distance to advance cursor (x axis)
+	int8_t   xOffset, yOffset; // Dist from cursor pos to UL corner
+} GFXglyph;
+
+typedef struct { // Data stored for FONT AS A WHOLE:
+	uint8_t  *bitmap;      // Glyph bitmaps, concatenated
+	GFXglyph *glyph;       // Glyph array
+	uint8_t   first, last; // ASCII extents
+	uint8_t   yAdvance;    // Newline distance (y axis)
+} GFXfont;
+
+#endif // _GFFFONT_H_
diff --git a/libraries/SondeLib/nav_gps_vel.cpp b/libraries/SondeLib/nav_gps_vel.cpp
new file mode 100755
index 0000000..afd1ccc
--- /dev/null
+++ b/libraries/SondeLib/nav_gps_vel.cpp
@@ -0,0 +1,1866 @@
+/* SPDX-License-Identifier:        GPL-3.0
+ * based on https://github.com/rs1729/RS/blob/master/rs92/nav_gps_vel.c
+ *
+ Quellen:
+           - IS-GPS-200H  (bis C: ICD-GPS-200):
+             http://www.gps.gov/technical/icwg/
+           - Borre: http://kom.aau.dk/~borre
+           - Essential GNSS Project (hier und da etwas unklar)
+*/
+#include <math.h>
+#include <inttypes.h>
+#include <SPIFFS.h>
+#include <Arduino.h>
+#include <stdio.h>
+
+#include "nav_gps_vel.h"
+
+#ifndef PI
+#define  PI  (3.1415926535897932384626433832795)
+#endif
+
+#define  RELATIVISTIC_CLOCK_CORRECTION   (-4.442807633e-10)  // combined constant defined in IS-GPS-200     [s]/[sqrt(m)]
+#define  GRAVITY_CONSTANT                (3.986005e14)       // gravity constant defined on IS-GPS-200      [m^3/s^2]
+#define  EARTH_ROTATION_RATE             (7.2921151467e-05)  // IS-GPS-200                                  [rad/s]
+#define  SECONDS_IN_WEEK                 (604800.0)          // [s]
+#define  LIGHTSPEED                      (299792458.0)       // light speed constant defined in IS-GPS-200  [m/s]
+
+#define  RANGE_ESTIMATE                  (0.072)             // approx. GPS-Sat range 0.072s*299792458m/s=21585057m
+#define  RANGERATE_ESTIMATE              (0.000)             //
+
+#define EARTH_a      (6378137.0)
+#define EARTH_b      (6356752.31424518)
+#define EARTH_a2_b2  (EARTH_a*EARTH_a - EARTH_b*EARTH_b)
+
+/* ---------------------------------------------------------------------------------------------------- */
+
+
+void ecef2elli(double X, double Y, double Z, double *lat, double *lon, double *alt) {
+    double ea2 = EARTH_a2_b2 / (EARTH_a*EARTH_a),
+           eb2 = EARTH_a2_b2 / (EARTH_b*EARTH_b);
+    double phi, lam, R, p, t;
+    double sint, cost;
+
+    lam = atan2( Y , X );
+
+    p = sqrt( X*X + Y*Y );
+    t = atan2( Z*EARTH_a , p*EARTH_b );
+
+    sint = sin(t);
+    cost = cos(t);
+
+    phi = atan2( Z + eb2 * EARTH_b * sint*sint*sint ,
+                 p - ea2 * EARTH_a * cost*cost*cost );
+
+    R = EARTH_a / sqrt( 1 - ea2*sin(phi)*sin(phi) );
+    *alt = p / cos(phi) - R;
+
+    *lat = phi*180.0/PI;
+    *lon = lam*180.0/PI;
+}
+
+
+double dist(double X1, double Y1, double Z1, double X2, double Y2, double Z2) {
+    return sqrt( (X2-X1)*(X2-X1) + (Y2-Y1)*(Y2-Y1) + (Z2-Z1)*(Z2-Z1) );
+}
+
+
+void rotZ(double x1, double y1, double z1, double angle, double *x2, double *y2, double *z2) {
+    double cosa = cos(angle);
+    double sina = sin(angle);
+    *x2 =  cosa * x1 + sina * y1;
+    *y2 = -sina * x1 + cosa * y1;
+    *z2 = z1;
+}
+
+
+/* ---------------------------------------------------------------------------------------------------- */
+
+/* ---------------------------------------------------------------------------------------------------- */
+
+#if 0
+int read_SEMalmanac(FILE *fp, EPHEM_t *alm) {
+    int l, j;
+    char buf[64];
+    unsigned n, week, toa, ui;
+    double dbl;
+
+    l = fscanf(fp, "%u", &n);    if (l != 1) return -1;
+    l = fscanf(fp, "%s", buf);   if (l != 1) return -1;
+    l = fscanf(fp, "%u", &week); if (l != 1) return -1;
+    l = fscanf(fp, "%u", &toa);  if (l != 1) return -1;
+
+    for (j = 1; j <= n; j++) {
+        //memset(&ephem, 0, sizeof(ephem));
+
+        alm[j].week = (uint16_t)week;
+        alm[j].toa  = (uint32_t)toa;
+        alm[j].toe  = (double)toa;
+        alm[j].toc  = alm[j].toe;
+
+        l = fscanf(fp, "%u", &ui);    if (l != 1) return -1;  alm[j].prn = (uint16_t)ui;
+        l = fscanf(fp, "%u", &ui);    if (l != 1) return -2;  alm[j].svn = (uint16_t)ui;
+        l = fscanf(fp, "%u", &ui);    if (l != 1) return -3;  alm[j].ura = (uint8_t)ui;
+        l = fscanf(fp, "%lf", &dbl);  if (l != 1) return -4;  alm[j].e = dbl;
+        l = fscanf(fp, "%lf", &dbl);  if (l != 1) return -5;  alm[j].delta_i = dbl;
+                                                              alm[j].i0 = (0.30 + alm[j].delta_i) * PI;
+        l = fscanf(fp, "%lf", &dbl);  if (l != 1) return -6;  alm[j].OmegaDot = dbl * PI;
+        l = fscanf(fp, "%lf", &dbl);  if (l != 1) return -7;  alm[j].sqrta = dbl;
+        l = fscanf(fp, "%lf", &dbl);  if (l != 1) return -6;  alm[j].Omega0 = dbl * PI;
+        l = fscanf(fp, "%lf", &dbl);  if (l != 1) return -8;  alm[j].w = dbl * PI;
+        l = fscanf(fp, "%lf", &dbl);  if (l != 1) return -9;  alm[j].M0 = dbl * PI;
+        l = fscanf(fp, "%lf", &dbl);  if (l != 1) return -10; alm[j].af0 = dbl;
+        l = fscanf(fp, "%lf", &dbl);  if (l != 1) return -11; alm[j].af1 = dbl;
+                                                              alm[j].af2 = 0;
+                                                              alm[j].crc = 0;
+                                                              alm[j].crs = 0;
+                                                              alm[j].cuc = 0;
+                                                              alm[j].cus = 0;
+                                                              alm[j].cic = 0;
+                                                              alm[j].cis = 0;
+                                                              alm[j].tgd = 0;
+                                                              alm[j].idot = 0;
+                                                              alm[j].delta_n = 0;
+        l = fscanf(fp, "%u", &ui);    if (l != 1) return -12; alm[j].health = (uint8_t)ui;
+        l = fscanf(fp, "%u", &ui);    if (l != 1) return -13; alm[j].conf = (uint8_t)ui;
+    }
+
+    return 0;
+}
+
+int read_RNXephemeris(FILE *fp, EPHEM_t eph[][24]) {
+    int l, i;
+    char buf[64], str[20];
+    char buf_header[83];
+       //buf_data[80];  // 3 + 4*19 = 79
+    char *pbuf;
+    unsigned ui;
+    double dbl;
+    int c;
+    EPHEM_t ephem = {};
+    int hr = 0;
+
+    do {
+        //l = fread(buf_header, 81, 1, fp); // Zeilen in Header sind nicht immer mit Leerzeichen aufgefuellt
+        pbuf = fgets(buf_header, 82, fp);   // max 82-1 Zeichen + '\0'
+        buf_header[82] = '\0';  // doppelt haelt besser
+        //l = strlen(buf_header);
+    } while ( pbuf  &&  !strstr(buf_header, "END OF HEADER") );
+
+    //l = fread(buf_data, 80, 1, fp);
+    //buf_data[79] = '\0';
+
+
+    while (hr < 24) {  // brdc/hour-rinex sollte nur Daten von einem Tag enthalten
+
+        //memset(&ephem, 0, sizeof(ephem));
+
+        l = fread(buf,  3, 1, fp);    if (l != 1) break;  buf[ 3] = 0;  sscanf(buf, "%d", &ui);
+        ephem.prn = ui;
+
+
+        for (i = 0; i < 16; i++) ephem.epoch[i] = '0';
+        ephem.epoch[16] = '\0';
+
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  buf[19] = 0;
+
+        for (i = 0; i < 6; i++) {
+            c = buf[3*i  ]; if (c == ' ') c = '0'; str[2*i  ] = c;
+            c = buf[3*i+1]; if (c == ' ') c = '0'; str[2*i+1] = c;
+        }
+        str[12] = buf[17];
+        str[13] = buf[18];
+        str[14] = '\0';
+
+        strncpy(ephem.epoch  , "20", 2);  // vorausgesetzt 21.Jhd; Datum steht auch im Header
+        strncpy(ephem.epoch+2, str, 15);
+        ephem.epoch[16] = '\0';
+
+        strncpy(str, buf+9, 2); str[2] = '\0';
+        hr  = atoi(str);
+
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.af0 = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.af1 = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.af2 = dbl;
+        if ((c=fgetc(fp)) == EOF) break;
+
+        l = fread(buf,  3, 1, fp);    if (l != 1) break;  buf[ 3] = 0;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.iode = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.crs = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.delta_n = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.M0 = dbl;
+        if ((c=fgetc(fp)) == EOF) break;
+
+        l = fread(buf,  3, 1, fp);    if (l != 1) break;  buf[ 3] = 0;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.cuc = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.e = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.cus = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.sqrta = dbl;
+        if ((c=fgetc(fp)) == EOF) break;
+
+        l = fread(buf,  3, 1, fp);    if (l != 1) break;  buf[ 3] = 0;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.toe = dbl;
+                                                                                                                                    ephem.toc = ephem.toe;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.cic = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.Omega0 = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.cis = dbl;
+        if ((c=fgetc(fp)) == EOF) break;
+
+        l = fread(buf,  3, 1, fp);    if (l != 1) break;  buf[ 3] = 0;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.i0 = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.crc = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.w = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.OmegaDot = dbl;
+        if ((c=fgetc(fp)) == EOF) break;
+
+        l = fread(buf,  3, 1, fp);    if (l != 1) break;  buf[ 3] = 0;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.idot = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.codeL2 = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.gpsweek = (int)dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.iodc = dbl;
+        if ((c=fgetc(fp)) == EOF) break;
+
+        l = fread(buf,  3, 1, fp);    if (l != 1) break;  buf[ 3] = 0;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.sva = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.health = (uint8_t)(dbl+0.1);
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.tgd = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.iodc = dbl;
+        if ((c=fgetc(fp)) == EOF) break;
+
+        l = fread(buf,  3, 1, fp);    if (l != 1) break;  buf[ 3] = 0;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.ttom = dbl;
+        pbuf = fgets(buf_header, 82, fp);
+     /* // die letzten beiden Felder (spare) sind manchmal leer (statt 0.00); manchmal fehlt sogar das drittletzte Feld
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.fit = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.spare1 = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.spare2 = dbl;
+        if ((c=fgetc(fp)) == EOF) break;  */
+
+
+        ephem.week = 1; // ephem.gpsweek
+        eph[ephem.prn][hr] = ephem;
+
+        if (pbuf == NULL) break;
+    }
+
+    return 0;
+}
+#endif
+
+static EPHEM_t *te;
+
+#define fgets(buffer, siz, file) file.read((uint8_t *)buffer, siz)
+#define fread(buffer, siz, els, file) (file.read((uint8_t *)buffer, (siz)*(els))/siz)
+#define fgetc(file) (char)file.read()
+
+
+//EPHEM_t *read_RNXpephs(FILE *fp) {
+EPHEM_t *read_RNXpephs(const char *file) {
+    int l, i;
+    //char buffer[86];
+    char buf[64], str[20];
+    unsigned ui;
+    double dbl;
+    int c;
+    EPHEM_t ephem = {};
+    // int count = 0;
+    //long fpos;
+
+    File fp = SPIFFS.open(file, "r");
+    if(!fp) { Serial.printf("Error opening %s\n", file); }
+
+    String line;
+    do {  // header-Zeilen: 80 Zeichen
+	line = fp.readStringUntil('\n');
+        //pbuf = fgets(buffer, 84, fp);   // max 82-1 Zeichen
+        //buffer[82] = '\0';
+	Serial.printf("Skipping header: %s\n", line.c_str());
+    } while ( fp.available()  &&  !strstr((const char *)line.c_str(), "END OF HEADER") );
+    if (!fp.available()) return NULL;
+/*
+    fpos = ftell(fp);
+    count = 0;
+    while (count >= 0) {  // data-Zeilen: 79 Zeichen
+        pbuf = fgets(buffer, 84, fp); if (pbuf == 0) break;
+        strncpy(str, buffer, 3);
+        str[3] = '\0';
+        sscanf(str, "%d", &ui);
+        if (ui < 33) count++;
+        for (i = 1; i < 8; i++) {
+            pbuf = fgets(buffer, 84, fp); if (pbuf == 0) break;
+        }
+    }
+    printf("Ephemerides: %d total=%d\n", count, count*sizeof(ephem));
+
+    fseek(fp, fpos, SEEK_SET);
+*/
+    if(te) free(te);
+    te = (EPHEM_t *)calloc( 34, sizeof(ephem) ); // calloc( 1, sizeof(ephem) );
+    if (te == NULL) return NULL;
+
+    //int n = 0;
+
+
+    while (true) {  // brdc/hour-rinex sollte nur Daten von einem Tag enthalten
+
+        //memset(&ephem, 0, sizeof(ephem));
+
+        l = fread(buf,  3, 1, fp);    if (l != 1) break;  buf[ 3] = 0;  sscanf(buf, "%d", &ui);
+        ephem.prn = ui;
+
+        for (i = 0; i < 16; i++) ephem.epoch[i] = '0';
+        ephem.epoch[16] = '\0';
+
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  buf[19] = 0;
+
+        for (i = 0; i < 6; i++) {
+            c = buf[3*i  ]; if (c == ' ') c = '0'; str[2*i  ] = c;
+            c = buf[3*i+1]; if (c == ' ') c = '0'; str[2*i+1] = c;
+        }
+        str[12] = buf[17];
+        str[13] = buf[18];
+        str[14] = '\0';
+
+        strncpy(ephem.epoch  , "20", 2);  // vorausgesetzt 21.Jhd; Datum steht auch im Header
+        strncpy(ephem.epoch+2, str, 15);
+        ephem.epoch[16] = '\0';
+
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.af0 = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.af1 = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.af2 = dbl;
+        while ((c=fgetc(fp)) != '\n') { if (c == EOF) break; }
+
+        l = fread(buf,  3, 1, fp);    if (l != 1) break;  buf[ 3] = 0;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.iode = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.crs = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.delta_n = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.M0 = dbl;
+        while ((c=fgetc(fp)) != '\n') { if (c == EOF) break; }
+
+        l = fread(buf,  3, 1, fp);    if (l != 1) break;  buf[ 3] = 0;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.cuc = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.e = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.cus = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.sqrta = dbl;
+        while ((c=fgetc(fp)) != '\n') { if (c == EOF) break; }
+
+        l = fread(buf,  3, 1, fp);    if (l != 1) break;  buf[ 3] = 0;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.toe = dbl;
+                                                                                                                                    ephem.toc = ephem.toe;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.cic = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.Omega0 = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.cis = dbl;
+        while ((c=fgetc(fp)) != '\n') { if (c == EOF) break; }
+
+        l = fread(buf,  3, 1, fp);    if (l != 1) break;  buf[ 3] = 0;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.i0 = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.crc = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.w = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.OmegaDot = dbl;
+        while ((c=fgetc(fp)) != '\n') { if (c == EOF) break; }
+
+        l = fread(buf,  3, 1, fp);    if (l != 1) break;  buf[ 3] = 0;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.idot = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.codeL2 = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.gpsweek = (int)dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.iodc = dbl;
+        while ((c=fgetc(fp)) != '\n') { if (c == EOF) break; }
+
+        l = fread(buf,  3, 1, fp);    if (l != 1) break;  buf[ 3] = 0;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.sva = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.health = (uint8_t)(dbl+0.1);
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); ephem.tgd = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.iodc = dbl;
+        while ((c=fgetc(fp)) != '\n') { if (c == EOF) break; }
+
+        l = fread(buf,  3, 1, fp);    if (l != 1) break;  buf[ 3] = 0;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.ttom = dbl;
+	String l = fp.readStringUntil('\n');
+     /* // die letzten beiden Felder (spare) sind manchmal leer (statt 0.00); manchmal fehlt sogar das drittletzte Feld
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.fit = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.spare1 = dbl;
+        l = fread(buf, 19, 1, fp);    if (l != 1) break;  if (buf[15] == 'D') buf[15] = 'E'; buf[19] = 0; sscanf(buf, "%lf", &dbl); //ephem.spare2 = dbl;
+        while ((c=fgetc(fp)) != '\n') { if (c == EOF) break; }  */
+
+        ephem.week = 1; // ephem.gpsweek
+	//Serial.printf("Reading ephem for prn %d\n", ui);
+	if(ui<33) {
+#if 0
+		// no need to do it the difficult way, most recent data is at end of file :-)
+		double tdiff;
+		if(te[ui].prn!=ui) {
+			tdiff = WEEKSEC;
+		} else {
+			tdiff = now - te[ui].toe;
+			if(tdiff>WEEKSEC/2) tdiff -= WEEKSEC;
+			if(tdiff<-WEEKSEC/2) tdiff += WEEKSEC;
+		}
+		double td = now - ephem.toe;
+		if(td>WEEKSEC/2) td -= WEEKSEC;
+		if(td<-WEEKSEC/2) td += WEEKSEC;
+#endif		
+		te[ui] = ephem;
+	} else {
+		Serial.printf("bad prn: %d\n", ui);
+	}
+        //if (pbuf == NULL) break;
+	if(!fp.available()) break;
+    }
+    te[33].prn=0;
+    return te;
+}
+
+/* ---------------------------------------------------------------------------------------------------- */
+//
+// Satellite Position
+//
+
+void GPS_SatelliteClockCorrection(
+  const unsigned short transmission_gpsweek,   // GPS week when signal was transmit (0-1024+)            [weeks]
+  const double         transmission_gpstow,    // GPS time of week when signal was transmit              [s]
+  const unsigned short ephem_week,             // ephemeris: GPS week (0-1024+)                          [weeks]
+  const double         toe,                    // ephemeris: time of week                                [s]
+  const double         toc,                    // ephemeris: clock reference time of week                [s]
+  const double         af0,                    // ephemeris: polynomial clock correction coefficient     [s],
+  const double         af1,                    // ephemeris: polynomial clock correction coefficient     [s/s],
+  const double         af2,                    // ephemeris: polynomial clock correction coefficient     [s/s^2]
+  const double         ecc,                    // ephemeris: eccentricity of satellite orbit             []
+  const double         sqrta,                  // ephemeris: square root of the semi-major axis of orbit [m^(1/2)]
+  const double         delta_n,                // ephemeris: mean motion difference from computed value  [rad]
+  const double         m0,                     // ephemeris: mean anomaly at reference time              [rad]
+  const double         tgd,                    // ephemeris: group delay differential between L1 and L2  [s]
+  double*  clock_correction )                  // ephemeris: satellite clock correction                  [m]
+{
+    int j;
+
+    double tot;    // time of transmission (including gps week) [s]
+    double tk;     // time from ephemeris reference epoch       [s]
+    double tc;     // time from clock reference epoch           [s]
+    double d_tr;   // relativistic correction term              [s]
+    double d_tsv;  // SV PRN code phase time offset             [s]
+    double a;      // semi-major axis of orbit                  [m]
+    double n;      // corrected mean motion                     [rad/s]
+    double M;      // mean anomaly,                             [rad]
+    double E;      // eccentric anomaly                         [rad]
+
+    // compute the times from the reference epochs
+    tot = transmission_gpsweek*SECONDS_IN_WEEK + transmission_gpstow;
+    tk  = tot - (ephem_week*SECONDS_IN_WEEK + toe);
+    tc  = tot - (ephem_week*SECONDS_IN_WEEK + toc);
+
+    // compute the corrected mean motion term
+    a = sqrta*sqrta;
+    n = sqrt( GRAVITY_CONSTANT / (a*a*a) ); //  mean motion
+    n += delta_n; // corrected mean motion
+
+    // Kepler-Gleichung  M = E - e sin(E)
+    M = m0 + n*tk; // mean anomaly
+    E = M;                         // f(E) = M + e sin(E)  hat Fixpunkt fuer e < 1,
+    for( j = 0; j < 7; j++ ) {     // da |f'(E)|=|e cos(E)|<1.
+        E = M + ecc * sin(E);      // waehle Startwert E_1 = M, E_{k+1} = f(E_k)
+    }                              // konvergiert langsam gegen E_0 = f(E_0)
+
+    // relativistic correction
+    d_tr = RELATIVISTIC_CLOCK_CORRECTION * ecc * sqrta * sin(E); // [s]
+    d_tr *= LIGHTSPEED;
+
+    // clock correction
+    d_tsv = af0 + af1*tc + af2*tc*tc; // [s]
+
+    // L1 only
+    d_tsv -= tgd; // [s]
+
+    // clock correction
+    *clock_correction = d_tsv*LIGHTSPEED + d_tr; // [m]
+
+}
+
+void GPS_ComputeSatellitePosition(
+  const unsigned short transmission_gpsweek,  // GPS week when signal was transmit (0-1024+)                            [weeks]
+  const double         transmission_gpstow,   // GPS time of week when signal was transmit                              [s]
+  const unsigned short ephem_week,            // ephemeris: GPS week (0-1024+)                                          [weeks]
+  const double         toe,                   // ephemeris: time of week                                                [s]
+  const double         m0,                    // ephemeris: mean anomaly at reference time                              [rad]
+  const double         delta_n,               // ephemeris: mean motion difference from computed value                  [rad]
+  const double         ecc,                   // ephemeris: eccentricity                                                []
+  const double         sqrta,                 // ephemeris: square root of the semi-major axis                          [m^(1/2)]
+  const double         omega0,                // ephemeris: longitude of ascending node of orbit plane at weekly epoch  [rad]
+  const double         i0,                    // ephemeris: inclination angle at reference time                         [rad]
+  const double         w,                     // ephemeris: argument of perigee                                         [rad]
+  const double         omegadot,              // ephemeris: rate of right ascension                                     [rad/s]
+  const double         idot,                  // ephemeris: rate of inclination angle                                   [rad/s]
+  const double         cuc,                   // ephemeris: cos harmonic correction term to the argument of latitude    [rad]
+  const double         cus,                   // ephemeris: sin harmonic correction term to the argument of latitude    [rad]
+  const double         crc,                   // ephemeris: cos harmonic correction term to the orbit radius            [m]
+  const double         crs,                   // ephemeris: sin harmonic correction term to the orbit radius            [m]
+  const double         cic,                   // ephemeris: cos harmonic correction term to the angle of inclination    [rad]
+  const double         cis,                   // ephemeris: sin harmonic correction term to the angle of inclination    [rad]
+  double* x,                                  // satellite x            [m]
+  double* y,                                  // satellite y            [m]
+  double* z )                                 // satellite z            [m]
+{
+    int j;
+
+    double tot;        // time of transmission (including gps week) [s]
+    double tk;         // time from ephemeris reference epoch       [s]
+    double a;          // semi-major axis of orbit                  [m]
+    double n;          // corrected mean motion                     [rad/s]
+    double M;          // mean anomaly,                             [rad]
+    double E;          // eccentric anomaly                         [rad]
+    double v;          // true anomaly                              [rad]
+    double u;          // argument of latitude, corrected           [rad]
+    double r;          // radius in the orbital plane               [m]
+    double i;          // orbital inclination                       [rad]
+    double cos2u;      // cos(2*u)                                  []
+    double sin2u;      // sin(2*u)                                  []
+    double d_u;        // argument of latitude correction           [rad]
+    double d_r;        // radius correction                         [m]
+    double d_i;        // inclination correction                    [rad]
+    double x_op;       // x position in the orbital plane           [m]
+    double y_op;       // y position in the orbital plane           [m]
+    double omegak;     // corrected longitude of the ascending node [rad]
+    double cos_omegak; // cos(omegak)
+    double sin_omegak; // sin(omegak)
+    double cosu;       // cos(u)
+    double sinu;       // sin(u)
+    double cosi;       // cos(i)
+    double sini;       // sin(i)
+    double cosE;       // cos(E)
+    double sinE;       // sin(E)
+
+
+    // compute the times from the reference epochs
+    tot = transmission_gpsweek*SECONDS_IN_WEEK + transmission_gpstow;
+    tk  = tot - (ephem_week*SECONDS_IN_WEEK + toe);
+
+    // compute the corrected mean motion term
+    a = sqrta*sqrta;
+    n = sqrt( GRAVITY_CONSTANT / (a*a*a) ); // computed mean motion
+    n += delta_n; // corrected mean motion
+
+    // Kepler-Gleichung  M = E - e sin(E)
+    M = m0 + n*tk; // mean anomaly
+    E = M;                         // f(E) = M + e sin(E)  hat Fixpunkt fuer e < 1,
+    for( j = 0; j < 7; j++ ) {     // da |f'(E)|=|e cos(E)|<1.
+        E = M + ecc * sin(E);      // waehle Startwert E_1 = M, E_{k+1} = f(E_k)
+    }                              // konvergiert langsam gegen E_0 = f(E_0)
+
+    cosE = cos(E);
+    sinE = sin(E);
+
+    // true anomaly
+    v = atan2( (sqrt(1.0 - ecc*ecc)*sinE),  (cosE - ecc) );
+    // argument of latitude
+    u = v + w;
+    // radius in orbital plane
+    r = a * (1.0 - ecc * cos(E));
+    // orbital inclination
+    i = i0;
+
+    // second harmonic perturbations
+    //
+    cos2u = cos(2.0*u);
+    sin2u = sin(2.0*u);
+    // argument of latitude correction
+    d_u = cuc * cos2u  +  cus * sin2u;
+    // radius correction
+    d_r = crc * cos2u  +  crs * sin2u;
+    // correction to inclination
+    d_i = cic * cos2u  +  cis * sin2u;
+
+    // corrected argument of latitude
+    u += d_u;
+    // corrected radius
+    r += d_r;
+    // corrected inclination
+    i += d_i + idot * tk;
+
+    // positions in orbital plane
+    cosu = cos(u);
+    sinu = sin(u);
+    x_op = r * cosu;
+    y_op = r * sinu;
+
+
+    omegak = omega0 + omegadot*tk - EARTH_ROTATION_RATE*(tk + toe);
+    // fuer Bestimmung der Satellitenposition in ECEF, range=0;
+    // fuer GPS-Loesung (Sats in ECI) Erdrotation hinzuziehen:
+    // rotZ(EARTH_ROTATION_RATE*0.072), 0.072s*299792458m/s=21585057m
+
+    // compute the WGS84 ECEF coordinates,
+    // vector r with components x & y is now rotated using, R3(-omegak)*R1(-i)
+    cos_omegak = cos(omegak);
+    sin_omegak = sin(omegak);
+    cosi = cos(i);
+    sini = sin(i);
+
+    *x = x_op * cos_omegak - y_op * sin_omegak * cosi;
+    *y = x_op * sin_omegak + y_op * cos_omegak * cosi;
+    *z = y_op * sini;
+
+}
+
+void GPS_SatellitePosition_Ephem(
+  const unsigned short gpsweek,      // gps week of signal transmission (0-1024+)            [week]
+  const double         gpstow,       // time of week of signal transmission  (gpstow-psr/c)  [s]
+  EPHEM_t ephem,
+  double* clock_correction,  // clock correction for this satellite for this epoch           [m]
+  double* satX,              // satellite X position WGS84 ECEF                              [m]
+  double* satY,              // satellite Y position WGS84 ECEF                              [m]
+  double* satZ               // satellite Z position WGS84 ECEF                              [m]
+  )
+{
+    double tow;          // user time of week adjusted with the clock corrections [s]
+    double x;            // sat X position [m]
+    double y;            // sat Y position [m]
+    double z;            // sat Z position [m]
+    unsigned short week; // user week adjusted with the clock correction if needed [week]
+
+
+    x = y = z = 0.0;
+
+    GPS_SatelliteClockCorrection( gpsweek, gpstow,
+        ephem.week, ephem.toe, ephem.toc, ephem.af0,
+        ephem.af1, ephem.af2, ephem.e, ephem.sqrta,
+        ephem.delta_n, ephem.M0, ephem.tgd, clock_correction );
+
+
+    // adjust for week rollover
+    week = gpsweek;
+    tow = gpstow + (*clock_correction)/LIGHTSPEED;
+    if ( tow < 0.0 ) {
+        tow += SECONDS_IN_WEEK;
+        week--;
+    }
+    if ( tow > SECONDS_IN_WEEK ) {
+        tow -= SECONDS_IN_WEEK;
+        week++;
+    }
+
+    //range = 0.072s*299792458m/s=21585057m
+    GPS_ComputeSatellitePosition( week, tow,
+        ephem.week, ephem.toe, ephem.M0, ephem.delta_n, ephem.e, ephem.sqrta,
+        ephem.Omega0, ephem.i0, ephem.w, ephem.OmegaDot, ephem.idot,
+        ephem.cuc, ephem.cus, ephem.crc, ephem.crs, ephem.cic, ephem.cis,
+        &x, &y, &z );
+
+    *satX = x;
+    *satY = y;
+    *satZ = z;
+
+}
+
+/* ---------------------------------------------------------------------------------------------------- */
+
+
+int NAV_ClosedFormSolution_FromPseudorange(
+  SAT_t sats[4],          // input:  satellite position and pseudorange
+  double* latitude,       // output: ellipsoid latitude  [rad]
+  double* longitude,      //         ellipsoid longitude [rad]
+  double* height,         //         ellipsoid height    [m]
+  double* rx_clock_bias,  //         receiver clock bias [m]
+  double pos_ecef[3] )    //         ECEF coordinates    [m]
+{
+
+    double p1 = sats[0].pseudorange + sats[0].clock_corr;  // pseudorange measurement + clock correction [m]
+    double p2 = sats[1].pseudorange + sats[1].clock_corr;
+    double p3 = sats[2].pseudorange + sats[2].clock_corr;
+    double p4 = sats[3].pseudorange + sats[3].clock_corr;
+
+    double x1, y1, z1;  // Sat1 ECEF
+    double x2, y2, z2;  // Sat2 ECEF
+    double x3, y3, z3;  // Sat3 ECEF
+    double x4, y4, z4;  // Sat4 ECEF
+
+    // Erdrotation ECEF-ECI,  0.070s*299792458m/s=20985472m, 0.072s*299792458m/s=21585057m
+    rotZ(sats[0].X, sats[0].Y, sats[0].Z, EARTH_ROTATION_RATE*RANGE_ESTIMATE, &x1, &y1, &z1);
+    rotZ(sats[1].X, sats[1].Y, sats[1].Z, EARTH_ROTATION_RATE*RANGE_ESTIMATE, &x2, &y2, &z2);
+    rotZ(sats[2].X, sats[2].Y, sats[2].Z, EARTH_ROTATION_RATE*RANGE_ESTIMATE, &x3, &y3, &z3);
+    rotZ(sats[3].X, sats[3].Y, sats[3].Z, EARTH_ROTATION_RATE*RANGE_ESTIMATE, &x4, &y4, &z4);
+
+
+    double x12, x13, x14; // 'xij' = 'xi' - 'xj' [m]
+    double y12, y13, y14;
+    double z12, z13, z14;
+    double p21, p31, p41; // 'pij' = 'pi' - 'pj' [m]
+
+    double k1, k2, k3; // coefficients
+    double c1, c2, c3;
+    double f1, f2, f3;
+    double m1, m2, m3;
+
+    double d1;   // clock bias, solution 1 [m]
+    double d2;   // clock bias, solution 2 [m]
+    double detA; // determinant of A
+    double tmp1;
+    double tmp2;
+    double tmp3;
+
+    double A[3][3];
+    double D[3][3]; // D is A^-1 * detA
+
+    typedef struct {
+        double x;
+        double y;
+        double z;
+    } struct_SOLN;
+
+    struct_SOLN s1;
+    struct_SOLN s2;
+
+    struct_SOLN stmp;
+    double dtmp;
+    double x0, y0, z0;
+    double latS, lonS, altS,
+           lat1, lon1, alt1,
+           lat2, lon2, alt2;
+    double d2_1, d2_2;
+
+
+    x12 = x1 - x2;
+    x13 = x1 - x3;
+    x14 = x1 - x4;
+
+    y12 = y1 - y2;
+    y13 = y1 - y3;
+    y14 = y1 - y4;
+
+    z12 = z1 - z2;
+    z13 = z1 - z3;
+    z14 = z1 - z4;
+
+    p21 = p2 - p1;
+    p31 = p3 - p1;
+    p41 = p4 - p1;
+
+    k1 = x12*x12 + y12*y12 + z12*z12 - p21*p21;
+    k2 = x13*x13 + y13*y13 + z13*z13 - p31*p31;
+    k3 = x14*x14 + y14*y14 + z14*z14 - p41*p41;
+
+    A[0][0] = 2.0*x12;
+    A[1][0] = 2.0*x13;
+    A[2][0] = 2.0*x14;
+
+    A[0][1] = 2.0*y12;
+    A[1][1] = 2.0*y13;
+    A[2][1] = 2.0*y14;
+
+    A[0][2] = 2.0*z12;
+    A[1][2] = 2.0*z13;
+    A[2][2] = 2.0*z14;
+
+    tmp1 = A[1][1]*A[2][2] - A[2][1]*A[1][2];
+    tmp2 = A[1][0]*A[2][2] - A[2][0]*A[1][2];
+    tmp3 = A[1][0]*A[2][1] - A[2][0]*A[1][1];
+
+    detA = A[0][0]*tmp1 - A[0][1]*tmp2 + A[0][2]*tmp3;
+
+    D[0][0] =  tmp1;
+    D[1][0] = -tmp2;
+    D[2][0] =  tmp3;
+
+    D[0][1] = -A[0][1]*A[2][2] + A[2][1]*A[0][2];
+    D[1][1] =  A[0][0]*A[2][2] - A[2][0]*A[0][2];
+    D[2][1] = -A[0][0]*A[2][1] + A[2][0]*A[0][1];
+
+    D[0][2] =  A[0][1]*A[1][2] - A[1][1]*A[0][2];
+    D[1][2] = -A[0][0]*A[1][2] + A[1][0]*A[0][2];
+    D[2][2] =  A[0][0]*A[1][1] - A[1][0]*A[0][1];
+
+    c1 = (D[0][0]*p21 + D[0][1]*p31 + D[0][2]*p41) * 2.0 / detA;
+    c2 = (D[1][0]*p21 + D[1][1]*p31 + D[1][2]*p41) * 2.0 / detA;
+    c3 = (D[2][0]*p21 + D[2][1]*p31 + D[2][2]*p41) * 2.0 / detA;
+
+    f1 = (D[0][0]*k1 + D[0][1]*k2 + D[0][2]*k3) / detA;
+    f2 = (D[1][0]*k1 + D[1][1]*k2 + D[1][2]*k3) / detA;
+    f3 = (D[2][0]*k1 + D[2][1]*k2 + D[2][2]*k3) / detA;
+
+    m1 = c1*c1 + c2*c2 + c3*c3 - 1.0;
+    m2 = -2.0*( c1*f1 + c2*f2 + c3*f3 );
+    m3 = f1*f1 + f2*f2 + f3*f3;
+
+    tmp1 = m2*m2 - 4.0*m1*m3;
+    if ( tmp1 < 0 ) { // not good, there is no solution
+        return -1;    //FALSE
+    }
+
+    d1 = ( -m2 - sqrt( tmp1 ) ) * 0.5 / m1; // +-Reihenfolge vertauscht
+    d2 = ( -m2 + sqrt( tmp1 ) ) * 0.5 / m1;
+
+    // two solutions
+    s1.x = c1*d1 - f1 + x1;
+    s1.y = c2*d1 - f2 + y1;
+    s1.z = c3*d1 - f3 + z1;
+
+    s2.x = c1*d2 - f1 + x1;
+    s2.y = c2*d2 - f2 + y1;
+    s2.z = c3*d2 - f3 + z1;
+
+    tmp1 = sqrt( s1.x*s1.x + s1.y*s1.y + s1.z*s1.z );
+    tmp2 = sqrt( s2.x*s2.x + s2.y*s2.y + s2.z*s2.z );
+
+    // choose the correct solution based
+    // on whichever solution is closest to
+    // the Earth's surface
+    tmp1 = fabs( tmp1 - 6371000.0 );
+    tmp2 = fabs( tmp2 - 6371000.0 );
+
+    // nur (tmp2 < tmp1) geht manchmal schief
+    if ( tmp2 < tmp1  &&  tmp1 >= 60000 ) {  // swap solutions
+        stmp = s1; s1 = s2; s2 = stmp;  // s1 = s2;
+        dtmp = d1; d1 = d2; d2 = dtmp;  // d1 = d2;
+    }
+    else if ( tmp2 < 60000 ) {   // interessant wenn tmp1<tmp2<60k oder tmp2<tmp1<60k,
+        x0 = (x1+x2+x3+x4)/4.0;  // d.h. beide Werte nahe Erdoberflaeche;
+        y0 = (y1+y2+y3+y4)/4.0;  // ungefaehre Position kann aus den Positionen
+        z0 = (z1+z2+z3+z4)/4.0;  // der empfangenen Sats abgeleitet werden
+        ecef2elli( x0, y0, z0, &latS, &lonS, &altS );
+
+        ecef2elli( s1.x, s1.y, s1.z, &lat1, &lon1, &alt1 );
+        ecef2elli( s2.x, s2.y, s2.z, &lat2, &lon2, &alt2 );
+
+        d2_1 = sqrt( (latS-lat1)*(latS-lat1) + (lonS-lon1)*(lonS-lon1) );
+        d2_2 = sqrt( (latS-lat2)*(latS-lat2) + (lonS-lon2)*(lonS-lon2) );
+
+        if ( d2_2 < d2_1 ) {
+            stmp = s1; s1 = s2; s2 = stmp;  // s1 = s2;
+            dtmp = d1; d1 = d2; d2 = dtmp;  // d1 = d2;
+        }
+    }
+
+    ecef2elli( s1.x, s1.y, s1.z, &lat1, &lon1, &alt1 );
+
+    *latitude  = lat1;
+    *longitude = lon1;
+    *height    = alt1;
+
+    *rx_clock_bias = d1;
+
+    pos_ecef[0] = s1.x;
+    pos_ecef[1] = s1.y;
+    pos_ecef[2] = s1.z;
+
+    if( *height < -1500.0 || *height > 50000.0 ) {
+        return -2;
+    }
+
+    return 0;
+}
+
+
+/* ---------------------------------------------------------------------------------------------------- */
+
+
+int trace_invert(double mat[4][4], double trinv[4])  // trace-invert
+/* selected elements from 4x4 matrix inversion */
+{
+    // Find all NECESSARY 2x2 subdeterminants
+    double Det2_12_01 = mat[1][0] * mat[2][1] - mat[1][1] * mat[2][0];
+    double Det2_12_02 = mat[1][0] * mat[2][2] - mat[1][2] * mat[2][0];
+    //double Det2_12_03 = mat[1][0]*mat[2][3] - mat[1][3]*mat[2][0];
+    double Det2_12_12 = mat[1][1] * mat[2][2] - mat[1][2] * mat[2][1];
+    //double Det2_12_13 = mat[1][1]*mat[2][3] - mat[1][3]*mat[2][1];
+    //double Det2_12_23 = mat[1][2]*mat[2][3] - mat[1][3]*mat[2][2];
+    double Det2_13_01 = mat[1][0] * mat[3][1] - mat[1][1] * mat[3][0];
+    //double Det2_13_02 = mat[1][0]*mat[3][2] - mat[1][2]*mat[3][0];
+    double Det2_13_03 = mat[1][0] * mat[3][3] - mat[1][3] * mat[3][0];
+    //double Det2_13_12 = mat[1][1]*mat[3][2] - mat[1][2]*mat[3][1];
+    double Det2_13_13 = mat[1][1] * mat[3][3] - mat[1][3] * mat[3][1];
+    //double Det2_13_23 = mat[1][2]*mat[3][3] - mat[1][3]*mat[3][2];
+    double Det2_23_01 = mat[2][0] * mat[3][1] - mat[2][1] * mat[3][0];
+    double Det2_23_02 = mat[2][0] * mat[3][2] - mat[2][2] * mat[3][0];
+    double Det2_23_03 = mat[2][0] * mat[3][3] - mat[2][3] * mat[3][0];
+    double Det2_23_12 = mat[2][1] * mat[3][2] - mat[2][2] * mat[3][1];
+    double Det2_23_13 = mat[2][1] * mat[3][3] - mat[2][3] * mat[3][1];
+    double Det2_23_23 = mat[2][2] * mat[3][3] - mat[2][3] * mat[3][2];
+
+    // Find all NECESSARY 3x3 subdeterminants
+    double Det3_012_012 = mat[0][0] * Det2_12_12 - mat[0][1] * Det2_12_02 + mat[0][2] * Det2_12_01;
+    //double Det3_012_013 = mat[0][0]*Det2_12_13 - mat[0][1]*Det2_12_03 + mat[0][3]*Det2_12_01;
+    //double Det3_012_023 = mat[0][0]*Det2_12_23 - mat[0][2]*Det2_12_03 + mat[0][3]*Det2_12_02;
+    //double Det3_012_123 = mat[0][1]*Det2_12_23 - mat[0][2]*Det2_12_13 + mat[0][3]*Det2_12_12;
+    //double Det3_013_012 = mat[0][0]*Det2_13_12 - mat[0][1]*Det2_13_02 + mat[0][2]*Det2_13_01;
+    double Det3_013_013 = mat[0][0] * Det2_13_13 - mat[0][1] * Det2_13_03 + mat[0][3] * Det2_13_01;
+    //double Det3_013_023 = mat[0][0]*Det2_13_23 - mat[0][2]*Det2_13_03 + mat[0][3]*Det2_13_02;
+    //double Det3_013_123 = mat[0][1]*Det2_13_23 - mat[0][2]*Det2_13_13 + mat[0][3]*Det2_13_12;
+    //double Det3_023_012 = mat[0][0]*Det2_23_12 - mat[0][1]*Det2_23_02 + mat[0][2]*Det2_23_01;
+    //double Det3_023_013 = mat[0][0]*Det2_23_13 - mat[0][1]*Det2_23_03 + mat[0][3]*Det2_23_01;
+    double Det3_023_023 = mat[0][0] * Det2_23_23 - mat[0][2] * Det2_23_03 + mat[0][3] * Det2_23_02;
+    //double Det3_023_123 = mat[0][1]*Det2_23_23 - mat[0][2]*Det2_23_13 + mat[0][3]*Det2_23_12;
+    double Det3_123_012 = mat[1][0] * Det2_23_12 - mat[1][1] * Det2_23_02 + mat[1][2] * Det2_23_01;
+    double Det3_123_013 = mat[1][0] * Det2_23_13 - mat[1][1] * Det2_23_03 + mat[1][3] * Det2_23_01;
+    double Det3_123_023 = mat[1][0] * Det2_23_23 - mat[1][2] * Det2_23_03 + mat[1][3] * Det2_23_02;
+    double Det3_123_123 = mat[1][1] * Det2_23_23 - mat[1][2] * Det2_23_13 + mat[1][3] * Det2_23_12;
+
+    // Find the 4x4 determinant
+    static double det;
+    det = mat[0][0] * Det3_123_123
+	    - mat[0][1] * Det3_123_023
+	    + mat[0][2] * Det3_123_013
+	    - mat[0][3] * Det3_123_012;
+
+    // Very small determinants probably reflect floating-point fuzz near zero
+    if (fabs(det) < 0.0001)
+	return -1;
+
+    //inv[0][0] = Det3_123_123 / det;
+    //inv[0][1] = -Det3_023_123 / det;
+    //inv[0][2] =  Det3_013_123 / det;
+    //inv[0][3] = -Det3_012_123 / det;
+
+    //inv[1][0] = -Det3_123_023 / det;
+    //inv[1][1] = Det3_023_023 / det;
+    //inv[1][2] = -Det3_013_023 / det;
+    //inv[1][3] =  Det3_012_023 / det;
+
+    //inv[2][0] =  Det3_123_013 / det;
+    //inv[2][1] = -Det3_023_013 / det;
+    //inv[2][2] = Det3_013_013 / det;
+    //inv[2][3] = -Det3_012_013 / det;
+
+    //inv[3][0] = -Det3_123_012 / det;
+    //inv[3][1] =  Det3_023_012 / det;
+    //inv[3][2] = -Det3_013_012 / det;
+    //inv[3][3] = Det3_012_012 / det;
+
+    trinv[0] = Det3_123_123 / det;
+
+    trinv[1] = Det3_023_023 / det;
+    trinv[2] = Det3_013_013 / det;
+    trinv[3] = Det3_012_012 / det;
+
+    return 0;
+}
+
+int calc_DOPn(int n, SAT_t satss[], double pos_ecef[3], double DOP[4]) {
+    int i, j, k;
+    double norm[n], satpos[n][3];
+    double SATS[n][4], AtA[4][4];
+
+    for (i = 0; i < n; i++) {
+        satpos[i][0] = satss[i].X-pos_ecef[0];
+        satpos[i][1] = satss[i].Y-pos_ecef[1];
+        satpos[i][2] = satss[i].Z-pos_ecef[2];
+    }
+
+
+    for (i = 0; i < n; i++) {
+        norm[i] = sqrt( satpos[i][0]*satpos[i][0] + satpos[i][1]*satpos[i][1] + satpos[i][2]*satpos[i][2] );
+        for (j = 0; j < 3; j++) {
+            SATS[i][j] = satpos[i][j] / norm[i];
+        }
+        SATS[i][3] = 1;
+    }
+
+    for (i = 0; i < 4; i++) {
+        for (j = 0; j < 4; j++) {
+            AtA[i][j] = 0.0;
+            for (k = 0; k < n; k++) {
+                AtA[i][j] += SATS[k][i]*SATS[k][j];
+            }
+        }
+    }
+
+    return trace_invert(AtA, DOP);
+}
+
+/* ---------------------------------------------------------------------------------------------------- */
+
+int rotE(SAT_t sat, double *x, double *y, double *z) {
+    // Erdrotation ECEF-ECI,  0.070s*299792458m/s=20985472m, 0.072s*299792458m/s=21585057m
+    double range = sat.PR/LIGHTSPEED;
+    if (range < 19e6  ||  range > 30e6) range = 21e6;
+    rotZ(sat.X, sat.Y, sat.Z, EARTH_ROTATION_RATE*(range/LIGHTSPEED), x, y, z);
+    return 0;
+}
+
+
+double lorentz(double a[4], double b[4]) {
+    return a[0]*b[0] + a[1]*b[1] +a[2]*b[2] - a[3]*b[3];
+}
+
+int matrix_invert(double mat[4][4], double inv[4][4])
+{
+    // 2x2 subdeterminants
+    double Det2_12_01 = mat[1][0] * mat[2][1] - mat[1][1] * mat[2][0];
+    double Det2_12_02 = mat[1][0] * mat[2][2] - mat[1][2] * mat[2][0];
+    double Det2_12_03 = mat[1][0] * mat[2][3] - mat[1][3] * mat[2][0];
+    double Det2_12_12 = mat[1][1] * mat[2][2] - mat[1][2] * mat[2][1];
+    double Det2_12_13 = mat[1][1] * mat[2][3] - mat[1][3] * mat[2][1];
+    double Det2_12_23 = mat[1][2] * mat[2][3] - mat[1][3] * mat[2][2];
+    double Det2_13_01 = mat[1][0] * mat[3][1] - mat[1][1] * mat[3][0];
+    double Det2_13_02 = mat[1][0] * mat[3][2] - mat[1][2] * mat[3][0];
+    double Det2_13_03 = mat[1][0] * mat[3][3] - mat[1][3] * mat[3][0];
+    double Det2_13_12 = mat[1][1] * mat[3][2] - mat[1][2] * mat[3][1];
+    double Det2_13_13 = mat[1][1] * mat[3][3] - mat[1][3] * mat[3][1];
+    double Det2_13_23 = mat[1][2] * mat[3][3] - mat[1][3] * mat[3][2];
+    double Det2_23_01 = mat[2][0] * mat[3][1] - mat[2][1] * mat[3][0];
+    double Det2_23_02 = mat[2][0] * mat[3][2] - mat[2][2] * mat[3][0];
+    double Det2_23_03 = mat[2][0] * mat[3][3] - mat[2][3] * mat[3][0];
+    double Det2_23_12 = mat[2][1] * mat[3][2] - mat[2][2] * mat[3][1];
+    double Det2_23_13 = mat[2][1] * mat[3][3] - mat[2][3] * mat[3][1];
+    double Det2_23_23 = mat[2][2] * mat[3][3] - mat[2][3] * mat[3][2];
+
+    // 3x3 subdeterminants
+    double Det3_012_012 = mat[0][0] * Det2_12_12 - mat[0][1] * Det2_12_02 + mat[0][2] * Det2_12_01;
+    double Det3_012_013 = mat[0][0] * Det2_12_13 - mat[0][1] * Det2_12_03 + mat[0][3] * Det2_12_01;
+    double Det3_012_023 = mat[0][0] * Det2_12_23 - mat[0][2] * Det2_12_03 + mat[0][3] * Det2_12_02;
+    double Det3_012_123 = mat[0][1] * Det2_12_23 - mat[0][2] * Det2_12_13 + mat[0][3] * Det2_12_12;
+    double Det3_013_012 = mat[0][0] * Det2_13_12 - mat[0][1] * Det2_13_02 + mat[0][2] * Det2_13_01;
+    double Det3_013_013 = mat[0][0] * Det2_13_13 - mat[0][1] * Det2_13_03 + mat[0][3] * Det2_13_01;
+    double Det3_013_023 = mat[0][0] * Det2_13_23 - mat[0][2] * Det2_13_03 + mat[0][3] * Det2_13_02;
+    double Det3_013_123 = mat[0][1] * Det2_13_23 - mat[0][2] * Det2_13_13 + mat[0][3] * Det2_13_12;
+    double Det3_023_012 = mat[0][0] * Det2_23_12 - mat[0][1] * Det2_23_02 + mat[0][2] * Det2_23_01;
+    double Det3_023_013 = mat[0][0] * Det2_23_13 - mat[0][1] * Det2_23_03 + mat[0][3] * Det2_23_01;
+    double Det3_023_023 = mat[0][0] * Det2_23_23 - mat[0][2] * Det2_23_03 + mat[0][3] * Det2_23_02;
+    double Det3_023_123 = mat[0][1] * Det2_23_23 - mat[0][2] * Det2_23_13 + mat[0][3] * Det2_23_12;
+    double Det3_123_012 = mat[1][0] * Det2_23_12 - mat[1][1] * Det2_23_02 + mat[1][2] * Det2_23_01;
+    double Det3_123_013 = mat[1][0] * Det2_23_13 - mat[1][1] * Det2_23_03 + mat[1][3] * Det2_23_01;
+    double Det3_123_023 = mat[1][0] * Det2_23_23 - mat[1][2] * Det2_23_03 + mat[1][3] * Det2_23_02;
+    double Det3_123_123 = mat[1][1] * Det2_23_23 - mat[1][2] * Det2_23_13 + mat[1][3] * Det2_23_12;
+
+    // 4x4 determinant
+    static double det;
+    det = mat[0][0] * Det3_123_123
+	    - mat[0][1] * Det3_123_023
+	    + mat[0][2] * Det3_123_013
+	    - mat[0][3] * Det3_123_012;
+
+    // Very small determinants probably reflect floating-point fuzz near zero
+    if (fabs(det) < 0.0001)
+	return -1;
+
+    inv[0][0] =  Det3_123_123 / det;
+    inv[0][1] = -Det3_023_123 / det;
+    inv[0][2] =  Det3_013_123 / det;
+    inv[0][3] = -Det3_012_123 / det;
+
+    inv[1][0] = -Det3_123_023 / det;
+    inv[1][1] =  Det3_023_023 / det;
+    inv[1][2] = -Det3_013_023 / det;
+    inv[1][3] =  Det3_012_023 / det;
+
+    inv[2][0] =  Det3_123_013 / det;
+    inv[2][1] = -Det3_023_013 / det;
+    inv[2][2] =  Det3_013_013 / det;
+    inv[2][3] = -Det3_012_013 / det;
+
+    inv[3][0] = -Det3_123_012 / det;
+    inv[3][1] =  Det3_023_012 / det;
+    inv[3][2] = -Det3_013_012 / det;
+    inv[3][3] =  Det3_012_012 / det;
+
+    return 0;
+}
+
+int NAV_bancroft1(int N, SAT_t sats[], double pos_ecef[3], double *cc) {
+
+    int i, j, k;
+    double B[N][4], BtB[4][4], BBinv[4][4], BBB[4][N];
+    double a[N], Be[4], Ba[4];
+
+    double q0, q1, q2, p, q, sq, x1, x2;
+    double Lsg1[4], Lsg2[4];
+
+    double tmp1, tmp2;
+    double X, Y, Z;
+
+
+    if (N < 4 || N > 12) return -1;
+
+    for (i = 0; i < N; i++) {
+        rotZ(sats[i].X, sats[i].Y, sats[i].Z, EARTH_ROTATION_RATE*RANGE_ESTIMATE, B[i], B[i]+1, B[i]+2);
+        B[i][3] = sats[i].pseudorange + sats[i].clock_corr;
+    }
+
+    if (N == 4) {
+        matrix_invert(B, (double (*)[4]) BBB);
+    }
+    else {
+        for (i = 0; i < 4; i++) {
+            for (j = 0; j < 4; j++) {
+                BtB[i][j] = 0.0;
+                for (k = 0; k < N; k++) {
+                    BtB[i][j] += B[k][i]*B[k][j];
+                }
+            }
+        }
+        matrix_invert(BtB, BBinv);
+        for (i = 0; i < 4; i++) {
+            for (j = 0; j < N; j++) {
+                BBB[i][j] = 0.0;
+                for (k = 0; k < 4; k++) {
+                    BBB[i][j] += BBinv[i][k]*B[j][k];
+                }
+            }
+        }
+    }
+
+    for (i = 0; i < 4; i++) {
+        Be[i] = 0.0;
+        for (k = 0; k < N; k++) {
+            Be[i] += BBB[i][k]*1.0;
+        }
+    }
+
+    for (i = 0; i < N; i++) {
+        a[i] = 0.5 * lorentz(B[i], B[i]);
+    }
+
+    for (i = 0; i < 4; i++) {
+        Ba[i] = 0.0;
+        for (k = 0; k < N; k++) {
+            Ba[i] += BBB[i][k]*a[k];
+        }
+    }
+
+    q2 = lorentz(Be, Be);
+    q1 = lorentz(Ba, Be)-1;
+    q0 = lorentz(Ba, Ba);
+
+    if (q2 == 0) return -2;
+
+    p = q1/q2;
+    q = q0/q2;
+
+    sq = p*p - q;
+    if (sq < 0) return -2;
+
+    x1 = -p + sqrt(sq);
+    x2 = -p - sqrt(sq);
+
+    for (i = 0; i < 4; i++) {
+        Lsg1[i] = x1*Be[i]+Ba[i];
+        Lsg2[i] = x2*Be[i]+Ba[i];
+    }
+    Lsg1[3] = -Lsg1[3];
+    Lsg2[3] = -Lsg2[3];
+
+
+    tmp1 = sqrt( Lsg1[0]*Lsg1[0] + Lsg1[1]*Lsg1[1] + Lsg1[2]*Lsg1[2] );
+    tmp2 = sqrt( Lsg2[0]*Lsg2[0] + Lsg2[1]*Lsg2[1] + Lsg2[2]*Lsg2[2] );
+
+    tmp1 = fabs( tmp1 - 6371000.0 );
+    tmp2 = fabs( tmp2 - 6371000.0 );
+
+    if (tmp1 < tmp2) {
+        X = Lsg1[0]; Y = Lsg1[1]; Z = Lsg1[2]; *cc = Lsg1[3];
+    } else {
+        X = Lsg2[0]; Y = Lsg2[1]; Z = Lsg2[2]; *cc = Lsg2[3];
+    }
+    pos_ecef[0] = X;
+    pos_ecef[1] = Y;
+    pos_ecef[2] = Z;
+
+    return 0;
+}
+
+int NAV_bancroft2(int N, SAT_t sats[], double pos_ecef[3], double *cc) {
+
+    int i, j, k;
+    double B[N][4], BtB[4][4], BBinv[4][4], BBB[4][N];
+    double a[N], Be[4], Ba[4];
+
+    double q0, q1, q2, p, q, sq, x1, x2;
+    double Lsg1[4], Lsg2[4];
+
+    double tmp1, tmp2;
+    double X, Y, Z;
+
+
+    if (N < 4 || N > 12) return -1;
+
+    for (i = 0; i < N; i++) {
+        rotE(sats[i], B[i], B[i]+1, B[i]+2);
+        B[i][3] = sats[i].PR;
+    }
+
+    if (N == 4) {
+        matrix_invert(B, (double (*)[4])BBB);
+    }
+    else {
+        for (i = 0; i < 4; i++) {
+            for (j = 0; j < 4; j++) {
+                BtB[i][j] = 0.0;
+                for (k = 0; k < N; k++) {
+                    BtB[i][j] += B[k][i]*B[k][j];
+                }
+            }
+        }
+        matrix_invert(BtB, BBinv);
+        for (i = 0; i < 4; i++) {
+            for (j = 0; j < N; j++) {
+                BBB[i][j] = 0.0;
+                for (k = 0; k < 4; k++) {
+                    BBB[i][j] += BBinv[i][k]*B[j][k];
+                }
+            }
+        }
+    }
+
+    for (i = 0; i < 4; i++) {
+        Be[i] = 0.0;
+        for (k = 0; k < N; k++) {
+            Be[i] += BBB[i][k]*1.0;
+        }
+    }
+
+    for (i = 0; i < N; i++) {
+        a[i] = 0.5 * lorentz(B[i], B[i]);
+    }
+
+    for (i = 0; i < 4; i++) {
+        Ba[i] = 0.0;
+        for (k = 0; k < N; k++) {
+            Ba[i] += BBB[i][k]*a[k];
+        }
+    }
+
+    q2 = lorentz(Be, Be);
+    q1 = lorentz(Ba, Be)-1;
+    q0 = lorentz(Ba, Ba);
+
+    if (q2 == 0) return -2;
+
+    p = q1/q2;
+    q = q0/q2;
+
+    sq = p*p - q;
+    if (sq < 0) return -2;
+
+    x1 = -p + sqrt(sq);
+    x2 = -p - sqrt(sq);
+
+    for (i = 0; i < 4; i++) {
+        Lsg1[i] = x1*Be[i]+Ba[i];
+        Lsg2[i] = x2*Be[i]+Ba[i];
+    }
+    Lsg1[3] = -Lsg1[3];
+    Lsg2[3] = -Lsg2[3];
+
+
+    tmp1 = sqrt( Lsg1[0]*Lsg1[0] + Lsg1[1]*Lsg1[1] + Lsg1[2]*Lsg1[2] );
+    tmp2 = sqrt( Lsg2[0]*Lsg2[0] + Lsg2[1]*Lsg2[1] + Lsg2[2]*Lsg2[2] );
+
+    tmp1 = fabs( tmp1 - 6371000.0 );
+    tmp2 = fabs( tmp2 - 6371000.0 );
+
+    if (tmp1 < tmp2) {
+        X = Lsg1[0]; Y = Lsg1[1]; Z = Lsg1[2]; *cc = Lsg1[3];
+    } else {
+        X = Lsg2[0]; Y = Lsg2[1]; Z = Lsg2[2]; *cc = Lsg2[3];
+    }
+    pos_ecef[0] = X;
+    pos_ecef[1] = Y;
+    pos_ecef[2] = Z;
+
+    return 0;
+}
+
+/* ---------------------------------------------------------------------------------------------------- */
+
+int NAV_bancroft3(int N, SAT_t sats[], double pos_ecef1[3], double *cc1 , double pos_ecef2[3], double *cc2) {
+
+    int i, j, k;
+    double B[N][4], BtB[4][4], BBinv[4][4], BBB[4][N];
+    double a[N], Be[4], Ba[4];
+
+    double q0, q1, q2, p, q, sq, x1, x2;
+    double Lsg1[4], Lsg2[4];
+
+    double tmp1, tmp2;
+    double X1, Y1, Z1;
+    double X2, Y2, Z2;
+
+
+    if (N < 4 || N > 12) return -1;
+
+    for (i = 0; i < N; i++) {  // Test: nicht hier rotieren, sondern spaeter Lsg rotieren...
+        rotZ(sats[i].X, sats[i].Y, sats[i].Z, 0.0, B[i], B[i]+1, B[i]+2);
+        //B[i][3] = sats[i].PR;
+        B[i][3] = sats[i].pseudorange + sats[i].clock_corr;
+    }
+
+    if (N == 4) {
+        matrix_invert(B, (double (*)[4])BBB);
+    }
+    else {
+        for (i = 0; i < 4; i++) {
+            for (j = 0; j < 4; j++) {
+                BtB[i][j] = 0.0;
+                for (k = 0; k < N; k++) {
+                    BtB[i][j] += B[k][i]*B[k][j];
+                }
+            }
+        }
+        matrix_invert(BtB, BBinv);
+        for (i = 0; i < 4; i++) {
+            for (j = 0; j < N; j++) {
+                BBB[i][j] = 0.0;
+                for (k = 0; k < 4; k++) {
+                    BBB[i][j] += BBinv[i][k]*B[j][k];
+                }
+            }
+        }
+    }
+
+    for (i = 0; i < 4; i++) {
+        Be[i] = 0.0;
+        for (k = 0; k < N; k++) {
+            Be[i] += BBB[i][k]*1.0;
+        }
+    }
+
+    for (i = 0; i < N; i++) {
+        a[i] = 0.5 * lorentz(B[i], B[i]);
+    }
+
+    for (i = 0; i < 4; i++) {
+        Ba[i] = 0.0;
+        for (k = 0; k < N; k++) {
+            Ba[i] += BBB[i][k]*a[k];
+        }
+    }
+
+    q2 = lorentz(Be, Be);
+    q1 = lorentz(Ba, Be)-1;
+    q0 = lorentz(Ba, Ba);
+
+    if (q2 == 0) return -2;
+
+    p = q1/q2;
+    q = q0/q2;
+
+    sq = p*p - q;
+    if (sq < 0) return -2;
+
+    x1 = -p + sqrt(sq);
+    x2 = -p - sqrt(sq);
+
+    for (i = 0; i < 4; i++) {
+        Lsg1[i] = x1*Be[i]+Ba[i];
+        Lsg2[i] = x2*Be[i]+Ba[i];
+    }
+    Lsg1[3] = -Lsg1[3];
+    Lsg2[3] = -Lsg2[3];
+
+
+    tmp1 = sqrt( Lsg1[0]*Lsg1[0] + Lsg1[1]*Lsg1[1] + Lsg1[2]*Lsg1[2] );
+    tmp2 = sqrt( Lsg2[0]*Lsg2[0] + Lsg2[1]*Lsg2[1] + Lsg2[2]*Lsg2[2] );
+
+    tmp1 = tmp1 - 6371000.0;
+    tmp2 = tmp2 - 6371000.0;
+
+    if ( fabs(tmp1) < fabs(tmp2) ) {
+        X1 = Lsg1[0]; Y1 = Lsg1[1]; Z1 = Lsg1[2]; *cc1 = Lsg1[3];
+        X2 = Lsg2[0]; Y2 = Lsg2[1]; Z2 = Lsg2[2]; *cc2 = Lsg2[3];
+    } else {
+        X1 = Lsg2[0]; Y1 = Lsg2[1]; Z1 = Lsg2[2]; *cc1 = Lsg2[3];
+        X2 = Lsg1[0]; Y2 = Lsg1[1]; Z2 = Lsg1[2]; *cc2 = Lsg1[3];
+    }
+
+    rotZ(X1, Y1, Z1, EARTH_ROTATION_RATE*RANGE_ESTIMATE, pos_ecef1, pos_ecef1+1, pos_ecef1+2);
+    rotZ(X2, Y2, Z2, EARTH_ROTATION_RATE*RANGE_ESTIMATE, pos_ecef2, pos_ecef2+1, pos_ecef2+2);
+
+    return 0;
+}
+
+
+/* ---------------------------------------------------------------------------------------------------- */
+/* ---------------------------------------------------------------------------------------------------- */
+//
+// Satellite Position and Velocity
+//
+
+void GPS_SatelliteClockDriftCorrection(
+  const unsigned short transmission_gpsweek,   // GPS week when signal was transmit (0-1024+)            [weeks]
+  const double         transmission_gpstow,    // GPS time of week when signal was transmit              [s]
+  const unsigned short ephem_week,             // ephemeris: GPS week (0-1024+)                          [weeks]
+  const double         toe,                    // ephemeris: time of week                                [s]
+  const double         toc,                    // ephemeris: clock reference time of week                [s]
+  const double         af0,                    // ephemeris: polynomial clock correction coefficient     [s],
+  const double         af1,                    // ephemeris: polynomial clock correction coefficient     [s/s],
+  const double         af2,                    // ephemeris: polynomial clock correction coefficient     [s/s^2]
+  const double         ecc,                    // ephemeris: eccentricity of satellite orbit             []
+  const double         sqrta,                  // ephemeris: square root of the semi-major axis of orbit [m^(1/2)]
+  const double         delta_n,                // ephemeris: mean motion difference from computed value  [rad]
+  const double         m0,                     // ephemeris: mean anomaly at reference time              [rad]
+  const double         tgd,                    // ephemeris: group delay differential between L1 and L2  [s]
+  double*  clock_correction,                   // ephemeris: satellite clock correction                  [m]
+  double*  clock_drift )                       // ephemeris: satellite clock drift correction            [m/s]
+{
+    int j;
+
+    double tot;    // time of transmission (including gps week) [s]
+    double tk;     // time from ephemeris reference epoch       [s]
+    double tc;     // time from clock reference epoch           [s]
+    double d_tr;   // relativistic correction term              [s]
+    double d_tsv;  // SV PRN code phase time offset             [s]
+    double a;      // semi-major axis of orbit                  [m]
+    double n;      // corrected mean motion                     [rad/s]
+    double M;      // mean anomaly,                             [rad]
+    double E;      // eccentric anomaly                         [rad]
+
+    // compute the times from the reference epochs
+    tot = transmission_gpsweek*SECONDS_IN_WEEK + transmission_gpstow;
+    tk  = tot - (ephem_week*SECONDS_IN_WEEK + toe);
+    tc  = tot - (ephem_week*SECONDS_IN_WEEK + toc);
+
+    // compute the corrected mean motion term
+    a = sqrta*sqrta;
+    n = sqrt( GRAVITY_CONSTANT / (a*a*a) ); //  mean motion
+    n += delta_n; // corrected mean motion
+
+    // Kepler-Gleichung  M = E - e sin(E)
+    M = m0 + n*tk; // mean anomaly
+    E = M;                         // f(E) = M + e sin(E)  hat Fixpunkt fuer e < 1,
+    for( j = 0; j < 7; j++ ) {     // da |f'(E)|=|e cos(E)|<1.
+        E = M + ecc * sin(E);      // waehle Startwert E_1 = M, E_{k+1} = f(E_k)
+    }                              // konvergiert langsam gegen E_0 = f(E_0)
+
+    // relativistic correction
+    d_tr = RELATIVISTIC_CLOCK_CORRECTION * ecc * sqrta * sin(E); // [s]
+    d_tr *= LIGHTSPEED;
+
+    // clock correction
+    d_tsv = af0 + af1*tc + af2*tc*tc; // [s]
+
+    // L1 only
+    d_tsv -= tgd; // [s]
+
+    // clock correction
+    *clock_correction = d_tsv*LIGHTSPEED + d_tr; // [m]
+
+    // clock drift
+    *clock_drift = (af1 + 2.0*af2*tc) * LIGHTSPEED; // [m/s]
+
+}
+
+void GPS_ComputeSatellitePositionVelocity(
+  const unsigned short transmission_gpsweek,  // GPS week when signal was transmit (0-1024+)                            [weeks]
+  const double         transmission_gpstow,   // GPS time of week when signal was transmit                              [s]
+  const unsigned short ephem_week,            // ephemeris: GPS week (0-1024+)                                          [weeks]
+  const double         toe,                   // ephemeris: time of week                                                [s]
+  const double         m0,                    // ephemeris: mean anomaly at reference time                              [rad]
+  const double         delta_n,               // ephemeris: mean motion difference from computed value                  [rad]
+  const double         ecc,                   // ephemeris: eccentricity                                                []
+  const double         sqrta,                 // ephemeris: square root of the semi-major axis                          [m^(1/2)]
+  const double         omega0,                // ephemeris: longitude of ascending node of orbit plane at weekly epoch  [rad]
+  const double         i0,                    // ephemeris: inclination angle at reference time                         [rad]
+  const double         w,                     // ephemeris: argument of perigee                                         [rad]
+  const double         omegadot,              // ephemeris: rate of right ascension                                     [rad/s]
+  const double         idot,                  // ephemeris: rate of inclination angle                                   [rad/s]
+  const double         cuc,                   // ephemeris: cos harmonic correction term to the argument of latitude    [rad]
+  const double         cus,                   // ephemeris: sin harmonic correction term to the argument of latitude    [rad]
+  const double         crc,                   // ephemeris: cos harmonic correction term to the orbit radius            [m]
+  const double         crs,                   // ephemeris: sin harmonic correction term to the orbit radius            [m]
+  const double         cic,                   // ephemeris: cos harmonic correction term to the angle of inclination    [rad]
+  const double         cis,                   // ephemeris: sin harmonic correction term to the angle of inclination    [rad]
+  double* x,                                  // satellite x            [m]
+  double* y,                                  // satellite y            [m]
+  double* z,                                  // satellite z            [m]
+  double* vx,                                 // satellite velocity x   [m/s]
+  double* vy,                                 // satellite velocity y   [m/s]
+  double* vz )                                // satellite velocity z   [m/s]
+{
+    int j;
+
+    double tot;        // time of transmission (including gps week) [s]
+    double tk;         // time from ephemeris reference epoch       [s]
+    double a;          // semi-major axis of orbit                  [m]
+    double n;          // corrected mean motion                     [rad/s]
+    double M;          // mean anomaly,                             [rad]
+    double E;          // eccentric anomaly                         [rad]
+    double v;          // true anomaly                              [rad]
+    double u;          // argument of latitude, corrected           [rad]
+    double r;          // radius in the orbital plane               [m]
+    double i;          // orbital inclination                       [rad]
+    double cos2u;      // cos(2*u)                                  []
+    double sin2u;      // sin(2*u)                                  []
+    double d_u;        // argument of latitude correction           [rad]
+    double d_r;        // radius correction                         [m]
+    double d_i;        // inclination correction                    [rad]
+    double x_op;       // x position in the orbital plane           [m]
+    double y_op;       // y position in the orbital plane           [m]
+    double omegak;     // corrected longitude of the ascending node [rad]
+    double cos_omegak; // cos(omegak)
+    double sin_omegak; // sin(omegak)
+    double cosu;       // cos(u)
+    double sinu;       // sin(u)
+    double cosi;       // cos(i)
+    double sini;       // sin(i)
+    double cosE;       // cos(E)
+    double sinE;       // sin(E)
+
+
+    // compute the times from the reference epochs
+    tot = transmission_gpsweek*SECONDS_IN_WEEK + transmission_gpstow;
+    tk  = tot - (ephem_week*SECONDS_IN_WEEK + toe);
+
+    // compute the corrected mean motion term
+    a = sqrta*sqrta;
+    n = sqrt( GRAVITY_CONSTANT / (a*a*a) ); // computed mean motion
+    n += delta_n; // corrected mean motion
+
+    // Kepler-Gleichung  M = E - e sin(E)
+    M = m0 + n*tk; // mean anomaly
+    E = M;                         // f(E) = M + e sin(E)  hat Fixpunkt fuer e < 1,
+    for( j = 0; j < 7; j++ ) {     // da |f'(E)|=|e cos(E)|<1.
+        E = M + ecc * sin(E);      // waehle Startwert E_1 = M, E_{k+1} = f(E_k)
+    }                              // konvergiert langsam gegen E_0 = f(E_0)
+
+    cosE = cos(E);
+    sinE = sin(E);
+
+    // true anomaly
+    v = atan2( (sqrt(1.0 - ecc*ecc)*sinE),  (cosE - ecc) );
+    // argument of latitude
+    u = v + w;
+    // radius in orbital plane
+    r = a * (1.0 - ecc * cos(E));
+    // orbital inclination
+    i = i0;
+
+    // second harmonic perturbations
+    //
+    cos2u = cos(2.0*u);
+    sin2u = sin(2.0*u);
+    // argument of latitude correction
+    d_u = cuc * cos2u  +  cus * sin2u;
+    // radius correction
+    d_r = crc * cos2u  +  crs * sin2u;
+    // correction to inclination
+    d_i = cic * cos2u  +  cis * sin2u;
+
+    // corrected argument of latitude
+    u += d_u;
+    // corrected radius
+    r += d_r;
+    // corrected inclination
+    i += d_i + idot * tk;
+
+    // positions in orbital plane
+    cosu = cos(u);
+    sinu = sin(u);
+    x_op = r * cosu;
+    y_op = r * sinu;
+
+
+    omegak = omega0 + omegadot*tk - EARTH_ROTATION_RATE*(tk + toe);
+    // fuer Bestimmung der Satellitenposition in ECEF, range=0;
+    // fuer GPS-Loesung (Sats in ECI) Erdrotation hinzuziehen:
+    // rotZ(EARTH_ROTATION_RATE*0.072), 0.072s*299792458m/s=21585057m
+
+    // compute the WGS84 ECEF coordinates,
+    // vector r with components x & y is now rotated using, R3(-omegak)*R1(-i)
+    cos_omegak = cos(omegak);
+    sin_omegak = sin(omegak);
+    cosi = cos(i);
+    sini = sin(i);
+
+    *x = x_op * cos_omegak - y_op * sin_omegak * cosi;
+    *y = x_op * sin_omegak + y_op * cos_omegak * cosi;
+    *z = y_op * sini;
+
+
+  // Satellite Velocity Computations are below
+  // see Reference
+  // Remodi, B. M (2004). GPS Tool Box: Computing satellite velocities using the broadcast ephemeris.
+  // GPS Solutions. Volume 8(3), 2004. pp. 181-183
+  //
+  // example source code was available at [http://www.ngs.noaa.gov/gps-toolbox/bc_velo/bc_velo.c]
+
+  // recomputed the cos and sin of the corrected argument of latitude
+
+  double omegadotk;  // corrected rate of right ascension         [rad/s]
+  double edot;       // edot = n/(1.0 - ecc*cos(E)),              [rad/s]
+  double vdot;       // d/dt of true anomaly                      [rad/s]
+  double udot;       // d/dt of argument of latitude              [rad/s]
+  double idotdot;    // d/dt of the rate of the inclination angle [rad/s^2]
+  double rdot;       // d/dt of the radius in the orbital plane   [m/s]
+  double tmpa;       // temp
+  double tmpb;       // temp
+  double vx_op;      // x velocity in the orbital plane           [m/s]
+  double vy_op;      // y velocity in the orbital plane           [m/s]
+
+  cos2u = cos(2.0*u);
+  sin2u = sin(2.0*u);
+
+  edot  = n / (1.0 - ecc*cosE);
+  vdot  = sinE*edot*(1.0 + ecc*cos(v)) / ( sin(v)*(1.0-ecc*cosE) );
+  udot  = vdot + 2.0*(cus*cos2u - cuc*sin2u)*vdot;
+  rdot  = a*ecc*sinE*n/(1.0-ecc*cosE) + 2.0*(crs*cos2u - crc*sin2u)*vdot;
+  idotdot = idot + (cis*cos2u - cic*sin2u)*2.0*vdot;
+
+  vx_op = rdot*cosu - y_op*udot;
+  vy_op = rdot*sinu + x_op*udot;
+
+                                               // corrected rate of right ascension including similarily as above,
+                                               //  for omegak, compensation for the Sagnac effect
+  omegadotk =  omegadot - EARTH_ROTATION_RATE  /* - EARTH_ROTATION_RATE*RANGERATE_ESTIMATE/LIGHTSPEED */ ;
+
+  tmpa = vx_op - y_op*cosi*omegadotk;
+  tmpb = x_op*omegadotk + vy_op*cosi - y_op*sini*idotdot;
+
+  *vx = tmpa * cos_omegak - tmpb * sin_omegak;
+  *vy = tmpa * sin_omegak + tmpb * cos_omegak;
+  *vz = vy_op*sini + y_op*cosi*idotdot;
+}
+
+void GPS_SatellitePositionVelocity_Ephem(
+  const unsigned short gpsweek,      // gps week of signal transmission (0-1024+)            [week]
+  const double         gpstow,       // time of week of signal transmission  (gpstow-psr/c)  [s]
+  EPHEM_t ephem,
+  double* clock_correction,   // clock correction for this satellite for this epoch           [m]
+  double* clock_drift,        // clock correction for this satellite for this epoch           [m]
+  double* satX,               // satellite X position WGS84 ECEF                              [m]
+  double* satY,               // satellite Y position WGS84 ECEF                              [m]
+  double* satZ,               // satellite Z position WGS84 ECEF                              [m]
+  double* satvX,              // satellite X velocity WGS84 ECEF                              [m]
+  double* satvY,              // satellite Y velocity WGS84 ECEF                              [m]
+  double* satvZ               // satellite Z velocity WGS84 ECEF                              [m]
+  )
+{
+    double tow;               // user time of week adjusted with the clock corrections [s]
+    double x;                 // sat X position [m]
+    double y;                 // sat Y position [m]
+    double z;                 // sat Z position [m]
+    double vx;                // sat vX velocity [m]
+    double vy;                // sat VY velocity [m]
+    double vz;                // sat VZ velocity [m]
+    unsigned short week;      // user week adjusted with the clock correction if needed [week]
+
+
+    x = y = z = 0.0;
+
+    GPS_SatelliteClockDriftCorrection( gpsweek, gpstow,
+        ephem.week, ephem.toe, ephem.toc, ephem.af0,
+        ephem.af1, ephem.af2, ephem.e, ephem.sqrta,
+        ephem.delta_n, ephem.M0, ephem.tgd, clock_correction, clock_drift );
+
+
+    // adjust for week rollover
+    week = gpsweek;
+    tow = gpstow + (*clock_correction)/LIGHTSPEED;
+    if ( tow < 0.0 ) {
+        tow += SECONDS_IN_WEEK;
+        week--;
+    }
+    if ( tow > SECONDS_IN_WEEK ) {
+        tow -= SECONDS_IN_WEEK;
+        week++;
+    }
+
+    //range = 0.072s*299792458m/s=21585057m
+    GPS_ComputeSatellitePositionVelocity( week, tow,
+        ephem.week, ephem.toe, ephem.M0, ephem.delta_n, ephem.e, ephem.sqrta,
+        ephem.Omega0, ephem.i0, ephem.w, ephem.OmegaDot, ephem.idot,
+        ephem.cuc, ephem.cus, ephem.crc, ephem.crs, ephem.cic, ephem.cis,
+        &x, &y, &z, &vx, &vy, &vz );
+
+    *satX = x;
+    *satY = y;
+    *satZ = z;
+    *satvX = vx;
+    *satvY = vy;
+    *satvZ = vz;
+
+}
+
+/* ---------------------------------------------------------------------------------------------------- */
+
+
+double NAV_relVel(LOC_t loc, VEL_t vel) {
+    double d;
+    double x,y,z;
+    double norm;
+
+    x = vel.X-loc.X;
+    y = vel.Y-loc.Y;
+    z = vel.Z-loc.Z;
+    norm = sqrt(x*x+y*y+z*z);
+    x /= norm;
+    y /= norm;
+    z /= norm;
+
+    d = vel.vX*x + vel.vY*y + vel.vZ*z;
+
+    return d;
+}
+
+int NAV_LinP(int N, SAT_t satv[], double pos_ecef[3], double dt,
+                    double dpos_ecef[3], double *cc) {
+
+    int i, j, k;
+    double B[N][4], Binv[4][N], BtB[4][4], BBinv[4][4];
+    double a[N], Ba[N];
+
+    double X, Y, Z;
+    double norm[N];
+    double range, obs_range, prox_range;
+
+    if (N < 4 || N > 12) return -1;
+
+    for (i = 0; i < N; i++) {
+
+        range = dist( pos_ecef[0], pos_ecef[1], pos_ecef[2], satv[i].X, satv[i].Y, satv[i].Z );
+        range /= LIGHTSPEED;
+        if (range < 0.06  ||  range > 0.1) range = RANGE_ESTIMATE;
+        rotZ(satv[i].X, satv[i].Y, satv[i].Z, EARTH_ROTATION_RATE*range, B[i], B[i]+1, B[i]+2);
+        //rotZ(satv[i].X, satv[i].Y, satv[i].Z, 0.0, B[i], B[i]+1, B[i]+2); // est. RANGE_RATE = 0.0
+
+        X = B[i][0]-pos_ecef[0];
+        Y = B[i][1]-pos_ecef[1];
+        Z = B[i][2]-pos_ecef[2];
+        norm[i] = sqrt(X*X+Y*Y+Z*Z);
+
+        B[i][0] = X/norm[i];
+        B[i][1] = Y/norm[i];
+        B[i][2] = Z/norm[i];
+
+        B[i][3] = 1;
+    }
+
+    if (N == 4) {
+        matrix_invert(B, (double (*)[4])Binv);
+    }
+    else {
+
+        for (i = 0; i < 4; i++) {
+            for (j = 0; j < 4; j++) {
+                BtB[i][j] = 0.0;
+                for (k = 0; k < N; k++) {
+                    BtB[i][j] += B[k][i]*B[k][j];
+                }
+            }
+        }
+        matrix_invert(BtB, BBinv);
+        for (i = 0; i < 4; i++) {
+            for (j = 0; j < N; j++) {
+                Binv[i][j] = 0.0;
+                for (k = 0; k < 4; k++) {
+                    Binv[i][j] += BBinv[i][k]*B[j][k];
+                }
+            }
+        }
+
+    }
+
+
+    for (i = 0; i < N; i++) {
+        obs_range = satv[i].pseudorange + satv[i].clock_corr; //satv[i].PR;
+        prox_range = norm[i] - dt;
+        a[i] = prox_range - obs_range;
+    }
+
+    for (i = 0; i < 4; i++) {
+        Ba[i] = 0.0;
+        for (k = 0; k < N; k++) {
+            Ba[i] += Binv[i][k]*a[k];
+        }
+    }
+
+    dpos_ecef[0] = Ba[0];
+    dpos_ecef[1] = Ba[1];
+    dpos_ecef[2] = Ba[2];
+
+    *cc = Ba[3];
+
+    return 0;
+}
+
+int NAV_LinV(int N, SAT_t satv[], double pos_ecef[3],
+                    double vel_ecef[3], double dt,
+                    double dvel_ecef[3], double *cc) {
+
+    int i, j, k;
+    double B[N][4], Binv[4][N], BtB[4][4], BBinv[4][4];
+    double a[N], Ba[N];
+
+    double X, Y, Z;
+    double norm[N];
+    double v_proj;
+    double obs_rate, prox_rate;
+    LOC_t loc;
+    VEL_t vel;
+
+    if (N < 4 || N > 12) return -1;
+
+    loc.X = pos_ecef[0];
+    loc.Y = pos_ecef[1];
+    loc.Z = pos_ecef[2];
+
+    if (N < 4 || N > 12) return -1;
+
+    for (i = 0; i < N; i++) {
+        rotZ(satv[i].X, satv[i].Y, satv[i].Z, EARTH_ROTATION_RATE*RANGE_ESTIMATE, B[i], B[i]+1, B[i]+2);
+        //rotZ(satv[i].X, satv[i].Y, satv[i].Z, 0.0, B[i], B[i]+1, B[i]+2); // est. RANGE_RATE = 0.0
+
+        X = B[i][0]-pos_ecef[0];
+        Y = B[i][1]-pos_ecef[1];
+        Z = B[i][2]-pos_ecef[2];
+        norm[i] = sqrt(X*X+Y*Y+Z*Z);
+        B[i][0] = X/norm[i];
+        B[i][1] = Y/norm[i];
+        B[i][2] = Z/norm[i];
+
+        // SatSpeed = sqrt( satv[i].vX*satv[i].vX + satv[i].vY*satv[i].vY + satv[i].vZ*satv[i].vZ );
+
+        B[i][3] = 1;
+    }
+
+    if (N == 4) {
+        matrix_invert(B, (double (*)[4])Binv);
+    }
+    else {
+
+        for (i = 0; i < 4; i++) {
+            for (j = 0; j < 4; j++) {
+                BtB[i][j] = 0.0;
+                for (k = 0; k < N; k++) {
+                    BtB[i][j] += B[k][i]*B[k][j];
+                }
+            }
+        }
+        matrix_invert(BtB, BBinv);
+        for (i = 0; i < 4; i++) {
+            for (j = 0; j < N; j++) {
+                Binv[i][j] = 0.0;
+                for (k = 0; k < 4; k++) {
+                    Binv[i][j] += BBinv[i][k]*B[j][k];
+                }
+            }
+        }
+
+    }
+
+
+    for (i = 0; i < N; i++) {
+        obs_rate = satv[i].pseudorate; // + satv[i].clock_drift;
+        vel.X = satv[i].X;
+        vel.Y = satv[i].Y;
+        vel.Z = satv[i].Z;
+        vel.vX = satv[i].vX - vel_ecef[0];
+        vel.vY = satv[i].vY - vel_ecef[1];
+        vel.vZ = satv[i].vZ - vel_ecef[2];
+        v_proj = NAV_relVel(loc, vel);
+        prox_rate = v_proj - dt;
+        a[i] = prox_rate - obs_rate;
+    }
+
+    for (i = 0; i < 4; i++) {
+        Ba[i] = 0.0;
+        for (k = 0; k < N; k++) {
+            Ba[i] += Binv[i][k]*a[k];
+        }
+    }
+
+    dvel_ecef[0] = Ba[0];
+    dvel_ecef[1] = Ba[1];
+    dvel_ecef[2] = Ba[2];
+
+    *cc = Ba[3];
+
+    return 0;
+}
+
diff --git a/libraries/SondeLib/nav_gps_vel.h b/libraries/SondeLib/nav_gps_vel.h
new file mode 100755
index 0000000..6bfcd7a
--- /dev/null
+++ b/libraries/SondeLib/nav_gps_vel.h
@@ -0,0 +1,148 @@
+
+
+typedef struct {
+    uint16_t prn;
+    uint16_t week;
+    uint32_t toa;
+    char   epoch[20];
+    double toe;
+    double toc;
+    double e;
+    double delta_n;
+    double delta_i;
+    double i0;
+    double OmegaDot;
+    double sqrta;
+    double Omega0;
+    double w;
+    double M0;
+    double tgd;
+    double idot;
+    double cuc;
+    double cus;
+    double crc;
+    double crs;
+    double cic;
+    double cis;
+    double af0;
+    double af1;
+    double af2;
+    int gpsweek;
+    uint16_t svn;
+    uint8_t  ura;
+    uint8_t  health;
+    uint8_t  conf;
+} EPHEM_t;
+
+
+typedef struct {
+    uint32_t t;
+    double pseudorange;
+    double pseudorate;
+    double clock_corr;
+    double clock_drift;
+    double X;
+    double Y;
+    double Z;
+    double vX;
+    double vY;
+    double vZ;
+    int ephhr;
+    double PR;
+    double ephtime;
+    int prn;
+} SAT_t;
+
+
+typedef struct {double X; double Y; double Z;} LOC_t;
+
+typedef struct {double  X;  double Y;  double Z;
+                double vX; double vY; double vZ;} VEL_t;
+
+
+double dist(double X1, double Y1, double Z1, double X2, double Y2, double Z2);
+
+void GPS_SatelliteClockCorrection(
+  const unsigned short transmission_gpsweek,   // GPS week when signal was transmit (0-1024+)            [weeks]
+  const double         transmission_gpstow,    // GPS time of week when signal was transmit              [s]
+  const unsigned short ephem_week,             // ephemeris: GPS week (0-1024+)                          [weeks]
+  const double         toe,                    // ephemeris: time of week                                [s]
+  const double         toc,                    // ephemeris: clock reference time of week                [s]
+  const double         af0,                    // ephemeris: polynomial clock correction coefficient     [s],
+  const double         af1,                    // ephemeris: polynomial clock correction coefficient     [s/s],
+  const double         af2,                    // ephemeris: polynomial clock correction coefficient     [s/s^2]
+  const double         ecc,                    // ephemeris: eccentricity of satellite orbit             []
+  const double         sqrta,                  // ephemeris: square root of the semi-major axis of orbit [m^(1/2)]
+  const double         delta_n,                // ephemeris: mean motion difference from computed value  [rad]
+  const double         m0,                     // ephemeris: mean anomaly at reference time              [rad]
+  const double         tgd,                    // ephemeris: group delay differential between L1 and L2  [s]
+  double*  clock_correction );
+
+void GPS_SatellitePosition_Ephem(
+  const unsigned short gpsweek,      // gps week of signal transmission (0-1024+)            [week]
+  const double         gpstow,       // time of week of signal transmission  (gpstow-psr/c)  [s]
+  EPHEM_t ephem,
+  double* clock_correction,  // clock correction for this satellite for this epoch           [m]
+  double* satX,              // satellite X position WGS84 ECEF                              [m]
+  double* satY,              // satellite Y position WGS84 ECEF                              [m]
+  double* satZ               // satellite Z position WGS84 ECEF                              [m]
+  );
+
+void GPS_SatelliteClockDriftCorrection(
+  const unsigned short transmission_gpsweek,   // GPS week when signal was transmit (0-1024+)            [weeks]
+  const double         transmission_gpstow,    // GPS time of week when signal was transmit              [s]
+  const unsigned short ephem_week,             // ephemeris: GPS week (0-1024+)                          [weeks]
+  const double         toe,                    // ephemeris: time of week                                [s]
+  const double         toc,                    // ephemeris: clock reference time of week                [s]
+  const double         af0,                    // ephemeris: polynomial clock correction coefficient     [s],
+  const double         af1,                    // ephemeris: polynomial clock correction coefficient     [s/s],
+  const double         af2,                    // ephemeris: polynomial clock correction coefficient     [s/s^2]
+  const double         ecc,                    // ephemeris: eccentricity of satellite orbit             []
+  const double         sqrta,                  // ephemeris: square root of the semi-major axis of orbit [m^(1/2)]
+  const double         delta_n,                // ephemeris: mean motion difference from computed value  [rad]
+  const double         m0,                     // ephemeris: mean anomaly at reference time              [rad]
+  const double         tgd,                    // ephemeris: group delay differential between L1 and L2  [s]
+  double*  clock_correction,                   // ephemeris: satellite clock correction                  [m]
+  double*  clock_drift )  ;
+
+void GPS_SatellitePositionVelocity_Ephem(
+  const unsigned short gpsweek,      // gps week of signal transmission (0-1024+)            [week]
+  const double         gpstow,       // time of week of signal transmission  (gpstow-psr/c)  [s]
+  EPHEM_t ephem,
+  double* clock_correction,   // clock correction for this satellite for this epoch           [m]
+  double* clock_drift,        // clock correction for this satellite for this epoch           [m]
+  double* satX,               // satellite X position WGS84 ECEF                              [m]
+  double* satY,               // satellite Y position WGS84 ECEF                              [m]
+  double* satZ,               // satellite Z position WGS84 ECEF                              [m]
+  double* satvX,              // satellite X velocity WGS84 ECEF                              [m]
+  double* satvY,              // satellite Y velocity WGS84 ECEF                              [m]
+  double* satvZ               // satellite Z velocity WGS84 ECEF                              [m]
+  );
+
+
+  int NAV_ClosedFormSolution_FromPseudorange(
+  SAT_t sats[4],          // input:  satellite position and pseudorange
+  double* latitude,       // output: ellipsoid latitude  [rad]
+  double* longitude,      //         ellipsoid longitude [rad]
+  double* height,         //         ellipsoid height    [m]
+  double* rx_clock_bias,  //         receiver clock bias [m]
+  double pos_ecef[3] );  
+
+int calc_DOPn(int n, SAT_t satss[], double pos_ecef[3], double DOP[4]);
+
+int NAV_LinP(int N, SAT_t satv[], double pos_ecef[3], double dt,
+                    double dpos_ecef[3], double *cc); 
+void ecef2elli(double X, double Y, double Z, double *lat, double *lon, double *alt);
+
+int NAV_LinP(int N, SAT_t satv[], double pos_ecef[3], double dt,
+                    double dpos_ecef[3], double *cc); 
+
+int NAV_LinV(int N, SAT_t satv[], double pos_ecef[3],
+                    double vel_ecef[3], double dt,
+                    double dvel_ecef[3], double *cc);
+
+int NAV_bancroft1(int N, SAT_t sats[], double pos_ecef[3], double *cc);
+
+EPHEM_t *read_RNXpephs(const char *file);
+
+
diff --git a/libraries/SondeLib/rs92gps.cpp b/libraries/SondeLib/rs92gps.cpp
new file mode 100755
index 0000000..f011172
--- /dev/null
+++ b/libraries/SondeLib/rs92gps.cpp
@@ -0,0 +1,1735 @@
+/*  SPDX-License-Identifier:        GPL-3.0
+ *  based on https://github.com/rs1729/RS/blob/master/rs92/rs92gps.c
+ * 
+ *  radiosonde RS92
+ *
+ *
+ *  broadcast ephemeris:
+ *  http://cddis.gsfc.nasa.gov/Data_and_Derived_Products/GNSS/broadcast_ephemeris_data.html
+ *  ftp://cddis.gsfc.nasa.gov/gnss/data/daily/YYYY/DDD/YYn/brdcDDD0.YYn.Z (updated)
+ *  ftp://cddis.gsfc.nasa.gov/gnss/data/daily/YYYY/brdc/brdcDDD0.YYn.Z (final)
+ *
+ *  SEM almanac:
+ *  https://celestrak.com/GPS/almanac/SEM/
+ *
+ *  GPS calendar:
+ *  http://adn.agi.com/GNSSWeb/
+ *
+ *  GPS-Hoehe ueber Ellipsoid, Geoid-Hoehe:
+ *  http://geographiclib.sourceforge.net/cgi-bin/GeoidEval
+ */
+
+/*
+    gcc rs92gps.c -lm -o rs92gps
+    (includes nav_gps_vel.c)
+
+    examples:
+
+    sox -t oss /dev/dsp -t wav - lowpass 2600 2>/dev/null | ./rs92gps -e brdc3050.15n
+
+    ./rs92gps -r 2015_11_01.wav > raw1.out
+    sox -t oss /dev/dsp -t wav - lowpass 2600 2>/dev/null | stdbuf -oL ./rs92gps -r > raw2.out
+    ./rs92gps --dop 5 -gg -e brdc3050.15n --rawin1 raw.out
+
+    sox -t oss /dev/dsp -t wav - lowpass 2600 2>/dev/null | tee audio.wav | ./rs92gps -e brdc3050.15n
+    ./rs92gps -g1 -e brdc3050.15n 2015_11_01-14.wav | tee out1.txt
+    ./rs92gps -g2 -e brdc3050.15n 2015_11_01-14.wav | tee out2.txt
+    sox 2015_11_01.wav -t wav - lowpass 2600 2>/dev/null | ./rs92gps -gg -e brdc3050.15n | tee out3.txt
+
+    sox -t oss /dev/dsp -t wav - lowpass 2600 2>/dev/null | stdbuf -oL ./rs92gps -e brdc3050.15n > out1.txt
+    sox -t oss /dev/dsp -t wav - lowpass 2600 2>/dev/null | stdbuf -oL ./rs92gps -e brdc3050.15n | tee out2.txt
+
+*/
+
+#if 1
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <stdint.h>
+#endif
+
+#include <SPIFFS.h>
+#include "nav_gps_vel.h"
+#include "rs92gps.h"
+#include "Sonde.h"
+
+
+
+gpx_t gpx;
+
+int option_verbose = 0,  // ausfuehrliche Anzeige
+    option_raw = 1,      // rohe Frames
+    option_inv = 0,      // invertiert Signal
+    option_res = 0,      // genauere Bitmessung
+    option_crc = 0,      // check CRC
+    option_avg = 0,      // moving average
+    option_b = 0,
+    fileloaded = 0,
+    option_vergps = 0,
+    option_iter = 0,
+    option_vel = 0,      // velocity
+    option_aux = 0,      // Aux/Ozon
+    option_der = 0,      // linErr
+    rawin = 0;
+double dop_limit = 9.9;
+double d_err = 10000;
+
+int rollover = 0,
+    err_gps = 0;
+
+int almanac = 0,
+    ephem = 0;
+
+int exSat = -1;
+
+#if 0
+/* --- RS92-SGP: 8N1 manchester --- */
+#define BITS (2*(1+8+1))  // 20
+#define HEADOFS 40 //  HEADOFS+HEADLEN = 120  (bis 0x10)
+#define HEADLEN 80 // (HEADOFS+HEADLEN) mod BITS = 0
+/*
+#define HEADOFS 0  // HEADOFS muss 0 wegen Wiederholung
+#define HEADLEN 60 // HEADLEN < 100, (HEADOFS+HEADLEN) mod BITS = 0
+*/
+#define FRAMESTART ((HEADOFS+HEADLEN)/BITS)
+
+/*               2A                  10*/
+char header[] = "10100110011001101001"
+                "10100110011001101001"
+                "10100110011001101001"
+                "10100110011001101001"
+                "1010011001100110100110101010100110101001";
+char buf[HEADLEN+1] = "x";
+#endif
+
+int bufpos = -1;
+
+#define FRAME_LEN 240
+uint8_t frame[FRAME_LEN] = { 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x10};
+/* --- RS92-SGP ------------------- */
+
+
+char buffer_rawin[3*FRAME_LEN+8]; //## rawin1: buffer_rawin[2*FRAME_LEN+4];
+int frameofs = 0;
+
+#define MASK_LEN 64
+uint8_t mask[MASK_LEN] = { 0x96, 0x83, 0x3E, 0x51, 0xB1, 0x49, 0x08, 0x98,
+                         0x32, 0x05, 0x59, 0x0E, 0xF9, 0x44, 0xC6, 0x26,
+                         0x21, 0x60, 0xC2, 0xEA, 0x79, 0x5D, 0x6D, 0xA1,
+                         0x54, 0x69, 0x47, 0x0C, 0xDC, 0xE8, 0x5C, 0xF1,
+                         0xF7, 0x76, 0x82, 0x7F, 0x07, 0x99, 0xA2, 0x2C,
+                         0x93, 0x7C, 0x30, 0x63, 0xF5, 0x10, 0x2E, 0x61,
+                         0xD0, 0xBC, 0xB4, 0xB6, 0x06, 0xAA, 0xF4, 0x23,
+                         0x78, 0x6E, 0x3B, 0xAE, 0xBF, 0x7B, 0x4C, 0xC1};
+/* LFSR: ab i=8 (mod 64):
+ * m[16+i] = m[i] ^ m[i+2] ^ m[i+4] ^ m[i+6]
+ * ________________3205590EF944C6262160C2EA795D6DA15469470CDCE85CF1
+ * F776827F0799A22C937C3063F5102E61D0BCB4B606AAF423786E3BAEBF7B4CC196833E51B1490898
+ */
+
+/* ------------------------------------------------------------------------------------ */
+
+#define BAUD_RATE 4800
+
+int sample_rate = 0, bits_sample = 0, channels = 0;
+float samples_per_bit = 0;
+
+int findstr(char *buff, char *str, int pos) {
+    int i;
+    for (i = 0; i < 4; i++) {
+        if (buff[(pos+i)%4] != str[i]) break;
+    }
+    return i;
+}
+
+#if 0
+int read_wav_header(FILE *fp) {
+    char txt[4+1] = "\0\0\0\0";
+    unsigned char dat[4];
+    int byte, p=0;
+
+    if (fread(txt, 1, 4, fp) < 4) return -1;
+    if (strncmp(txt, "RIFF", 4)) return -1;
+    if (fread(txt, 1, 4, fp) < 4) return -1;
+    // pos_WAVE = 8L
+    if (fread(txt, 1, 4, fp) < 4) return -1;
+    if (strncmp(txt, "WAVE", 4)) return -1;
+    // pos_fmt = 12L
+    for ( ; ; ) {
+        if ( (byte=fgetc(fp)) == EOF ) return -1;
+        txt[p % 4] = byte;
+        p++; if (p==4) p=0;
+        if (findstr(txt, "fmt ", p) == 4) break;
+    }
+    if (fread(dat, 1, 4, fp) < 4) return -1;
+    if (fread(dat, 1, 2, fp) < 2) return -1;
+
+    if (fread(dat, 1, 2, fp) < 2) return -1;
+    channels = dat[0] + (dat[1] << 8);
+
+    if (fread(dat, 1, 4, fp) < 4) return -1;
+    memcpy(&sample_rate, dat, 4); //sample_rate = dat[0]|(dat[1]<<8)|(dat[2]<<16)|(dat[3]<<24);
+
+    if (fread(dat, 1, 4, fp) < 4) return -1;
+    if (fread(dat, 1, 2, fp) < 2) return -1;
+    //byte = dat[0] + (dat[1] << 8);
+
+    if (fread(dat, 1, 2, fp) < 2) return -1;
+    bits_sample = dat[0] + (dat[1] << 8);
+
+    // pos_dat = 36L + info
+    for ( ; ; ) {
+        if ( (byte=fgetc(fp)) == EOF ) return -1;
+        txt[p % 4] = byte;
+        p++; if (p==4) p=0;
+        if (findstr(txt, "data", p) == 4) break;
+    }
+    if (fread(dat, 1, 4, fp) < 4) return -1;
+
+
+    Serial.printf("sample_rate: %d\n", sample_rate);
+    Serial.printf("bits       : %d\n", bits_sample);
+    Serial.printf("channels   : %d\n", channels);
+
+    if ((bits_sample != 8) && (bits_sample != 16)) return -1;
+
+    samples_per_bit = sample_rate/(float)BAUD_RATE;
+
+    Serial.printf("samples/bit: %.2f\n", samples_per_bit);
+
+    return 0;
+}
+#endif
+
+#if 0
+#define EOF_INT  0x1000000
+
+#define LEN_movAvg 3
+int movAvg[LEN_movAvg];
+unsigned long sample_count = 0;
+double bitgrenze = 0;
+
+int read_signed_sample(FILE *fp) {  // int = i32_t
+    int byte, i, sample, s=0;       // EOF -> 0x1000000
+
+    for (i = 0; i < channels; i++) {
+                           // i = 0: links bzw. mono
+        byte = fgetc(fp);
+        if (byte == EOF) return EOF_INT;
+        if (i == 0) sample = byte;
+
+        if (bits_sample == 16) {
+            byte = fgetc(fp);
+            if (byte == EOF) return EOF_INT;
+            if (i == 0) sample +=  byte << 8;
+        }
+
+    }
+
+    if (bits_sample ==  8)  s = sample-128;   // 8bit: 00..FF, centerpoint 0x80=128
+    if (bits_sample == 16)  s = (short)sample;
+
+    if (option_avg) {
+        movAvg[sample_count % LEN_movAvg] = s;
+        s = 0;
+        for (i = 0; i < LEN_movAvg; i++) s += movAvg[i];
+        s = (s+0.5) / LEN_movAvg;
+    }
+
+    sample_count++;
+
+    return s;
+}
+
+int par=1, par_alt=1;
+
+int read_bits_fsk(FILE *fp, int *bit, int *len) {
+    static int sample;
+    int n, y0;
+    float l, x1;
+    static float x0;
+
+    n = 0;
+    do{
+        y0 = sample;
+        sample = read_signed_sample(fp);
+        if (sample == EOF_INT) return EOF;
+        //sample_count++; // in read_signed_sample()
+        par_alt = par;
+        par =  (sample >= 0) ? 1 : -1;  // 8bit: 0..127,128..255 (-128..-1,0..127)
+        n++;
+    } while (par*par_alt > 0);
+
+    if (!option_res) l = (float)n / samples_per_bit;
+    else {                                 // genauere Bitlaengen-Messung
+        x1 = sample/(float)(sample-y0);    // hilft bei niedriger sample rate
+        l = (n+x0-x1) / samples_per_bit;   // meist mehr frames (nicht immer)
+        x0 = x1;
+    }
+
+    *len = (int)(l+0.5);
+
+    if (!option_inv) *bit = (1+par_alt)/2;  // oben 1, unten -1
+    else             *bit = (1-par_alt)/2;  // sdr#<rev1381?, invers: unten 1, oben -1
+
+    /* Y-offset ? */
+
+    return 0;
+}
+
+int bitstart = 0;
+int read_rawbit(FILE *fp, int *bit) {
+    int sample;
+    int n, sum;
+
+    sum = 0;
+    n = 0;
+
+    if (bitstart) {
+        n = 1;    // d.h. bitgrenze = sample_count-1 (?)
+        bitgrenze = sample_count-1;
+        bitstart = 0;
+    }
+    bitgrenze += samples_per_bit;
+
+    do {
+        sample = read_signed_sample(fp);
+        if (sample == EOF_INT) return EOF;
+        //sample_count++; // in read_signed_sample()
+        //par =  (sample >= 0) ? 1 : -1;    // 8bit: 0..127,128..255 (-128..-1,0..127)
+        sum += sample;
+        n++;
+    } while (sample_count < bitgrenze);  // n < samples_per_bit
+
+    if (sum >= 0) *bit = 1;
+    else          *bit = 0;
+
+    if (option_inv) *bit ^= 1;
+
+    return 0;
+}
+
+/* ------------------------------------------------------------------------------------ */
+
+// manchester1 1->10,0->01: 1.bit
+// manchester2 0->10,1->01: 2.bit
+// RS92-SGP: 8N1 manchester2
+char manch(char *mbits) {
+   if      ((mbits[0] == 1) && (mbits[1] == 0)) return 0;
+   else if ((mbits[0] == 0) && (mbits[1] == 1)) return 1;
+   else return -1;
+}
+int bits2byte(char bits[]) {
+    int i, byteval=0, d=1;
+    int bit8[8];
+
+    if (manch(bits+0) != 0) return 0x100;
+    for (i = 0; i < 8; i++) {
+        bit8[i] = manch(bits+2*(i+1));
+    }
+    if (manch(bits+(2*(8+1))) != 1) return 0x100;
+
+    for (i = 0; i < 8; i++) {     // little endian
+        if      (bit8[i] == 1)  byteval += d;
+        else if (bit8[i] == 0)  byteval += 0;
+        else return 0x100;
+        d <<= 1;
+    }
+    return byteval;
+}
+
+
+void inc_bufpos() {
+  bufpos = (bufpos+1) % HEADLEN;
+}
+
+int compare() {
+    int i=0, j = bufpos;
+
+    while (i < HEADLEN) {
+        if (j < 0) j = HEADLEN-1;
+        if (buf[j] != header[HEADOFS+HEADLEN-1-i]) break;
+        j--;
+        i++;
+    }
+    return i;
+}
+#endif
+
+/*
+uint8_t xorbyte(int pos) {
+    return  xframe[pos] ^ mask[pos % MASK_LEN];
+}
+*/
+uint8_t framebyte(int pos) {
+    return  frame[pos];
+}
+
+
+/* ------------------------------------------------------------------------------------ */
+
+#define GPS_WEEK1024  1
+#define WEEKSEC       604800
+
+/*
+ * Convert GPS Week and Seconds to Modified Julian Day.
+ * - Adapted from sci.astro FAQ.
+ * - Ignores UTC leap seconds.
+ */
+
+void Gps2Date(long GpsWeek, long GpsSeconds, int *Year, int *Month, int *Day) {
+
+    long GpsDays, Mjd;
+    long J, C, Y, M;
+
+    GpsDays = GpsWeek * 7 + (GpsSeconds / 86400);
+    Mjd = 44244 + GpsDays;
+
+    J = Mjd + 2468570;
+    C = 4 * J / 146097;
+    J = J - (146097 * C + 3) / 4;
+    Y = 4000 * (J + 1) / 1461001;
+    J = J - 1461 * Y / 4 + 31;
+    M = 80 * J / 2447;
+    *Day = J - 2447 * M / 80;
+    J = M / 11;
+    *Month = M + 2 - (12 * J);
+    *Year = 100 * (C - 49) + Y + J;
+}
+
+/* ------------------------------------------------------------------------------------ */
+
+#define pos_FrameNb   0x08  // 2 byte
+#define pos_SondeID   0x0C  // 8 byte  // oder: 0x0A, 10 byte?
+#define pos_CalData   0x17  // 1 byte, counter 0x00..0x1f
+#define pos_Calfreq   0x1A  // 2 byte, calfr 0x00
+
+#define posGPS_TOW    0x48  // 4 byte
+#define posGPS_PRN    0x4E  // 12*5 bit in 8 byte
+#define posGPS_STATUS 0x56  // 12 byte
+#define posGPS_DATA   0x62  // 12*8 byte
+
+#define pos_PTU       0x2C  // 24 byte
+#define pos_AuxData   0xC8  // 8 byte
+
+
+#define BLOCK_CFG 0x6510  // frame[pos_FrameNb-2], frame[pos_FrameNb-1]
+#define BLOCK_PTU 0x690C
+#define BLOCK_GPS 0x673D  // frame[posGPS_TOW-2], frame[posGPS_TOW-1]
+#define BLOCK_AUX 0x6805
+
+#define LEN_CFG (2*(BLOCK_CFG & 0xFF))
+#define LEN_GPS (2*(BLOCK_GPS & 0xFF))
+#define LEN_PTU (2*(BLOCK_PTU & 0xFF))
+
+
+int crc16(int start, int len) {
+    int crc16poly = 0x1021;
+    int rem = 0xFFFF, i, j;
+    int byte;
+
+    if (start+len >= FRAME_LEN) return -1;
+
+    for (i = 0; i < len; i++) {
+        byte = framebyte(start+i);
+        rem = rem ^ (byte << 8);
+        for (j = 0; j < 8; j++) {
+            if (rem & 0x8000) {
+                rem = (rem << 1) ^ crc16poly;
+            }
+            else {
+                rem = (rem << 1);
+            }
+            rem &= 0xFFFF;
+        }
+    }
+    return rem;
+}
+
+int get_FrameNb() {
+    int i;
+    unsigned byte;
+    uint8_t frnr_bytes[2];
+    int frnr;
+
+    for (i = 0; i < 2; i++) {
+        byte = framebyte(pos_FrameNb + i);
+        frnr_bytes[i] = byte;
+    }
+
+    frnr = frnr_bytes[0] + (frnr_bytes[1] << 8);
+    gpx.frnr = frnr;
+
+    return 0;
+}
+
+int get_SondeID() {
+    int i, ret=0;
+    unsigned byte;
+    uint8_t sondeid_bytes[10];
+    int crc_frame, crc;
+
+    // BLOCK_CFG == frame[pos_FrameNb-2 .. pos_FrameNb-1] ?
+    crc_frame = framebyte(pos_FrameNb+LEN_CFG) | (framebyte(pos_FrameNb+LEN_CFG+1) << 8);
+    crc = crc16(pos_FrameNb, LEN_CFG);
+/*
+    if (option_crc) {
+      //fprintf(stdout, " (%04X:%02X%02X) ", BLOCK_CFG, frame[pos_FrameNb-2], frame[pos_FrameNb-1]);
+      fprintf(stdout, " [%04X:%04X] ", crc_frame, crc);
+    }
+*/
+    ret = 0;
+    if ( 0  &&  option_crc  &&  crc != crc_frame) {
+        ret = -2;  // erst wichtig, wenn Cal/Cfg-Data
+    }
+
+    for (i = 0; i < 8; i++) {
+        byte = framebyte(pos_SondeID + i);
+        if ((byte < 0x20) || (byte > 0x7E)) return -1;
+        sondeid_bytes[i] = byte;
+    }
+
+    for (i = 0; i < 8; i++) {
+        gpx.id[i] = sondeid_bytes[i];
+    }
+    gpx.id[8] = '\0';
+
+    return ret;
+}
+
+char weekday[7][3] = { "So", "Mo", "Di", "Mi", "Do", "Fr", "Sa"};
+
+int get_GPStime() {
+    int i, ret=0;
+    unsigned byte;
+    uint8_t gpstime_bytes[4];
+    int gpstime = 0, // 32bit
+        day;
+    int ms;
+    int crc_frame, crc;
+
+    // BLOCK_GPS == frame[posGPS_TOW-2 .. posGPS_TOW-1] ?
+    crc_frame = framebyte(posGPS_TOW+LEN_GPS) | (framebyte(posGPS_TOW+LEN_GPS+1) << 8);
+    crc = crc16(posGPS_TOW, LEN_GPS);
+/*
+    if (option_crc) {
+      //fprintf(stdout, " (%04X:%02X%02X) ", BLOCK_GPS, frame[posGPS_TOW-2], frame[posGPS_TOW-1]);
+      fprintf(stdout, " [%04X:%04X] ", crc_frame, crc);
+    }
+*/
+    ret = 0;
+    if (option_crc  &&  crc != crc_frame) {
+        ret = -2;
+    }
+
+    for (i = 0; i < 4; i++) {
+        byte = framebyte(posGPS_TOW + i);
+        gpstime_bytes[i] = byte;
+    }
+
+    memcpy(&gpstime, gpstime_bytes, 4);
+    ms = gpstime % 1000;
+    gpstime /= 1000;
+
+    gpx.gpssec = gpstime;
+    Serial.printf("GPS time is %04x (%d)\n", gpstime, gpstime);
+
+    day = (gpstime / (24 * 3600)) % 7;        // besser CRC-check, da auch
+    //if ((day < 0) || (day > 6)) return -1;  // gpssec=604800,604801 beobachtet
+
+    gpstime %= (24*3600);
+
+    gpx.wday = day;
+    gpx.std = gpstime / 3600;
+    gpx.min = (gpstime % 3600) / 60;
+    gpx.sek = gpstime % 60 + ms/1000.0;
+
+    return ret;
+}
+
+int get_Aux() {
+    int i;
+    unsigned short byte;
+
+    for (i = 0; i < 4; i++) {
+        byte = framebyte(pos_AuxData+2*i)+(framebyte(pos_AuxData+2*i+1)<<8);
+        gpx.aux[i] = byte;
+    }
+
+    return 0;
+}
+
+int get_Cal() {
+    int i;
+    unsigned byte;
+    uint8_t calfr = 0;
+    //uint8_t burst = 0;
+    int freq = 0;
+    uint8_t freq_bytes[2];
+
+    byte = framebyte(pos_CalData);
+    calfr = byte;
+
+    if (option_verbose == 4) {
+        fprintf(stdout, "\n");
+        fprintf(stdout, "[%5d] ", gpx.frnr);
+        fprintf(stdout, "  0x%02x:", calfr);
+    }
+    for (i = 0; i < 16; i++) {
+        byte = framebyte(pos_CalData+1+i);
+        if (option_verbose == 4) {
+            fprintf(stdout, " %02x", byte);
+        }
+    }
+    if (option_aux) {
+        get_Aux();
+        if (option_verbose == 4) {
+            fprintf(stdout, "  #  ");
+            for (i = 0; i < 8; i++) {
+                byte = framebyte(pos_AuxData+i);
+                fprintf(stdout, "%02x ", byte);
+            }
+        }
+        else {
+            if (gpx.aux[0] != 0 || gpx.aux[1] != 0 || gpx.aux[2] != 0 || gpx.aux[3] != 0) {
+                fprintf(stdout, " # %04x %04x %04x %04x", gpx.aux[0], gpx.aux[1], gpx.aux[2], gpx.aux[3]);
+            }
+        }
+    }
+
+    if (calfr == 0x00) {
+        for (i = 0; i < 2; i++) {
+            byte = framebyte(pos_Calfreq + i);
+            freq_bytes[i] = byte;
+        }
+        byte = freq_bytes[0] + (freq_bytes[1] << 8);
+        //fprintf(stdout, ":%04x ", byte);
+        freq = 400000 + 10*byte; // kHz;
+        gpx.freq = freq;
+        fprintf(stdout, " : fq %d kHz", freq);
+    }
+
+    return 0;
+}
+
+
+/* ---------------------------------------------------------------------------------------------------- */
+
+
+
+//we only use ephs  EPHEM_t alm[33];
+//EPHEM_t eph[33][24];
+EPHEM_t *ephs = NULL;
+
+SAT_t sat[33],
+      sat1s[33];
+
+
+uint8_t prn_le[12*5+4];
+/* le - little endian */
+int prnbits_le(uint16_t byte16, uint8_t bits[64], int block) {
+    int i; /* letztes bit Ueberlauf, wenn 3. PRN = 32 */
+    for (i = 0; i < 15; i++) {
+        bits[15*block+i] = byte16 & 1;
+        byte16 >>= 1;
+    }
+    bits[60+block] = byte16 & 1;
+    return byte16 & 1;
+}
+uint8_t prns[12], // PRNs in data
+      sat_status[12];
+int prn32toggle = 0x1, ind_prn32, prn32next;
+void prn12(uint8_t *prn_le, uint8_t prns[12]) {
+    int i, j, d;
+    for (i = 0; i < 12; i++) {
+        prns[i] = 0;
+        d = 1;
+        for (j = 0; j < 5; j++) {
+          if (prn_le[5*i+j]) prns[i] += d;
+          d <<= 1;
+        }
+    }
+    ind_prn32 = 32;
+    for (i = 0; i < 12; i++) {
+        // PRN-32 overflow
+        if ( (prns[i] == 0) && (sat_status[i] & 0x0F) ) {  // 5 bit: 0..31
+            if (  ((i % 3 == 2) && (prn_le[60+i/3] & 1))       // Spalte 2
+               || ((i % 3 != 2) && (prn_le[5*(i+1)] & 1)) ) {  // Spalte 0,1
+                prns[i] = 32; ind_prn32 = i;
+            }
+        }
+        else if ((sat_status[i] & 0x0F) == 0) {  // erste beiden bits: 0x03 ?
+            prns[i] = 0;
+        }
+    }
+
+    prn32next = 0;
+    if (ind_prn32 < 12) {
+        // PRN-32 overflow
+        if (ind_prn32 % 3 != 2) { // -> ind_prn32<11                            // vorausgesetzt im Block folgt auf PRN-32
+            if ((sat_status[ind_prn32+1] & 0x0F)  &&  prns[ind_prn32+1] > 1) {  // entweder PRN-1 oder PRN-gerade
+                                               // &&  prns[ind_prn32+1] != 3 ?
+                for (j = 0; j < ind_prn32; j++) {
+                    if (prns[j] == (prns[ind_prn32+1]^prn32toggle)  &&  (sat_status[j] & 0x0F)) break;
+                }
+                if (j < ind_prn32) { prn32toggle ^= 0x1; }
+                else {
+                    for (j = ind_prn32+2; j < 12; j++) {
+                        if (prns[j] == (prns[ind_prn32+1]^prn32toggle)  &&  (sat_status[j] & 0x0F)) break;
+                    }
+                    if (j < 12) { prn32toggle ^= 0x1; }
+                }
+                prns[ind_prn32+1] ^= prn32toggle;
+                /*
+                  // nochmal testen
+                  for (j = 0; j < ind_prn32; j++) { if (prns[j] == prns[ind_prn32+1]) break; }
+                  if (j < ind_prn32) prns[ind_prn32+1] = 0;
+                  else {
+                      for (j = ind_prn32+2; j < 12; j++) { if (prns[j] == prns[ind_prn32+1]) break; }
+                      if (j < 12) prns[ind_prn32+1] = 0;
+                  }
+                  if (prns[ind_prn32+1] == 0) { prn32toggle ^= 0x1; }
+                */
+            }
+            prn32next = prns[ind_prn32+1];  // ->  ind_prn32<11  &&  ind_prn32 % 3 != 2
+        }
+    }
+}
+
+
+int calc_satpos_alm(EPHEM_t alm[], double t, SAT_t *satp) {
+    return -1;
+#if 0
+    double X, Y, Z, vX, vY, vZ;
+    int j;
+    int week;
+    double cl_corr, cl_drift;
+
+    for (j = 1; j < 33; j++) {
+        if (alm[j].prn > 0) {  // prn==j
+
+            // Woche hat 604800 sec
+            if      (t-alm[j].toa >  WEEKSEC/2) rollover = +1;
+            else if (t-alm[j].toa < -WEEKSEC/2) rollover = -1;
+            else rollover = 0;
+            week = alm[j].week - rollover;
+            /*if (j == 1)*/ gpx.week = week + GPS_WEEK1024*1024;
+
+            if (option_vel >= 2) {
+                GPS_SatellitePositionVelocity_Ephem(
+                    week, t, alm[j],
+                    &cl_corr, &cl_drift, &X, &Y, &Z, &vX, &vY, &vZ
+                );
+                satp[alm[j].prn].clock_drift = cl_drift;
+                satp[alm[j].prn].vX = vX;
+                satp[alm[j].prn].vY = vY;
+                satp[alm[j].prn].vZ = vZ;
+            }
+            else {
+                GPS_SatellitePosition_Ephem(
+                    week, t, alm[j],
+                    &cl_corr, &X, &Y, &Z
+                );
+            }
+
+            satp[alm[j].prn].X = X;
+            satp[alm[j].prn].Y = Y;
+            satp[alm[j].prn].Z = Z;
+            satp[alm[j].prn].clock_corr = cl_corr;
+
+        }
+    }
+
+    return 0;
+#endif
+}
+
+int calc_satpos_rnx(EPHEM_t eph[][24], double t, SAT_t *satp) {
+    double X, Y, Z, vX, vY, vZ;
+    int j, i, ti;
+    int week = 0;
+    double cl_corr, cl_drift;
+    double tdiff, td;
+
+    for (j = 1; j < 33; j++) {
+
+        // Woche hat 604800 sec
+        tdiff = WEEKSEC;
+        ti = 0;
+        for (i = 0; i < 24; i++) {
+            if (eph[j][i].prn > 0) {
+                if      (t-eph[j][i].toe >  WEEKSEC/2) rollover = +1;
+                else if (t-eph[j][i].toe < -WEEKSEC/2) rollover = -1;
+                else rollover = 0;
+                td = t-eph[j][i].toe - rollover*WEEKSEC;
+                if (td < 0) td *= -1;
+
+                if ( td < tdiff ) {
+                    tdiff = td;
+                    ti = i;
+                    week = eph[j][ti].week - rollover;
+                    gpx.week = eph[j][ti].gpsweek - rollover;
+                }
+            }
+        }
+
+        if (option_vel >= 2) {
+            GPS_SatellitePositionVelocity_Ephem(
+                week, t, eph[j][ti],
+                &cl_corr, &cl_drift, &X, &Y, &Z, &vX, &vY, &vZ
+            );
+            satp[eph[j][ti].prn].clock_drift = cl_drift;
+            satp[eph[j][ti].prn].vX = vX;
+            satp[eph[j][ti].prn].vY = vY;
+            satp[eph[j][ti].prn].vZ = vZ;
+        }
+        else {
+            GPS_SatellitePosition_Ephem(
+                week, t, eph[j][ti],
+                &cl_corr, &X, &Y, &Z
+            );
+        }
+
+        satp[eph[j][ti].prn].X = X;
+        satp[eph[j][ti].prn].Y = Y;
+        satp[eph[j][ti].prn].Z = Z;
+        satp[eph[j][ti].prn].clock_corr = cl_corr;
+
+    }
+
+    return 0;
+}
+
+int calc_satpos_rnx2(EPHEM_t *eph, double t, SAT_t *satp) {
+    double X, Y, Z, vX, vY, vZ;
+    int j;
+    int week = 0;
+    double cl_corr, cl_drift;
+    double tdiff, td;
+    int count, count0, satfound;
+
+    for (j = 1; j < 33; j++) {
+
+        count = count0 = 1;
+        satfound = 0;
+
+        // Woche hat 604800 sec
+        tdiff = WEEKSEC;
+        while (eph[count].prn > 0) {
+            if (eph[count].prn == j) {
+
+                satfound += 1;
+
+                if      (t - eph[count].toe >  WEEKSEC/2) rollover = +1;
+                else if (t - eph[count].toe < -WEEKSEC/2) rollover = -1;
+                else rollover = 0;
+                td = fabs( t - eph[count].toe - rollover*WEEKSEC);
+
+                if ( td < tdiff ) {
+                    tdiff = td;
+                    week = eph[count].week - rollover;
+                    gpx.week = eph[count].gpsweek - rollover;
+                    count0 = count;
+                }
+            }
+            count += 1;
+        }
+
+        if ( satfound )
+        {
+            if (option_vel >= 2) {
+                GPS_SatellitePositionVelocity_Ephem(
+                    week, t, eph[count0],
+                    &cl_corr, &cl_drift, &X, &Y, &Z, &vX, &vY, &vZ
+                );
+                satp[j].clock_drift = cl_drift;
+                satp[j].vX = vX;
+                satp[j].vY = vY;
+                satp[j].vZ = vZ;
+            }
+            else {
+                GPS_SatellitePosition_Ephem(
+                    week, t, eph[count0],
+                    &cl_corr, &X, &Y, &Z
+                );
+            }
+
+            satp[j].X = X;
+            satp[j].Y = Y;
+            satp[j].Z = Z;
+            satp[j].clock_corr = cl_corr;
+            satp[j].ephtime = eph[count0].toe;
+        }
+
+    }
+
+    return 0;
+}
+
+
+typedef struct {
+    uint32_t tow;
+    uint8_t status;
+    int chips;
+    int deltachips;
+} RANGE_t;
+RANGE_t range[33];
+
+int prn[12];  // valide PRN 0,..,k-1
+
+
+// pseudo.range = -df*pseudo.chips
+//           df = lightspeed/(chips/sec)/2^10
+const double df = 299792.458/1023.0/1024.0; //0.286183844 // c=299792458m/s, 1023000chips/s
+//           dl = L1/(chips/sec)/4
+const double dl = 1575.42/1.023/4.0; //385.0 // GPS L1 1575.42MHz=154*10.23MHz, dl=154*10/4
+
+double pr_ofs;
+double GPSsatAlt = 20200e3;
+
+int get_pseudorange() {
+    uint32_t gpstime;
+    uint8_t gpstime_bytes[4];
+    uint8_t pseudobytes[4];
+    uint32_t chipbytes, deltabytes;
+    int i, j, k;
+    uint8_t bytes[4];
+    uint16_t byte16;
+    double  pr0, prj;
+
+    // GPS-TOW in ms
+    for (i = 0; i < 4; i++) {
+        gpstime_bytes[i] = framebyte(posGPS_TOW + i);
+    }
+    memcpy(&gpstime, gpstime_bytes, 4);
+
+    // Sat Status
+    Serial.print("Sat status: ");
+    for (i = 0; i < 12; i++) {
+        sat_status[i] = framebyte(posGPS_STATUS + i);
+	Serial.printf("%d:%d ", i, sat_status[i]);
+    }
+    Serial.print("\n");
+
+    // PRN-Nummern
+    for (i = 0; i < 4; i++) {
+        for (j = 0; j < 2; j++) {
+            bytes[j] = frame[posGPS_PRN+2*i+j];
+        }
+        memcpy(&byte16, bytes, 2);
+        prnbits_le(byte16, prn_le, i);
+    }
+    prn12(prn_le, prns);
+
+
+    // GPS Sat Pos (& Vel)
+    //if (almanac) calc_satpos_alm(  alm, gpstime/1000.0, sat);
+    if (ephem)   calc_satpos_rnx2(ephs, gpstime/1000.0, sat);
+
+    // GPS Sat Pos t -= 1s
+    if (option_vel == 1) {
+        //if (almanac) calc_satpos_alm(  alm, gpstime/1000.0-1, sat1s);
+        if (ephem)   calc_satpos_rnx2(ephs, gpstime/1000.0-1, sat1s);
+    }
+
+    k = 0;
+    for (j = 0; j < 12; j++) {
+
+        // Pseudorange/chips
+        for (i = 0; i < 4; i++) {
+            pseudobytes[i] = frame[posGPS_DATA+8*j+i];
+        }
+        memcpy(&chipbytes, pseudobytes, 4);
+	//Serial.printf("Chipbytes(%d): %04x\n",j, chipbytes);
+
+        // delta_pseudochips / 385
+        for (i = 0; i < 3; i++) {
+            pseudobytes[i] = frame[posGPS_DATA+8*j+4+i];
+        }
+        deltabytes = 0; // bzw. pseudobytes[3]=0 (24 bit);  deltabytes & (0xFF<<24) als
+        memcpy(&deltabytes, pseudobytes, 3); // gemeinsamer offset relevant in --vel1 !
+
+        //if ( (prns[j] == 0) && (sat_status[j] & 0x0F) )  prns[j] = 32;
+        range[prns[j]].tow = gpstime;
+        range[prns[j]].status = sat_status[j];
+
+        if ( chipbytes == 0x7FFFFFFF  ||  chipbytes == 0x55555555 ) {
+             range[prns[j]].chips = 0;
+             continue;
+        }
+        if (option_vergps != 8) {
+        if ( chipbytes >  0x10000000  &&  chipbytes <  0xF0000000 ) {
+             range[prns[j]].chips = 0;
+             continue;
+        }}
+
+        range[prns[j]].chips = chipbytes;
+        range[prns[j]].deltachips = deltabytes;
+
+/*
+        if (range[prns[j]].deltachips == 0x555555) {
+            range[prns[j]].deltachips = 0;
+            continue;
+        }
+*/
+	Serial.printf("j=%d: prns=%d status=%d  dist=%f\n ", j, prns[j], sat_status[j], dist(sat[prns[j]].X, sat[prns[j]].Y, sat[prns[j]].Z, 0, 0, 0));
+	//int o=prns[j];
+	//Serial.printf("x=%f y=%f z=%f\n", sat[o].X, sat[o].Y, sat[o].Z);
+        if (  (prns[j] > 0)  &&  ((sat_status[j] & 0x0F) == 0xF)
+           && (dist(sat[prns[j]].X, sat[prns[j]].Y, sat[prns[j]].Z, 0, 0, 0) > 6700000) )
+        {
+            for (i = 0; i < k; i++) { if (prn[i] == prns[j]) break; }
+            if (i == k  &&  prns[j] != exSat) {
+                //if ( range[prns[j]].status & 0xF0 )  // Signalstaerke > 0 ?
+                {
+                    prn[k] = prns[j];
+                    k++;
+                }
+            }
+        }
+
+    }
+
+
+    for (j = 0; j < 12; j++) {    // 0x013FB0A4
+        sat[prns[j]].pseudorange = /*0x01400000*/ - range[prns[j]].chips * df;
+        sat1s[prns[j]].pseudorange = -(range[prns[j]].chips - range[prns[j]].deltachips/dl)*df;
+                                   //+ sat[prns[j]].clock_corr - sat1s[prns[j]].clock_corr
+        sat[prns[j]].pseudorate = - range[prns[j]].deltachips * df / dl;
+
+        sat[prns[j]].prn = prns[j];
+        sat1s[prns[j]].prn = prns[j];
+    }
+
+
+    pr0 = (double)0x01400000;
+    for (j = 0; j < k; j++) {
+        prj = sat[prn[j]].pseudorange + sat[prn[j]].clock_corr;
+        if (prj < pr0) pr0 = prj;
+    }
+    for (j = 0; j < k; j++) sat[prn[j]].PR = sat[prn[j]].pseudorange + sat[prn[j]].clock_corr - pr0 + GPSsatAlt;
+    // es kann PRNs geben, die zeitweise stark abweichende PR liefern;
+    // eventuell Standardabweichung ermitteln und fehlerhafte Sats weglassen
+    for (j = 0; j < k; j++) {                      //  sat/sat1s...             PR-check
+        sat1s[prn[j]].PR = sat1s[prn[j]].pseudorange + sat[prn[j]].clock_corr - pr0 + GPSsatAlt;
+    }
+    pr_ofs = pr0;
+
+    return k;
+}
+
+int get_GPSvel(double lat, double lon, double vel_ecef[3],
+               double *vH, double *vD, double *vU) {
+    // ECEF-Velocities
+    // ECEF-Vel -> NorthEastUp
+    double phi = lat*M_PI/180.0;
+    double lam = lon*M_PI/180.0;
+    double vN = -vel_ecef[0]*sin(phi)*cos(lam) - vel_ecef[1]*sin(phi)*sin(lam) + vel_ecef[2]*cos(phi);
+    double vE = -vel_ecef[0]*sin(lam) + vel_ecef[1]*cos(lam);
+    *vU =  vel_ecef[0]*cos(phi)*cos(lam) + vel_ecef[1]*cos(phi)*sin(lam) + vel_ecef[2]*sin(phi);
+    // NEU -> HorDirVer
+    *vH = sqrt(vN*vN+vE*vE);
+    *vD = atan2(vE, vN) * 180 / M_PI;
+    if (*vD < 0) *vD += 360;
+
+    return 0;
+}
+
+double DOP[4];
+
+int naiv_2Dfix(int N, SAT_t sats[], double alt) {
+// simple 2D fix: 3 Sats & Alt above ellipsoid
+//
+// - fuer 3 unbekannte lat, lon, t braucht man mind. 3 Satelliten
+// - fuer Iteration braucht man jedoch einen Startwert
+// - es gibt direkte Methoden
+// - hier werden die vorhandenen Funktionen benutzt:
+//   - der 4. Satellit im Erdmittelpunkt
+//   - seine pseudorange(+clock) wird grob geschaetzt
+//     (pseudochips liefern erst Rueckschluesse, wenn man Position kennt)
+//   - dann approximieren, bis Hoehe stimmt
+// - bei 3-4 Satelliten ist die DOP-Konstellation oft schlecht
+// - moeglicherweise ist in einigen Faellen die 2. Loesung besser
+
+    double radius = 6371e3 + alt; // wird dann approximiert
+    double lat2d, lon2d, alt2d,
+           pos_ecef[3], rx_cl_bias,
+           dpos_ecef[3];
+    //double d;
+    double rofs = 200000.0, rdiff = 0.0;
+    int k, k_limit;
+    double gdop = -1;
+
+
+    sats[3].X = sats[3].Y = sats[3].Z = 0;
+
+    k = 0;
+    k_limit = 100;
+
+    if (N >= 3) {
+
+            do
+            {
+                // PR = pseudorange + clock_corr - pr_ofs + GPSsatAlt
+                sats[3].X = sats[3].Y = sats[3].Z = 0;
+                sats[3].PR = radius - rofs;
+                sats[3].pseudorange = sats[3].PR + pr_ofs - GPSsatAlt;
+
+
+                NAV_bancroft1(4, sats, pos_ecef, &rx_cl_bias);
+                //NAV_bancroft3(4, sats, pos_ecef1, &rx_cl_bias1, pos_ecef2, &rx_cl_bias2);
+
+                ecef2elli(pos_ecef[0], pos_ecef[1], pos_ecef[2], &lat2d, &lon2d, &alt2d);
+                rdiff = alt-alt2d;
+
+                rofs -= rdiff*1.2;
+                k += 1;
+
+            } while (k < k_limit  &&  fabs(rdiff) > 1.0);
+
+            NAV_LinP(4, sats, pos_ecef, rx_cl_bias, dpos_ecef, &rx_cl_bias);
+            //  for (j=0;j<3;j++) pos_ecef[j] += dpos_ecef[j];
+            //  NAV_LinP(4, sats, pos_ecef, rx_cl_bias, dpos_ecef, &rx_cl_bias);
+            //  d = dist(0, 0, 0, dpos_ecef[0], dpos_ecef[1], dpos_ecef[2]);
+
+    }
+
+    if (calc_DOPn(4, sats, pos_ecef, DOP) == 0) {
+        gdop = sqrt(DOP[0]+DOP[1]+DOP[2]+DOP[3]);
+    }
+    //if (gdop > 2*dop_limit) gdop = -1;
+    //if (gdop < 0) gdop = -1;
+
+    gpx.lat = lat2d;
+    gpx.lon = lon2d;
+    gpx.alt = alt2d;
+    gpx.dop = gdop;
+
+    if ( fabs(alt2d-alt) > 1000.0 ) return -1;
+    if ( k == k_limit ) return 0;
+    return 1;
+}
+
+
+int get_GPSkoord(int N) {
+    double lat, lon, alt, rx_cl_bias;
+    double vH, vD, vU;
+    double lat1s, lon1s, alt1s,
+           lat0 , lon0 , alt0 , pos0_ecef[3];
+    double pos_ecef[3], pos1s_ecef[3], dpos_ecef[3],
+           vel_ecef[3], dvel_ecef[3];
+    double gdop, gdop0 = 1000.0;
+    //double hdop, vdop, pdop;
+    int i0, i1, i2, i3, j, k, n;
+    int nav_ret = 0;
+    int num = 0;
+    SAT_t Sat_A[4];
+    SAT_t Sat_B[12]; // N <= 12
+    SAT_t Sat_B1s[12];
+    SAT_t Sat_C[12]; // 11
+    double diter = 0;
+    int exN = -1;
+
+    if (option_vergps == 8) {
+        fprintf(stdout, "  sats: ");
+        for (j = 0; j < N; j++) fprintf(stdout, "%02d ", prn[j]);
+        fprintf(stdout, "\n");
+    }
+
+    gpx.lat = gpx.lon = gpx.alt = 0;
+
+    if (option_vergps != 2) {
+    for (i0=0;i0<N;i0++) { for (i1=i0+1;i1<N;i1++) { for (i2=i1+1;i2<N;i2++) { for (i3=i2+1;i3<N;i3++) {
+
+        Sat_A[0] = sat[prn[i0]];
+        Sat_A[1] = sat[prn[i1]];
+        Sat_A[2] = sat[prn[i2]];
+        Sat_A[3] = sat[prn[i3]];
+        nav_ret = NAV_ClosedFormSolution_FromPseudorange( Sat_A, &lat, &lon, &alt, &rx_cl_bias, pos_ecef );
+
+        if (nav_ret == 0) {
+            num += 1;
+            if (calc_DOPn(4, Sat_A, pos_ecef, DOP) == 0) {
+                gdop = sqrt(DOP[0]+DOP[1]+DOP[2]+DOP[3]);
+                //fprintf(stdout, " DOP : %.1f ", gdop);
+
+                NAV_LinP(4, Sat_A, pos_ecef, rx_cl_bias, dpos_ecef, &rx_cl_bias);
+                diter = dist(0, 0, 0, dpos_ecef[0], dpos_ecef[1], dpos_ecef[2]);
+                for (j = 0; j < 3; j++) pos_ecef[j] += dpos_ecef[j];
+                ecef2elli(pos_ecef[0], pos_ecef[1], pos_ecef[2], &lat, &lon, &alt);
+                if ( option_vel == 4 ) {
+                    vel_ecef[0] = vel_ecef[1] = vel_ecef[2] = 0;
+                    NAV_LinV(4, Sat_A, pos_ecef, vel_ecef, 0.0, dvel_ecef, &rx_cl_bias);
+                    for (j=0; j<3; j++) vel_ecef[j] += dvel_ecef[j];
+                    NAV_LinV(4, Sat_A, pos_ecef, vel_ecef, rx_cl_bias, dvel_ecef, &rx_cl_bias);
+                    for (j=0; j<3; j++) vel_ecef[j] += dvel_ecef[j];
+                    get_GPSvel(lat, lon, vel_ecef, &vH, &vD, &vU);
+                }
+                if (option_vergps == 8) {
+                    // gdop = sqrt(DOP[0]+DOP[1]+DOP[2]+DOP[3]); // s.o.
+                    //hdop = sqrt(DOP[0]+DOP[1]);
+                    //vdop = sqrt(DOP[2]);
+                    //pdop = sqrt(DOP[0]+DOP[1]+DOP[2]);
+                    if (gdop < dop_limit) {
+                        fprintf(stdout, "       ");
+                        fprintf(stdout, "lat: %.5f , lon: %.5f , alt: %.1f ", lat, lon, alt);
+                        fprintf(stdout, " (d:%.1f)", diter);
+                        if ( option_vel == 4 ) {
+                            fprintf(stdout, "  vH: %4.1f  D: %5.1f°  vV: %3.1f ", vH, vD, vU);
+                        }
+                        fprintf(stdout, "  sats: ");
+                        fprintf(stdout, "%02d %02d %02d %02d  ", prn[i0], prn[i1], prn[i2], prn[i3]);
+                        fprintf(stdout, " GDOP : %.1f  ", gdop);
+                        //fprintf(stdout, " HDOP: %.1f  VDOP: %.1f ", hdop, vdop);
+                        //fprintf(stdout, " PDOP: %.1f  ", pdop);
+                        fprintf(stdout, "\n");
+                    }
+                }
+            }
+            else gdop = -1;
+
+            if (gdop > 0 && gdop < gdop0) {  // wenn fehlerhafter Sat, diter wohl besserer Indikator
+                gpx.lat = lat;
+                gpx.lon = lon;
+                gpx.alt = alt;
+                gpx.dop = gdop;
+                gpx.diter = diter;
+                gpx.sats[0] = prn[i0]; gpx.sats[1] = prn[i1]; gpx.sats[2] = prn[i2]; gpx.sats[3] = prn[i3];
+                gdop0 = gdop;
+
+                if (option_vel == 4) {
+                    gpx.vH = vH;
+                    gpx.vD = vD;
+                    gpx.vU = vU;
+                }
+            }
+        }
+
+    }}}}
+    }
+
+    if (option_vergps == 8  ||  option_vergps == 2) {
+
+        for (j = 0; j < N; j++) Sat_B[j] = sat[prn[j]];
+        for (j = 0; j < N; j++) Sat_B1s[j] = sat1s[prn[j]];
+
+        NAV_bancroft1(N, Sat_B, pos_ecef, &rx_cl_bias);
+        ecef2elli(pos_ecef[0], pos_ecef[1], pos_ecef[2], &lat, &lon, &alt);
+        gdop = -1;
+        if (calc_DOPn(N, Sat_B, pos_ecef, DOP) == 0) {
+            gdop = sqrt(DOP[0]+DOP[1]+DOP[2]+DOP[3]);
+        }
+
+        NAV_LinP(N, Sat_B, pos_ecef, rx_cl_bias, dpos_ecef, &rx_cl_bias);
+        if (option_iter) {
+            for (j = 0; j < 3; j++) pos_ecef[j] += dpos_ecef[j];
+            ecef2elli(pos_ecef[0], pos_ecef[1], pos_ecef[2], &lat, &lon, &alt);
+        }
+        gpx.diter = dist(0, 0, 0, dpos_ecef[0], dpos_ecef[1], dpos_ecef[2]);
+
+        // Sat mit schlechten Daten suchen
+        if (gpx.diter > d_err) {
+            if (N > 5) {  // N > 4 kann auch funktionieren
+                for (n = 0; n < N; n++) {
+                    k = 0;
+                    for (j = 0; j < N; j++) {
+                        if (j != n) {
+                            Sat_C[k] = Sat_B[j];
+                            k++;
+                        }
+                    }
+                    for (j = 0; j < 3; j++) pos0_ecef[j] = 0;
+                    NAV_bancroft1(N-1, Sat_C, pos0_ecef, &rx_cl_bias);
+                    NAV_LinP(N-1, Sat_C, pos0_ecef, rx_cl_bias, dpos_ecef, &rx_cl_bias);
+                    diter = dist(0, 0, 0, dpos_ecef[0], dpos_ecef[1], dpos_ecef[2]);
+                    ecef2elli(pos0_ecef[0], pos0_ecef[1], pos0_ecef[2], &lat0, &lon0, &alt0);
+                    if (diter < gpx.diter) {
+                        gpx.diter = diter;
+                        for (j = 0; j < 3; j++) pos_ecef[j] = pos0_ecef[j];
+                        lat = lat0;
+                        lon = lon0;
+                        alt = alt0;
+                        exN = n;
+                    }
+                }
+                if (exN >= 0) {
+                    if (prn[exN] == prn32next) prn32toggle ^= 0x1;
+                    for (k = exN; k < N-1; k++) {
+                        Sat_B[k] = Sat_B[k+1];
+                        prn[k] = prn[k+1];
+                        if (option_vel == 1) {
+                            Sat_B1s[k] = Sat_B1s[k+1];
+                        }
+                    }
+                    N = N-1;
+                    if (calc_DOPn(N, Sat_B, pos_ecef, DOP) == 0) {
+                        gdop = sqrt(DOP[0]+DOP[1]+DOP[2]+DOP[3]);
+                    }
+                }
+            }
+/*
+            if (exN < 0  &&  prn32next > 0) {
+                //prn32next used in pre-fix? prn32toggle ^= 0x1;
+            }
+*/
+        }
+
+        if (option_vel == 1) {
+            NAV_bancroft1(N, Sat_B1s, pos1s_ecef, &rx_cl_bias);
+            if (option_iter) {
+                NAV_LinP(N, Sat_B1s, pos1s_ecef, rx_cl_bias, dpos_ecef, &rx_cl_bias);
+                for (j = 0; j < 3; j++) pos1s_ecef[j] += dpos_ecef[j];
+            }
+            for (j = 0; j < 3; j++) vel_ecef[j] = pos_ecef[j] - pos1s_ecef[j];
+            get_GPSvel(lat, lon, vel_ecef, &vH, &vD, &vU);
+            ecef2elli(pos1s_ecef[0], pos1s_ecef[1], pos1s_ecef[2], &lat1s, &lon1s, &alt1s);
+            if (option_vergps == 8) {
+                fprintf(stdout, "\ndeltachips1s lat: %.6f , lon: %.6f , alt: %.2f ", lat1s, lon1s, alt1s);
+                fprintf(stdout, " vH: %4.1f  D: %5.1f°  vV: %3.1f ", vH, vD, vU);
+                fprintf(stdout, "\n");
+            }
+        }
+        if (option_vel >= 2) {
+              //fprintf(stdout, "\nP(%.1f,%.1f,%.1f) \n", pos_ecef[0], pos_ecef[1], pos_ecef[2]);
+            vel_ecef[0] = vel_ecef[1] = vel_ecef[2] = 0;
+            NAV_LinV(N, Sat_B, pos_ecef, vel_ecef, 0.0, dvel_ecef, &rx_cl_bias);
+            for (j=0; j<3; j++) vel_ecef[j] += dvel_ecef[j];
+              //fprintf(stdout, " V(%.1f,%.1f,%.1f) ", vel_ecef[0], vel_ecef[1], vel_ecef[2]);
+              //fprintf(stdout, " rx_vel_bias: %.1f \n", rx_cl_bias);
+            /* 2. Iteration:
+                NAV_LinV(N, Sat_B, pos_ecef, vel_ecef, rx_cl_bias, dvel_ecef, &rx_cl_bias);
+                for (j=0; j<3; j++) vel_ecef[j] += dvel_ecef[j];
+                //fprintf(stdout, " V(%.1f,%.1f,%.1f) ", vel_ecef[0], vel_ecef[1], vel_ecef[2]);
+                //fprintf(stdout, " rx_vel_bias: %.1f \n", rx_cl_bias);
+            */
+            get_GPSvel(lat, lon, vel_ecef, &vH, &vD, &vU);
+        }
+
+        if (option_vergps == 8) {
+            fprintf(stdout, "bancroft[%2d] lat: %.6f , lon: %.6f , alt: %.2f ", N, lat, lon, alt);
+            fprintf(stdout, " (d:%.1f)", gpx.diter);
+            if (option_vel) {
+                fprintf(stdout, "  vH: %4.1f  D: %5.1f°  vV: %3.1f ", vH, vD, vU);
+            }
+            fprintf(stdout, "  DOP[");
+            for (j = 0; j < N; j++) {
+                fprintf(stdout, "%d", prn[j]);
+                if (j < N-1) fprintf(stdout, ","); else fprintf(stdout, "] %.1f ", gdop);
+            }
+            fprintf(stdout, "\n");
+        }
+
+        if (option_vergps == 2) {
+            gpx.lat = lat;
+            gpx.lon = lon;
+            gpx.alt = alt;
+            gpx.dop = gdop;
+            num = N;
+
+            if (option_vel) {
+                gpx.vH = vH;
+                gpx.vD = vD;
+                gpx.vU = vU;
+            }
+        }
+
+    }
+
+    return num;
+}
+
+
+/* ------------------------------------------------------------------------------------ */
+
+
+int print_position() {  // GPS-Hoehe ueber Ellipsoid
+    int j, k = 0, n = 0;
+    int err1, err2, fix2d = 0;
+
+    err1 = 0;
+    if (!option_verbose) err1 = err_gps;
+    err1 |= get_FrameNb();
+    err1 |= get_SondeID();
+
+    err2  = err1 | err_gps;
+  //err2 |= get_GPSweek();
+    err2 |= get_GPStime();
+
+#if 0
+    Serial.printf("ephem=%d\n",ephem);
+    Serial.printf("print_position: ephs is %p\n", ephs);
+#endif
+
+    if (!err2 && (almanac || ephem)) {
+        k = get_pseudorange();
+	gpx.k = k;
+	Serial.printf("k=%d\n", k);
+        if (k >= 4) {
+            n = get_GPSkoord(k);
+        }
+	if (k == 3) {
+	    SAT_t Sat_A[4];
+	    for (j = 0; j < 3; j++) { Sat_A[j] = sat[prn[j]]; }
+	    fix2d = naiv_2Dfix( 3, Sat_A, sonde.config.rs92.alt2d);
+	}
+    }
+
+    if (!err1) {
+        fprintf(stdout, "[%5d] ", gpx.frnr);
+        fprintf(stdout, "(%s) ", gpx.id);
+    }
+
+    if (!err2) {
+        if (option_verbose) {
+            Gps2Date(gpx.week, gpx.gpssec, &gpx.jahr, &gpx.monat, &gpx.tag);
+            //fprintf(stdout, "(W %d) ", gpx.week);
+            fprintf(stdout, "(%04d-%02d-%02d) ", gpx.jahr, gpx.monat, gpx.tag);
+        }
+        fprintf(stdout, "%s ", weekday[gpx.wday]);  // %04.1f: wenn sek >= 59.950, wird auf 60.0 gerundet
+        fprintf(stdout, "%02d:%02d:%06.3f", gpx.std, gpx.min, gpx.sek);
+
+	if (k == 3  &&  fix2d > 0  &&  gpx.dop > 0  &&  gpx.dop < 2*dop_limit) {
+             fprintf(stdout, "  2D  lat: %.5f  lon: %.5f  alt: %.1f ", gpx.lat, gpx.lon, gpx.alt);
+             fprintf(stdout, " DOP[%02d,%02d,%02d,0] %.1f ", prn[0], prn[1], prn[2], gpx.dop);
+        }
+        else if (n > 0) {
+            fprintf(stdout, " ");
+
+            if (almanac) fprintf(stdout, " lat: %.4f  lon: %.4f  alt: %.1f ", gpx.lat, gpx.lon, gpx.alt);
+            else         fprintf(stdout, " lat: %.5f  lon: %.5f  alt: %.1f ", gpx.lat, gpx.lon, gpx.alt);
+
+            if (option_verbose  &&  option_vergps != 8) {
+                fprintf(stdout, " (d:%.1f)", gpx.diter);
+            }
+            if (option_vel  /*&&  option_vergps >= 2*/) {
+                fprintf(stdout,"  vH: %4.1f  D: %5.1f°  vV: %3.1f ", gpx.vH, gpx.vD, gpx.vU);
+            }
+            if (option_verbose) {
+                if (option_vergps != 2) {
+                    fprintf(stdout, " DOP[%02d,%02d,%02d,%02d] %.1f",
+                                   gpx.sats[0], gpx.sats[1], gpx.sats[2], gpx.sats[3], gpx.dop);
+                }
+                else {  // wenn option_vergps=2, dann n=N=k(-1)
+                    fprintf(stdout, " DOP[");
+                    for (j = 0; j < n; j++) {
+                        fprintf(stdout, "%d", prn[j]);
+                        if (j < n-1) fprintf(stdout, ","); else fprintf(stdout, "] %.1f ", gpx.dop);
+                    }
+                }
+            }
+        }
+
+        get_Cal();
+
+        if (option_vergps == 8 /*||  option_vergps == 2*/)
+        {
+            fprintf(stdout, "\n");
+            for (j = 0; j < 60; j++) { fprintf(stdout, "%d", prn_le[j]); if (j % 5 == 4) fprintf(stdout, " "); }
+            fprintf(stdout, ": ");
+            for (j = 0; j < 12; j++) fprintf(stdout, "%2d ", prns[j]);
+            fprintf(stdout, "\n");
+            fprintf(stdout, "                                                                  status: ");
+            for (j = 0; j < 12; j++) fprintf(stdout, "%02X ", sat_status[j]); //range[prns[j]].status
+            fprintf(stdout, "\n");
+        }
+
+    }
+
+    if (!err1) {
+        fprintf(stdout, "\n");
+        //if (option_vergps == 8) fprintf(stdout, "\n");
+    }
+
+    return err2;
+}
+
+void print_frame(uint8_t *data, int len) {
+    int i;
+    uint8_t byte;
+
+    for (i = 0; i<len; i++) {
+	frame[i] = data[i];
+    }
+    for (i = len; i < FRAME_LEN; i++) {
+        frame[i] = 0;
+    }
+
+    if (option_raw) {
+        for (i = 0; i < len; i++) {
+            //byte = frame[i];
+            byte = framebyte(i);
+            fprintf(stdout, "%02x", byte);
+        }
+        fprintf(stdout, "\n");
+    }
+    //Serial.printf("print_frame: ephs is %p\n", ephs);
+    print_position();
+}
+
+void get_eph(const char *file) {
+        ephs = read_RNXpephs(file);
+        if (ephs) {
+            ephem = 1;
+            almanac = 0;
+        }
+	Serial.printf("reading RNX done, result is %d, ephs=%p\n", ephem, ephs);
+        if (!option_der) d_err = 1000;
+}
+
+
+
+#if 0
+int main(int argc, char *argv[]) {
+
+    FILE *fp, *fp_alm = NULL, *fp_eph = NULL;
+    char *fpname;
+    char bitbuf[BITS];
+    int bit_count = 0,
+        byte_count = FRAMESTART,
+        header_found = 0,
+        byte, i;
+    int bit, len;
+    char *pbuf = NULL;
+
+#ifdef CYGWIN
+    _setmode(_fileno(stdin), _O_BINARY);
+#endif
+    setbuf(stdout, NULL);
+
+    fpname = argv[0];
+    ++argv;
+    while ((*argv) && (!fileloaded)) {
+        if      ( (strcmp(*argv, "-h") == 0) || (strcmp(*argv, "--help") == 0) ) {
+            Serial.printf("%s [options] <file>\n", fpname);
+            Serial.printf("  file: audio.wav or raw_data\n");
+            Serial.printf("  options:\n");
+            Serial.printf("       --vel; --vel1, --vel2 (-g2)\n");
+            Serial.printf("       -v, -vx, -vv\n");
+            Serial.printf("       -r, --raw\n");
+            Serial.printf("       -i, --invert\n");
+            Serial.printf("       -a, --almanac  <almanacSEM>\n");
+            Serial.printf("       -e, --ephem    <ephemperisRinex>\n");
+            Serial.printf("       -g1         (verbose GPS:   4 sats)\n");
+            Serial.printf("       -g2         (verbose GPS: all sats)\n");
+            Serial.printf("       -gg         (vverbose GPS)\n");
+            Serial.printf("       --crc       (CRC check GPS)\n");
+            Serial.printf("       --rawin1,2  (raw_data file)\n");
+            return 0;
+        }
+        else if ( (strcmp(*argv, "--vel") == 0) ) {
+            option_vel = 4;
+        }
+        else if ( (strcmp(*argv, "--vel1") == 0) ) {
+            option_vel = 1;
+            if (option_vergps < 1) option_vergps = 2;
+        }
+        else if ( (strcmp(*argv, "--vel2") == 0) ) {
+            option_vel = 2;
+            if (option_vergps < 1) option_vergps = 2;
+        }
+        else if ( (strcmp(*argv, "--iter") == 0) ) {
+            option_iter = 1;
+        }
+        else if ( (strcmp(*argv, "-v") == 0) ) {
+            option_verbose = 1;
+        }
+        else if ( (strcmp(*argv, "-vv") == 0) ) {
+            option_verbose = 4;
+        }
+        else if ( (strcmp(*argv, "-vx") == 0) ) {
+            option_aux = 1;
+        }
+        else if   (strcmp(*argv, "--crc") == 0) { option_crc = 1; }
+        else if ( (strcmp(*argv, "-r") == 0) || (strcmp(*argv, "--raw") == 0) ) {
+            option_raw = 1;
+        }
+        else if ( (strcmp(*argv, "-i") == 0) || (strcmp(*argv, "--invert") == 0) ) {
+            option_inv = 1;
+        }
+        else if ( (strcmp(*argv, "-a") == 0) || (strcmp(*argv, "--almanac") == 0) ) {
+            ++argv;
+            if (*argv) fp_alm = fopen(*argv, "r"); // txt-mode
+            else return -1;
+            if (fp_alm == NULL) Serial.printf("[almanac] %s konnte nicht geoeffnet werden\n", *argv);
+        }
+        else if ( (strcmp(*argv, "-e") == 0) || (strncmp(*argv, "--ephem", 7) == 0) ) {
+            ++argv;
+            if (*argv) fp_eph = fopen(*argv, "rb"); // bin-mode
+            else return -1;
+            if (fp_eph == NULL) Serial.printf("[rinex] %s konnte nicht geoeffnet werden\n", *argv);
+        }
+        else if ( (strcmp(*argv, "--dop") == 0) ) {
+            ++argv;
+            if (*argv) {
+                dop_limit = atof(*argv);
+                if (dop_limit <= 0  || dop_limit >= 100)  dop_limit = 9.9;
+            }
+            else return -1;
+        }
+        else if ( (strcmp(*argv, "--der") == 0) ) {
+            ++argv;
+            if (*argv) {
+                d_err = atof(*argv);
+                if (d_err <= 0  || d_err >= 100000)  d_err = 10000;
+                else option_der = 1;
+            }
+            else return -1;
+        }
+        else if ( (strcmp(*argv, "--exsat") == 0) ) {
+            ++argv;
+            if (*argv) {
+                exSat = atoi(*argv);
+                if (exSat < 1  || exSat > 32)  exSat = -1;
+            }
+            else return -1;
+        }
+        else if (strcmp(*argv, "-g1") == 0) { option_vergps = 1; }  //  verbose1 GPS
+        else if (strcmp(*argv, "-g2") == 0) { option_vergps = 2; }  //  verbose2 GPS (bancroft)
+        else if (strcmp(*argv, "-gg") == 0) { option_vergps = 8; }  // vverbose GPS
+        else if (strcmp(*argv, "--rawin1") == 0) { rawin = 2; }     // raw_txt input1
+        else if (strcmp(*argv, "--rawin2") == 0) { rawin = 3; }     // raw_txt input2 (SM)
+        else if ( (strcmp(*argv, "--avg") == 0) ) {
+            option_avg = 1;
+        }
+        else if   (strcmp(*argv, "-b") == 0) { option_b = 1; }
+        else {
+            if (!rawin) fp = fopen(*argv, "rb");
+            else        fp = fopen(*argv, "r");
+            if (fp == NULL) {
+                Serial.printf("%s konnte nicht geoeffnet werden\n", *argv);
+                return -1;
+            }
+            fileloaded = 1;
+        }
+        ++argv;
+    }
+    if (!fileloaded) fp = stdin;
+
+    if (fp_alm) {
+        i = read_SEMalmanac(fp_alm, alm);
+        if (i == 0) {
+            almanac = 1;
+        }
+        fclose(fp_alm);
+        if (!option_der) d_err = 4000;
+    }
+    if (fp_eph) {
+        /* i = read_RNXephemeris(fp_eph, eph);
+           if (i == 0) {
+               ephem = 1;
+               almanac = 0;
+           }
+           fclose(fp_eph); */
+        ephs = read_RNXpephs(fp_eph);
+        if (ephs) {
+            ephem = 1;
+            almanac = 0;
+        }
+        fclose(fp_eph);
+        if (!option_der) d_err = 1000;
+    }
+
+
+    if (!rawin) {
+
+        i = read_wav_header(fp);
+        if (i) {
+            fclose(fp);
+            return -1;
+        }
+
+        while (!read_bits_fsk(fp, &bit, &len)) {
+
+            if (len == 0) { // reset_frame();
+                if (byte_count > pos_SondeID+8) {
+                    if (byte_count < FRAME_LEN-20) err_gps = 1;
+                    print_frame(byte_count);
+                    err_gps = 0;
+                }
+                bit_count = 0;
+                byte_count = FRAMESTART;
+                header_found = 0;
+                inc_bufpos();
+                buf[bufpos] = 'x';
+                continue;   // ...
+            }
+
+            for (i = 0; i < len; i++) {
+
+                inc_bufpos();
+                buf[bufpos] = 0x30 + bit;  // Ascii
+
+                if (!header_found) {
+                    if (compare() >= HEADLEN) header_found = 1;
+                }
+                else {
+                    bitbuf[bit_count] = bit;
+                    bit_count++;
+
+                    if (bit_count == BITS) {
+                        bit_count = 0;
+                        byte = bits2byte(bitbuf);
+                        frame[byte_count] = byte;
+                        byte_count++;
+                        if (byte_count == FRAME_LEN) {
+                            byte_count = FRAMESTART;
+                            header_found = 0;
+                            //inc_bufpos();
+                            //buf[bufpos] = 'x';
+                            print_frame(FRAME_LEN);
+                        }
+                    }
+                }
+            }
+            if (header_found && option_b) {
+                bitstart = 1;
+
+                while ( byte_count < FRAME_LEN ) {
+                    if (read_rawbit(fp, &bit) == EOF) break;
+                    bitbuf[bit_count] = bit;
+                    bit_count++;
+                    if (bit_count == BITS) {
+                        bit_count = 0;
+                        byte = bits2byte(bitbuf);
+                        frame[byte_count] = byte;
+                        byte_count++;
+                    }
+                }
+                header_found = 0;
+                print_frame(byte_count);
+                byte_count = FRAMESTART;
+
+            }
+        }
+
+    }
+    else //if (rawin)
+    {
+        if (rawin == 3) frameofs = 5;
+
+        while (1 > 0) {
+
+            pbuf = fgets(buffer_rawin, rawin*FRAME_LEN+4, fp);
+            if (pbuf == NULL) break;
+            buffer_rawin[rawin*FRAME_LEN+1] = '\0';
+            len = strlen(buffer_rawin) / rawin;
+            if (len > pos_SondeID+8) {
+                for (i = 0; i < len-frameofs; i++) { //%2x  SCNx8=%hhx(inttypes.h)
+                    sscanf(buffer_rawin+rawin*i, "%2hhx", frame+frameofs+i);
+                    // wenn ohne %hhx: sscanf(buffer_rawin+rawin*i, "%2x", &byte); frame[frameofs+i] = (uint8_t)byte;
+                }
+                if (len < FRAME_LEN-20) err_gps = 1;
+                print_frame(len);
+                err_gps = 0;
+            }
+        }
+    }
+
+    free(ephs);
+    fclose(fp);
+
+    return 0;
+}
+
+#endif
diff --git a/libraries/SondeLib/rs92gps.h b/libraries/SondeLib/rs92gps.h
new file mode 100755
index 0000000..16192bd
--- /dev/null
+++ b/libraries/SondeLib/rs92gps.h
@@ -0,0 +1,22 @@
+
+typedef struct {
+    int frnr;
+    char id[11];
+    int week; int gpssec;
+    int jahr; int monat; int tag;
+    int wday;
+    int std; int min; float sek;
+    double lat; double lon; double alt;
+    double vH; double vD; double vU;
+    int k;
+    int sats[4];
+    double dop;
+    int freq;
+    unsigned short aux[4];
+    double diter;
+} gpx_t;
+
+extern gpx_t gpx;
+
+void print_frame(uint8_t *data, int len); 
+void get_eph(const char *file);
diff --git a/libraries/SondeLib/rsc.cpp b/libraries/SondeLib/rsc.cpp
new file mode 100755
index 0000000..2b87a26
--- /dev/null
+++ b/libraries/SondeLib/rsc.cpp
@@ -0,0 +1,32 @@
+/*
+ * dxlAPRS toolchain
+ *
+ * Copyright (C) Christian Rabler <oe5dxl@oevsv.at>
+ *
+ * SPDX-License-Identifier:	GPL-2.0+
+ */
+
+#ifndef inttypes_h
+        #include <inttypes.h>
+#endif
+
+#define N 255
+#define R 24
+#define K (N-R)
+
+void *init_rs_char(int symsize,int gfpoly,int fcr,int prim,int nroots,int pad);
+int decode_rs_char(void *arg,
+                   unsigned char *data, int *eras_pos, int no_eras);
+
+void *rs;
+
+void initrsc()
+{
+ rs = init_rs_char( 8, 0x11d, 0, 1, R, 0);
+}
+
+
+int decodersc(char *data, uint32_t *eras_pos, uint32_t no_eras)
+{
+ return decode_rs_char(rs, (unsigned char *)data, (int *)eras_pos, no_eras);
+}
diff --git a/libraries/SondeLib/rsc.h b/libraries/SondeLib/rsc.h
new file mode 100755
index 0000000..a73575c
--- /dev/null
+++ b/libraries/SondeLib/rsc.h
@@ -0,0 +1,17 @@
+/*
+ * dxlAPRS toolchain
+ *
+ * Copyright (C) Christian Rabler <oe5dxl@oevsv.at>
+ *
+ * SPDX-License-Identifier:	GPL-2.0+
+ */
+#ifndef rsc_H_
+#define rsc_H_
+
+
+long decodersc(char [], uint32_t [], uint32_t);
+
+void initrsc(void);
+
+
+#endif /* rsc_H_ */
diff --git a/libraries/SondeLib/rsc_decode.cpp b/libraries/SondeLib/rsc_decode.cpp
new file mode 100755
index 0000000..eb102b4
--- /dev/null
+++ b/libraries/SondeLib/rsc_decode.cpp
@@ -0,0 +1,436 @@
+/*
+ * Copyright 2016 Hannes Schmelzer, OE5HPM
+ *   doing several cleanups and architecture changes, no functional change yet
+ *
+ * General purpose Reed-Solomon decoder for 8-bit symbols or less
+ * Copyright 2003 Phil Karn, KA9Q
+ * May be used under the terms of the GNU Lesser General Public License (LGPL)
+ *
+ * The guts of the Reed-Solomon decoder, meant to be #included
+ * into a function body with the following typedefs, macros and variables supplied
+ * according to the code parameters:
+
+ * data_t - a typedef for the data symbol
+ * data_t data[] - array of rs->nn data and parity symbols to be corrected in place
+ * retval - an integer lvalue into which the decoder's return code is written
+ * NROOTS - the number of roots in the RS code generator polynomial,
+ *          which is the same as the number of parity symbols in a block.
+            Integer variable or literal.
+ * rs->nn - the total number of symbols in a RS block. Integer variable or literal.
+ * rs->pad - the number of pad symbols in a block. Integer variable or literal.
+ * rs->alpha_to - The address of an array of rs->nn elements to convert Galois field
+ *            elements in index (log) form to polynomial form. Read only.
+ * rs->index_of - The address of an array of rs->nn elements to convert Galois field
+ *            elements in polynomial form to index (log) form. Read only.
+ * MODNN - a function to reduce its argument modulo rs->nn. May be inline or a macro.
+ * rs->fcr - An integer literal or variable specifying the first consecutive root of the
+ *       Reed-Solomon generator polynomial. Integer variable or literal.
+ * rs->prim - The primitive root of the generator poly. Integer variable or literal.
+ * DEBUG - If set to 1 or more, do various internal consistency checking. Leave this
+ *         undefined for production code
+
+ * The memset(), memmove(), and memcpy() functions are used. The appropriate header
+ * file declaring these functions (usually <string.h>) must be included by the calling
+ * program.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct rs {
+	unsigned int magic;		/* struct magic */
+	int mm;				/* Bits per symbol */
+	int nn;				/* Symbols per block (= (1<<mm)-1) */
+	unsigned char *alpha_to;	/* log lookup table */
+	unsigned char *index_of;	/* Antilog lookup table */
+	unsigned char *genpoly;		/* Generator polynomial */
+	int nroots;			/*
+					 * Number of generator
+					 * roots = number of parity symbols
+					 */
+	int fcr;			/* First consecutive root, index form */
+	int prim;			/* Primitive element, index form */
+	int iprim;			/* prim-th root of 1, index form */
+	int pad;			/* Padding bytes in shortened block */
+};
+
+static inline int modnn(struct rs *rs,int x)
+{
+	while (x >= rs->nn) {
+		x -= rs->nn;
+		x = (x >> rs->mm) + (x & rs->nn);
+	}
+	return x;
+}
+
+#define MODNN(x) modnn(rs, x)
+#define	MIN(a,b)	((a) < (b) ? (a) : (b))
+#define MAGIC		0xABCD6722
+
+void free_rs_char(void *arg)
+{
+	struct rs *rs = (struct rs *)arg;
+
+	if (rs == NULL)
+		return;
+	if (rs->magic != MAGIC)
+		return;
+
+	if (rs->alpha_to != NULL)
+		free(rs->alpha_to);
+	if (rs->index_of != NULL)
+		free(rs->index_of);
+	if (rs->genpoly != NULL)
+		free(rs->genpoly);
+	free(rs);
+}
+
+/* Initialize a Reed-Solomon codec
+ * symsize = symbol size, bits
+ * gfpoly = Field generator polynomial coefficients
+ * fcr = first root of RS code generator polynomial, index form
+ * prim = primitive element to generate polynomial roots
+ * nroots = RS code generator polynomial degree (number of roots)
+ * pad = padding bytes at front of shortened block
+ */
+void *init_rs_char(int symsize, int gfpoly, int fcr, int prim,
+		   int nroots, int pad)
+{
+	struct rs *rs;
+
+	int i, j, sr,root,iprim;
+
+	/* Check parameter ranges */
+	if (symsize < 0 || symsize > 8*sizeof(unsigned char))
+		return NULL;
+	if (fcr < 0 || fcr >= (1<<symsize))
+		return NULL;
+	if (prim <= 0 || prim >= (1<<symsize))
+		return NULL;
+	if (nroots < 0 || nroots >= (1<<symsize))
+		return NULL;
+	if (pad < 0 || pad >= ((1<<symsize) -1 - nroots))
+		return NULL;
+
+	rs = (struct rs*)malloc(sizeof(*rs));
+	if (rs == NULL) {
+		printf("%s: cannot allocate memory!\n", __func__);
+		return NULL;
+	}
+	memset(rs, 0, sizeof(*rs));
+	rs->magic = MAGIC;
+
+	rs->mm = symsize;
+	rs->nn = (1<<symsize)-1;
+	rs->pad = pad;
+
+	rs->alpha_to = (unsigned char *)malloc(sizeof(unsigned char)*(rs->nn+1));
+	if (rs->alpha_to == NULL) {
+		free(rs);
+		return NULL;
+	}
+	rs->index_of = (unsigned char *)malloc(sizeof(unsigned char)*(rs->nn+1));
+	if (rs->index_of == NULL) {
+		free(rs->alpha_to);
+		free(rs);
+		return NULL;
+	}
+
+	/* Generate Galois field lookup tables */
+	rs->index_of[0] = rs->nn; /* log(zero) = -inf */
+	rs->alpha_to[rs->nn] = 0; /* alpha**-inf = 0 */
+	sr = 1;
+	for (i = 0; i < rs->nn; i++) {
+		rs->index_of[sr] = i;
+		rs->alpha_to[i] = sr;
+		sr <<= 1;
+		if (sr & (1<<symsize))
+			sr ^= gfpoly;
+		sr &= rs->nn;
+	}
+	if (sr != 1) {
+		/* field generator polynomial is not primitive! */
+		free(rs->alpha_to);
+		free(rs->index_of);
+		free(rs);
+		return NULL;
+	}
+
+	/* Form RS code generator polynomial from its roots */
+	rs->genpoly = (unsigned char *)malloc(sizeof(unsigned char)*(nroots+1));
+	if(rs->genpoly == NULL) {
+		free(rs->alpha_to);
+		free(rs->index_of);
+		free(rs);
+		return NULL;
+	}
+	rs->fcr = fcr;
+	rs->prim = prim;
+	rs->nroots = nroots;
+
+	/* Find prim-th root of 1, used in decoding */
+	for (iprim = 1; (iprim % prim) != 0; iprim += rs->nn)
+		;
+	rs->iprim = iprim / prim;
+
+	rs->genpoly[0] = 1;
+	for (i = 0, root = fcr*prim; i < nroots; i++, root += prim) {
+		rs->genpoly[i+1] = 1;
+
+		/* Multiply rs->genpoly[] by  @**(root + x) */
+		for (j = i; j > 0; j--) {
+			if (rs->genpoly[j] != 0)
+				rs->genpoly[j] = rs->genpoly[j-1] ^ rs->alpha_to[modnn(rs,rs->index_of[rs->genpoly[j]] + root)];
+			else
+				rs->genpoly[j] = rs->genpoly[j-1];
+		}
+		/* rs->genpoly[0] can never be zero */
+		rs->genpoly[0] = rs->alpha_to[modnn(rs,rs->index_of[rs->genpoly[0]] + root)];
+	}
+	/* convert rs->genpoly[] to index form for quicker encoding */
+	for (i = 0; i <= nroots; i++)
+		rs->genpoly[i] = rs->index_of[rs->genpoly[i]];
+
+	return rs;
+}
+
+int decode_rs_char(void *arg,
+		   unsigned char *data, int *eras_pos, int no_eras)
+{
+	struct rs *rs = (struct rs *)arg;
+
+	if (rs == NULL)
+		return -1;
+	if (rs->magic != MAGIC)
+		return -1;
+
+	int retval;
+	int deg_lambda, el, deg_omega;
+	int i, j, r,k;
+
+	unsigned char u,q,tmp,num1,num2,den,discr_r;
+	unsigned char lambda[rs->nroots+1], s[rs->nroots];	/* Err+Eras Locator poly
+					 * and syndrome poly */
+	unsigned char b[rs->nroots+1], t[rs->nroots+1], omega[rs->nroots+1];
+	unsigned char root[rs->nroots], reg[rs->nroots+1], loc[rs->nroots];
+	int syn_error, count;
+
+	/* form the syndromes; i.e., evaluate data(x) at roots of g(x) */
+	for (i = 0; i < rs->nroots; i++)
+		s[i] = data[0];
+
+	for (j = 1; j < rs->nn-rs->pad; j++) {
+		for(i=0;i<rs->nroots;i++) {
+			if(s[i] == 0) {
+				s[i] = data[j];
+			} else {
+				s[i] = data[j] ^ rs->alpha_to[MODNN(rs->index_of[s[i]] + (rs->fcr+i)*rs->prim)];
+			}
+		}
+	}
+
+	/* Convert syndromes to index form, checking for nonzero condition */
+	syn_error = 0;
+	for (i = 0; i < rs->nroots; i++) {
+		syn_error |= s[i];
+		s[i] = rs->index_of[s[i]];
+	}
+
+	if (!syn_error) {
+		/* if syndrome is zero, data[] is a codeword and there are no
+		* errors to correct. So return data[] unmodified
+		*/
+		count = 0;
+		goto finish;
+	}
+	memset(&lambda[1], 0, rs->nroots*sizeof(lambda[0]));
+	lambda[0] = 1;
+
+	if (no_eras > 0) {
+		/* Init lambda to be the erasure locator polynomial */
+		lambda[1] = rs->alpha_to[MODNN(rs->prim*(rs->nn-1-eras_pos[0]))];
+		for (i = 1; i < no_eras; i++) {
+		u = MODNN(rs->prim*(rs->nn-1-eras_pos[i]));
+		for (j = i+1; j > 0; j--) {
+			tmp = rs->index_of[lambda[j - 1]];
+			if(tmp != rs->nn)
+			  lambda[j] ^= rs->alpha_to[MODNN(u + tmp)];
+		}
+	}
+
+	#if DEBUG >= 1
+	/* Test code that verifies the erasure locator polynomial just constructed
+	Needed only for decoder debugging. */
+
+	/* find roots of the erasure location polynomial */
+	for(i=1;i<=no_eras;i++)
+		reg[i] = rs->index_of[lambda[i]];
+
+	count = 0;
+	for (i = 1,k=rs->iprim-1; i <= rs->nn; i++,k = MODNN(k+rs->iprim)) {
+		q = 1;
+		for (j = 1; j <= no_eras; j++)
+		if (reg[j] != rs->nn) {
+			reg[j] = MODNN(reg[j] + j);
+			q ^= rs->alpha_to[reg[j]];
+		}
+		if (q != 0)
+			continue;
+		/* store root and error location number indices */
+		root[count] = i;
+		loc[count] = k;
+		count++;
+	}
+	if (count != no_eras) {
+		printf("count = %d no_eras = %d\n lambda(x) is WRONG\n",count,no_eras);
+		count = -1;
+		goto finish;
+	}
+	#if DEBUG >= 2
+	printf("\n Erasure positions as determined by roots of Eras Loc Poly:\n");
+	for (i = 0; i < count; i++)
+		printf("%d ", loc[i]);
+	printf("\n");
+	#endif
+	#endif
+	}
+	for (i = 0; i < rs->nroots+1; i++)
+		b[i] = rs->index_of[lambda[i]];
+
+	/*
+	* Begin Berlekamp-Massey algorithm to determine error+erasure
+	* locator polynomial
+	*/
+	r = no_eras;
+	el = no_eras;
+	while (++r <= rs->nroots) {	/* r is the step number */
+	/* Compute discrepancy at the r-th step in poly-form */
+		discr_r = 0;
+		for (i = 0; i < r; i++) {
+			if ((lambda[i] != 0) && (s[r-i-1] != rs->nn)) {
+				discr_r ^= rs->alpha_to[MODNN(rs->index_of[lambda[i]] + s[r-i-1])];
+			}
+		}
+		discr_r = rs->index_of[discr_r];	/* Index form */
+		if (discr_r == rs->nn) {
+			/* 2 lines below: B(x) <-- x*B(x) */
+			memmove(&b[1],b,rs->nroots*sizeof(b[0]));
+			b[0] = rs->nn;
+		} else {
+			/* 7 lines below: T(x) <-- lambda(x) - discr_r*x*b(x) */
+			t[0] = lambda[0];
+			for (i = 0 ; i < rs->nroots; i++) {
+				if(b[i] != rs->nn)
+					t[i+1] = lambda[i+1] ^ rs->alpha_to[MODNN(discr_r + b[i])];
+				else
+					t[i+1] = lambda[i+1];
+			}
+			if (2 * el <= r + no_eras - 1) {
+				el = r + no_eras - el;
+				/*
+				 * 2 lines below: B(x) <-- inv(discr_r) *
+				 * lambda(x)
+				 */
+				for (i = 0; i <= rs->nroots; i++)
+					b[i] = (lambda[i] == 0) ? rs->nn : MODNN(rs->index_of[lambda[i]] - discr_r + rs->nn);
+			} else {
+				/* 2 lines below: B(x) <-- x*B(x) */
+				memmove(&b[1],b,rs->nroots*sizeof(b[0]));
+				b[0] = rs->nn;
+			}
+			memcpy(lambda,t,(rs->nroots+1)*sizeof(t[0]));
+		}
+	}
+
+	/* Convert lambda to index form and compute deg(lambda(x)) */
+	deg_lambda = 0;
+	for (i = 0;i < rs->nroots+1; i++){
+		lambda[i] = rs->index_of[lambda[i]];
+		if(lambda[i] != rs->nn)
+			deg_lambda = i;
+	}
+	/* Find roots of the error+erasure locator polynomial by Chien search */
+	memcpy(&reg[1], &lambda[1], rs->nroots*sizeof(reg[0]));
+	count = 0;		/* Number of roots of lambda(x) */
+	for (i = 1,k=rs->iprim-1; i <= rs->nn; i++,k = MODNN(k+rs->iprim)) {
+		q = 1; /* lambda[0] is always 0 */
+		for (j = deg_lambda; j > 0; j--) {
+			if (reg[j] != rs->nn) {
+				reg[j] = MODNN(reg[j] + j);
+				q ^= rs->alpha_to[reg[j]];
+			}
+		}
+		if (q != 0)
+			continue; /* Not a root */
+		/* store root (index-form) and error location number */
+		#if DEBUG>=2
+		printf("count %d root %d loc %d\n",count,i,k);
+		#endif
+		root[count] = i;
+		loc[count] = k;
+		/* If we've already found max possible roots,
+		* abort the search to save time
+		*/
+		if(++count == deg_lambda)
+			break;
+	}
+	if (deg_lambda != count) {
+		/*
+		* deg(lambda) unequal to number of roots => uncorrectable
+		* error detected
+		*/
+		count = -1;
+		goto finish;
+	}
+	/*
+	* Compute err+eras evaluator poly omega(x) = s(x)*lambda(x) (modulo
+	* x**rs->nroots). in index form. Also find deg(omega).
+	*/
+	deg_omega = deg_lambda-1;
+	for (i = 0; i <= deg_omega;i++) {
+		tmp = 0;
+		for (j = i; j >= 0; j--) {
+			if ((s[i - j] != rs->nn) && (lambda[j] != rs->nn))
+			tmp ^= rs->alpha_to[MODNN(s[i - j] + lambda[j])];
+		}
+		omega[i] = rs->index_of[tmp];
+	}
+	/*
+	* Compute error values in poly-form. num1 = omega(inv(X(l))), num2 =
+	* inv(X(l))**(rs->fcr-1) and den = lambda_pr(inv(X(l))) all in poly-form
+	*/
+	for (j = count-1; j >=0; j--) {
+		num1 = 0;
+		for (i = deg_omega; i >= 0; i--) {
+			if (omega[i] != rs->nn)
+				num1  ^= rs->alpha_to[MODNN(omega[i] + i * root[j])];
+		}
+		num2 = rs->alpha_to[MODNN(root[j] * (rs->fcr - 1) + rs->nn)];
+		den = 0;
+
+		/* lambda[i+1] for i even is the formal derivative lambda_pr of lambda[i] */
+		for (i = MIN(deg_lambda, rs->nroots-1) & ~1; i >= 0; i -=2) {
+			if(lambda[i+1] != rs->nn)
+				den ^= rs->alpha_to[MODNN(lambda[i+1] + i * root[j])];
+		}
+		#if DEBUG >= 1
+		if (den == 0) {
+			printf("\n ERROR: denominator = 0\n");
+			count = -1;
+			goto finish;
+		}
+		#endif
+		/* Apply error to data */
+		if (num1 != 0 && loc[j] >= rs->pad) {
+			data[loc[j]-rs->pad] ^= rs->alpha_to[MODNN(rs->index_of[num1] + rs->index_of[num2] + rs->nn - rs->index_of[den])];
+		}
+	}
+	finish:
+	if(eras_pos != NULL) {
+		for (i = 0; i < count; i++)
+			eras_pos[i] = loc[i];
+	}
+	retval = count;
+
+	return retval;
+}
diff --git a/libraries/SondeLib/sd.h b/libraries/SondeLib/sd.h
new file mode 100755
index 0000000..ed7470b
--- /dev/null
+++ b/libraries/SondeLib/sd.h
@@ -0,0 +1,179 @@
+#include "FS.h"
+#include "SD_MMC.h"
+//Write data RadioSonde on SD
+
+//Fonction de gestion SD
+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.name(), 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 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());
+    }
+}
+
+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");
+    }
+}
+
+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");
+    }
+}
+
+void sdwrite()
+{
+ Serial.print("Detect SD\n");
+ if(SD_MMC.begin()){
+
+
+    uint8_t cardType = SD_MMC.cardType();
+
+    if(cardType != CARD_NONE){
+
+
+    Serial.print("SD_MMC 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_MMC.cardSize() / (1024 * 1024);
+    Serial.printf("SD_MMC Card Size: %lluMB\n", cardSize);
+
+
+
+
+/*    
+    Serial.printf("Total space: %lluMB\n", SD_MMC.totalBytes() / (1024 * 1024));
+    Serial.printf("Used space: %lluMB\n", SD_MMC.usedBytes() / (1024 * 1024));
+*/    
+    if (sonde.si()->validPos)  { 
+        char buff[20];
+    	char chemin[40];   
+    	//String repertoire="/radiosonde/", name=sonde.si()->ser;
+    	//repertoire.toCharArray(chemin, 40);
+    	//if (!SD_MMC.exists(chemin)) {
+    	   createDir(SD_MMC, "/radiosonde/");
+    	   Serial.printf("\nWrite Rep\n");
+	   //listDir(SD_MMC, chemin, 0);
+	//}
+
+    	//if (name.length()>8) {
+    	    //name.concat(".csv");
+    	    //repertoire.concat(name);
+	    //repertoire.toCharArray(chemin, 40);
+	    writeFile(SD_MMC, "/radiosonde/sonde.csv", "");
+	    Serial.printf("\nWrite file\n");
+	    //if (!SD_MMC.exists(chemin)) {
+	    	appendFile(SD_MMC, "/radiosonde/sonde.csv", "RadioSonde N; Ser ; Type ; Freq ; Alt ; VSpeed ; HSpeed ; Dir ; LaunchSite ; RSSI\n");
+	    	Serial.printf("\nWrite titre\n");
+	    //}
+	    Serial.printf("\nWrite Data\n");
+	    snprintf(buff, 16, "%10c", sonde.si()->id);
+	    appendFile(SD_MMC, "/radiosonde/sonde.csv", buff);
+	    appendFile(SD_MMC, "/radiosonde/sonde.csv", ";");   
+	    snprintf(buff, 16, "%12c", sonde.si()->ser);
+	    appendFile(SD_MMC, "/radiosonde/sonde.csv", buff);
+	    appendFile(SD_MMC, "/radiosonde/sonde.csv", ";");      
+	    appendFile(SD_MMC, "/radiosonde/sonde.csv", sondeTypeStr[sonde.si()->type]);
+	    appendFile(SD_MMC, "/radiosonde/sonde.csv", ";");   
+	    snprintf(buff, 16, "%3.3fMhz", sonde.si()->freq);
+	    appendFile(SD_MMC, "/radiosonde/sonde.csv", buff);
+	    appendFile(SD_MMC, "/radiosonde/sonde.csv", ";");  
+	    snprintf(buff, 16, sonde.si()->alt>=1000?"   %5.0fm":"   %3.1fm", sonde.si()->alt);
+	    appendFile(SD_MMC, "/radiosonde/sonde.csv", buff);
+	    appendFile(SD_MMC, "/radiosonde/sonde.csv", ";");  
+	    snprintf(buff, 16, "%2.2fm/s", sonde.si()->vs);
+	    appendFile(SD_MMC, "/radiosonde/sonde.csv", buff);
+	    appendFile(SD_MMC, "/radiosonde/sonde.csv", ";");
+	    snprintf(buff, 16, "%2.2fm/s", sonde.si()->hs);
+	    appendFile(SD_MMC, "/radiosonde/sonde.csv", buff);
+	    appendFile(SD_MMC, "/radiosonde/sonde.csv", ";");
+	    snprintf(buff, 16, "%3.0f°", sonde.si()->dir);
+	    appendFile(SD_MMC, "/radiosonde/sonde.csv", buff);
+	    appendFile(SD_MMC, "/radiosonde/sonde.csv", ";"); 
+	    snprintf(buff, 16, "%18c", sonde.si()->launchsite);
+	    appendFile(SD_MMC, "/radiosonde/sonde.csv", buff);
+	    appendFile(SD_MMC, "/radiosonde/sonde.csv", ";");
+	    snprintf(buff, 16, "%d", sonde.si()->rssi);
+	    appendFile(SD_MMC, "/radiosonde/sonde.csv", buff);
+	    appendFile(SD_MMC, "/radiosonde/sonde.csv", "\n");    
+	}         
+    }
+ 
+ }  
+}
+
diff --git a/libraries/fonts/FreeMono12pt7b.h b/libraries/fonts/FreeMono12pt7b.h
new file mode 100755
index 0000000..94ecb88
--- /dev/null
+++ b/libraries/fonts/FreeMono12pt7b.h
@@ -0,0 +1,227 @@
+const uint8_t FreeMono12pt7bBitmaps[] PROGMEM = {
+  0x49, 0x24, 0x92, 0x48, 0x01, 0xF8, 0xE7, 0xE7, 0x67, 0x42, 0x42, 0x42,
+  0x42, 0x09, 0x02, 0x41, 0x10, 0x44, 0x11, 0x1F, 0xF1, 0x10, 0x4C, 0x12,
+  0x3F, 0xE1, 0x20, 0x48, 0x12, 0x04, 0x81, 0x20, 0x48, 0x04, 0x07, 0xA2,
+  0x19, 0x02, 0x40, 0x10, 0x03, 0x00, 0x3C, 0x00, 0x80, 0x10, 0x06, 0x01,
+  0xE0, 0xA7, 0xC0, 0x40, 0x10, 0x04, 0x00, 0x3C, 0x19, 0x84, 0x21, 0x08,
+  0x66, 0x0F, 0x00, 0x0C, 0x1C, 0x78, 0x01, 0xE0, 0xCC, 0x21, 0x08, 0x43,
+  0x30, 0x78, 0x3E, 0x30, 0x10, 0x08, 0x02, 0x03, 0x03, 0x47, 0x14, 0x8A,
+  0x43, 0x11, 0x8F, 0x60, 0xFD, 0xA4, 0x90, 0x05, 0x25, 0x24, 0x92, 0x48,
+  0x92, 0x24, 0x11, 0x24, 0x89, 0x24, 0x92, 0x92, 0x90, 0x00, 0x04, 0x02,
+  0x11, 0x07, 0xF0, 0xC0, 0x50, 0x48, 0x42, 0x00, 0x08, 0x04, 0x02, 0x01,
+  0x00, 0x87, 0xFC, 0x20, 0x10, 0x08, 0x04, 0x02, 0x00, 0x3B, 0x9C, 0xCE,
+  0x62, 0x00, 0xFF, 0xE0, 0xFF, 0x80, 0x00, 0x80, 0xC0, 0x40, 0x20, 0x20,
+  0x10, 0x10, 0x08, 0x08, 0x04, 0x04, 0x02, 0x02, 0x01, 0x01, 0x00, 0x80,
+  0x80, 0x40, 0x00, 0x1C, 0x31, 0x90, 0x58, 0x38, 0x0C, 0x06, 0x03, 0x01,
+  0x80, 0xC0, 0x60, 0x30, 0x34, 0x13, 0x18, 0x70, 0x30, 0xE1, 0x44, 0x81,
+  0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x81, 0x1F, 0xC0, 0x1E, 0x10, 0x90,
+  0x68, 0x10, 0x08, 0x0C, 0x04, 0x04, 0x04, 0x06, 0x06, 0x06, 0x06, 0x0E,
+  0x07, 0xFE, 0x3E, 0x10, 0x40, 0x08, 0x02, 0x00, 0x80, 0x40, 0xE0, 0x04,
+  0x00, 0x80, 0x10, 0x04, 0x01, 0x00, 0xD8, 0x63, 0xE0, 0x06, 0x0A, 0x0A,
+  0x12, 0x22, 0x22, 0x42, 0x42, 0x82, 0x82, 0xFF, 0x02, 0x02, 0x02, 0x0F,
+  0x7F, 0x20, 0x10, 0x08, 0x04, 0x02, 0xF1, 0x8C, 0x03, 0x00, 0x80, 0x40,
+  0x20, 0x18, 0x16, 0x18, 0xF0, 0x0F, 0x8C, 0x08, 0x08, 0x04, 0x04, 0x02,
+  0x79, 0x46, 0xC1, 0xE0, 0x60, 0x28, 0x14, 0x19, 0x08, 0x78, 0xFF, 0x81,
+  0x81, 0x02, 0x02, 0x02, 0x02, 0x04, 0x04, 0x04, 0x04, 0x08, 0x08, 0x08,
+  0x08, 0x3E, 0x31, 0xB0, 0x70, 0x18, 0x0C, 0x05, 0x8C, 0x38, 0x63, 0x40,
+  0x60, 0x30, 0x18, 0x1B, 0x18, 0xF8, 0x3C, 0x31, 0x30, 0x50, 0x28, 0x0C,
+  0x0F, 0x06, 0x85, 0x3C, 0x80, 0x40, 0x40, 0x20, 0x20, 0x63, 0xE0, 0xFF,
+  0x80, 0x07, 0xFC, 0x39, 0xCE, 0x00, 0x00, 0x06, 0x33, 0x98, 0xC4, 0x00,
+  0x00, 0xC0, 0x60, 0x18, 0x0C, 0x06, 0x01, 0x80, 0x0C, 0x00, 0x60, 0x03,
+  0x00, 0x30, 0x01, 0x00, 0xFF, 0xF0, 0x00, 0x00, 0x0F, 0xFF, 0xC0, 0x06,
+  0x00, 0x30, 0x01, 0x80, 0x18, 0x01, 0x80, 0xC0, 0x30, 0x18, 0x0C, 0x02,
+  0x00, 0x00, 0x3E, 0x60, 0xA0, 0x20, 0x10, 0x08, 0x08, 0x18, 0x10, 0x08,
+  0x00, 0x00, 0x00, 0x01, 0xC0, 0xE0, 0x1C, 0x31, 0x10, 0x50, 0x28, 0x14,
+  0x3A, 0x25, 0x22, 0x91, 0x4C, 0xA3, 0xF0, 0x08, 0x02, 0x01, 0x80, 0x7C,
+  0x3F, 0x00, 0x0C, 0x00, 0x48, 0x01, 0x20, 0x04, 0x40, 0x21, 0x00, 0x84,
+  0x04, 0x08, 0x1F, 0xE0, 0x40, 0x82, 0x01, 0x08, 0x04, 0x20, 0x13, 0xE1,
+  0xF0, 0xFF, 0x08, 0x11, 0x01, 0x20, 0x24, 0x04, 0x81, 0x1F, 0xC2, 0x06,
+  0x40, 0x68, 0x05, 0x00, 0xA0, 0x14, 0x05, 0xFF, 0x00, 0x1E, 0x48, 0x74,
+  0x05, 0x01, 0x80, 0x20, 0x08, 0x02, 0x00, 0x80, 0x20, 0x04, 0x01, 0x01,
+  0x30, 0x87, 0xC0, 0xFE, 0x10, 0x44, 0x09, 0x02, 0x40, 0x50, 0x14, 0x05,
+  0x01, 0x40, 0x50, 0x14, 0x0D, 0x02, 0x41, 0x3F, 0x80, 0xFF, 0xC8, 0x09,
+  0x01, 0x20, 0x04, 0x00, 0x88, 0x1F, 0x02, 0x20, 0x40, 0x08, 0x01, 0x00,
+  0xA0, 0x14, 0x03, 0xFF, 0xC0, 0xFF, 0xE8, 0x05, 0x00, 0xA0, 0x04, 0x00,
+  0x88, 0x1F, 0x02, 0x20, 0x40, 0x08, 0x01, 0x00, 0x20, 0x04, 0x01, 0xF0,
+  0x00, 0x1F, 0x46, 0x19, 0x01, 0x60, 0x28, 0x01, 0x00, 0x20, 0x04, 0x00,
+  0x83, 0xF0, 0x0B, 0x01, 0x20, 0x23, 0x0C, 0x3E, 0x00, 0xE1, 0xD0, 0x24,
+  0x09, 0x02, 0x40, 0x90, 0x27, 0xF9, 0x02, 0x40, 0x90, 0x24, 0x09, 0x02,
+  0x40, 0xB8, 0x70, 0xFE, 0x20, 0x40, 0x81, 0x02, 0x04, 0x08, 0x10, 0x20,
+  0x40, 0x81, 0x1F, 0xC0, 0x0F, 0xE0, 0x10, 0x02, 0x00, 0x40, 0x08, 0x01,
+  0x00, 0x20, 0x04, 0x80, 0x90, 0x12, 0x02, 0x40, 0xC6, 0x30, 0x7C, 0x00,
+  0xF1, 0xE4, 0x0C, 0x41, 0x04, 0x20, 0x44, 0x04, 0x80, 0x5C, 0x06, 0x60,
+  0x43, 0x04, 0x10, 0x40, 0x84, 0x08, 0x40, 0xCF, 0x07, 0xF8, 0x04, 0x00,
+  0x80, 0x10, 0x02, 0x00, 0x40, 0x08, 0x01, 0x00, 0x20, 0x04, 0x04, 0x80,
+  0x90, 0x12, 0x03, 0xFF, 0xC0, 0xE0, 0x3B, 0x01, 0x94, 0x14, 0xA0, 0xA4,
+  0x89, 0x24, 0x49, 0x14, 0x48, 0xA2, 0x45, 0x12, 0x10, 0x90, 0x04, 0x80,
+  0x24, 0x01, 0x78, 0x3C, 0xE0, 0xF6, 0x02, 0x50, 0x25, 0x02, 0x48, 0x24,
+  0xC2, 0x44, 0x24, 0x22, 0x43, 0x24, 0x12, 0x40, 0xA4, 0x0A, 0x40, 0x6F,
+  0x06, 0x0F, 0x03, 0x0C, 0x60, 0x64, 0x02, 0x80, 0x18, 0x01, 0x80, 0x18,
+  0x01, 0x80, 0x18, 0x01, 0x40, 0x26, 0x06, 0x30, 0xC0, 0xF0, 0xFF, 0x10,
+  0x64, 0x05, 0x01, 0x40, 0x50, 0x34, 0x19, 0xFC, 0x40, 0x10, 0x04, 0x01,
+  0x00, 0x40, 0x3E, 0x00, 0x0F, 0x03, 0x0C, 0x60, 0x64, 0x02, 0x80, 0x18,
+  0x01, 0x80, 0x18, 0x01, 0x80, 0x18, 0x01, 0x40, 0x26, 0x06, 0x30, 0xC1,
+  0xF0, 0x0C, 0x01, 0xF1, 0x30, 0xE0, 0xFF, 0x04, 0x18, 0x40, 0xC4, 0x04,
+  0x40, 0x44, 0x0C, 0x41, 0x87, 0xE0, 0x43, 0x04, 0x10, 0x40, 0x84, 0x04,
+  0x40, 0x4F, 0x03, 0x1F, 0x48, 0x34, 0x05, 0x01, 0x40, 0x08, 0x01, 0xC0,
+  0x0E, 0x00, 0x40, 0x18, 0x06, 0x01, 0xE1, 0xA7, 0xC0, 0xFF, 0xF0, 0x86,
+  0x10, 0x82, 0x00, 0x40, 0x08, 0x01, 0x00, 0x20, 0x04, 0x00, 0x80, 0x10,
+  0x02, 0x00, 0x40, 0x7F, 0x00, 0xF0, 0xF4, 0x02, 0x40, 0x24, 0x02, 0x40,
+  0x24, 0x02, 0x40, 0x24, 0x02, 0x40, 0x24, 0x02, 0x40, 0x22, 0x04, 0x30,
+  0xC0, 0xF0, 0xF8, 0x7C, 0x80, 0x22, 0x01, 0x04, 0x04, 0x10, 0x20, 0x40,
+  0x80, 0x82, 0x02, 0x10, 0x08, 0x40, 0x11, 0x00, 0x48, 0x01, 0xA0, 0x03,
+  0x00, 0x0C, 0x00, 0xF8, 0x7C, 0x80, 0x22, 0x00, 0x88, 0xC2, 0x23, 0x10,
+  0x8E, 0x42, 0x29, 0x09, 0x24, 0x24, 0x90, 0x91, 0x41, 0x85, 0x06, 0x14,
+  0x18, 0x70, 0x60, 0x80, 0xF0, 0xF2, 0x06, 0x30, 0x41, 0x08, 0x09, 0x80,
+  0x50, 0x06, 0x00, 0x60, 0x0D, 0x00, 0x88, 0x10, 0xC2, 0x04, 0x60, 0x2F,
+  0x0F, 0xF0, 0xF2, 0x02, 0x10, 0x41, 0x04, 0x08, 0x80, 0x50, 0x05, 0x00,
+  0x20, 0x02, 0x00, 0x20, 0x02, 0x00, 0x20, 0x02, 0x01, 0xFC, 0xFF, 0x40,
+  0xA0, 0x90, 0x40, 0x40, 0x40, 0x20, 0x20, 0x20, 0x10, 0x50, 0x30, 0x18,
+  0x0F, 0xFC, 0xF2, 0x49, 0x24, 0x92, 0x49, 0x24, 0x9C, 0x80, 0x60, 0x10,
+  0x08, 0x02, 0x01, 0x00, 0x40, 0x20, 0x08, 0x04, 0x01, 0x00, 0x80, 0x20,
+  0x10, 0x04, 0x02, 0x00, 0x80, 0x40, 0xE4, 0x92, 0x49, 0x24, 0x92, 0x49,
+  0x3C, 0x08, 0x0C, 0x09, 0x0C, 0x4C, 0x14, 0x04, 0xFF, 0xFC, 0x84, 0x21,
+  0x3E, 0x00, 0x60, 0x08, 0x02, 0x3F, 0x98, 0x28, 0x0A, 0x02, 0xC3, 0x9F,
+  0x30, 0xE0, 0x01, 0x00, 0x08, 0x00, 0x40, 0x02, 0x00, 0x13, 0xE0, 0xA0,
+  0x86, 0x02, 0x20, 0x09, 0x00, 0x48, 0x02, 0x40, 0x13, 0x01, 0x14, 0x1B,
+  0x9F, 0x00, 0x1F, 0x4C, 0x19, 0x01, 0x40, 0x28, 0x01, 0x00, 0x20, 0x02,
+  0x00, 0x60, 0x43, 0xF0, 0x00, 0xC0, 0x08, 0x01, 0x00, 0x20, 0x04, 0x3C,
+  0x98, 0x52, 0x06, 0x80, 0x50, 0x0A, 0x01, 0x40, 0x24, 0x0C, 0xC2, 0x87,
+  0x98, 0x3F, 0x18, 0x68, 0x06, 0x01, 0xFF, 0xE0, 0x08, 0x03, 0x00, 0x60,
+  0xC7, 0xC0, 0x0F, 0x98, 0x08, 0x04, 0x02, 0x07, 0xF8, 0x80, 0x40, 0x20,
+  0x10, 0x08, 0x04, 0x02, 0x01, 0x03, 0xF8, 0x1E, 0x6C, 0x39, 0x03, 0x40,
+  0x28, 0x05, 0x00, 0xA0, 0x12, 0x06, 0x61, 0x43, 0xC8, 0x01, 0x00, 0x20,
+  0x08, 0x3E, 0x00, 0xC0, 0x10, 0x04, 0x01, 0x00, 0x40, 0x13, 0x87, 0x11,
+  0x82, 0x40, 0x90, 0x24, 0x09, 0x02, 0x40, 0x90, 0x2E, 0x1C, 0x08, 0x04,
+  0x02, 0x00, 0x00, 0x03, 0xC0, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x00,
+  0x80, 0x43, 0xFE, 0x04, 0x08, 0x10, 0x00, 0x1F, 0xC0, 0x81, 0x02, 0x04,
+  0x08, 0x10, 0x20, 0x40, 0x81, 0x02, 0x0B, 0xE0, 0xE0, 0x02, 0x00, 0x20,
+  0x02, 0x00, 0x20, 0x02, 0x3C, 0x21, 0x02, 0x60, 0x2C, 0x03, 0x80, 0x24,
+  0x02, 0x20, 0x21, 0x02, 0x08, 0xE1, 0xF0, 0x78, 0x04, 0x02, 0x01, 0x00,
+  0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x00, 0x80, 0x43, 0xFE,
+  0xDC, 0xE3, 0x19, 0x90, 0x84, 0x84, 0x24, 0x21, 0x21, 0x09, 0x08, 0x48,
+  0x42, 0x42, 0x17, 0x18, 0xC0, 0x67, 0x83, 0x84, 0x20, 0x22, 0x02, 0x20,
+  0x22, 0x02, 0x20, 0x22, 0x02, 0x20, 0x2F, 0x07, 0x1F, 0x04, 0x11, 0x01,
+  0x40, 0x18, 0x03, 0x00, 0x60, 0x0A, 0x02, 0x20, 0x83, 0xE0, 0xCF, 0x85,
+  0x06, 0x60, 0x24, 0x01, 0x40, 0x14, 0x01, 0x40, 0x16, 0x02, 0x50, 0x44,
+  0xF8, 0x40, 0x04, 0x00, 0x40, 0x0F, 0x00, 0x1E, 0x6C, 0x3B, 0x03, 0x40,
+  0x28, 0x05, 0x00, 0xA0, 0x12, 0x06, 0x61, 0x43, 0xC8, 0x01, 0x00, 0x20,
+  0x04, 0x03, 0xC0, 0xE3, 0x8B, 0x13, 0x80, 0x80, 0x20, 0x08, 0x02, 0x00,
+  0x80, 0x20, 0x3F, 0x80, 0x1F, 0x58, 0x34, 0x05, 0x80, 0x1E, 0x00, 0x60,
+  0x06, 0x01, 0xC0, 0xAF, 0xC0, 0x20, 0x04, 0x00, 0x80, 0x10, 0x0F, 0xF0,
+  0x40, 0x08, 0x01, 0x00, 0x20, 0x04, 0x00, 0x80, 0x10, 0x03, 0x04, 0x3F,
+  0x00, 0xC1, 0xC8, 0x09, 0x01, 0x20, 0x24, 0x04, 0x80, 0x90, 0x12, 0x02,
+  0x61, 0xC7, 0xCC, 0xF8, 0xF9, 0x01, 0x08, 0x10, 0x60, 0x81, 0x08, 0x08,
+  0x40, 0x22, 0x01, 0x20, 0x05, 0x00, 0x30, 0x00, 0xF0, 0x7A, 0x01, 0x10,
+  0x08, 0x8C, 0x42, 0x62, 0x12, 0x90, 0xA5, 0x05, 0x18, 0x28, 0xC0, 0x86,
+  0x00, 0x78, 0xF3, 0x04, 0x18, 0x80, 0xD0, 0x06, 0x00, 0x70, 0x09, 0x81,
+  0x0C, 0x20, 0x6F, 0x8F, 0xF0, 0xF2, 0x02, 0x20, 0x41, 0x04, 0x10, 0x80,
+  0x88, 0x09, 0x00, 0x50, 0x06, 0x00, 0x20, 0x04, 0x00, 0x40, 0x08, 0x0F,
+  0xE0, 0xFF, 0x41, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x40, 0xBF,
+  0xC0, 0x19, 0x08, 0x42, 0x10, 0x84, 0x64, 0x18, 0x42, 0x10, 0x84, 0x20,
+  0xC0, 0xFF, 0xFF, 0xC0, 0xC1, 0x08, 0x42, 0x10, 0x84, 0x10, 0x4C, 0x42,
+  0x10, 0x84, 0x26, 0x00, 0x38, 0x13, 0x38, 0x38 };
+
+const GFXglyph FreeMono12pt7bGlyphs[] PROGMEM = {
+  {     0,   0,   0,  14,    0,    1 },   // 0x20 ' '
+  {     0,   3,  15,  14,    6,  -14 },   // 0x21 '!'
+  {     6,   8,   7,  14,    3,  -14 },   // 0x22 '"'
+  {    13,  10,  16,  14,    2,  -14 },   // 0x23 '#'
+  {    33,  10,  17,  14,    2,  -14 },   // 0x24 '$'
+  {    55,  10,  15,  14,    2,  -14 },   // 0x25 '%'
+  {    74,   9,  12,  14,    3,  -11 },   // 0x26 '&'
+  {    88,   3,   7,  14,    5,  -14 },   // 0x27 '''
+  {    91,   3,  18,  14,    7,  -14 },   // 0x28 '('
+  {    98,   3,  18,  14,    4,  -14 },   // 0x29 ')'
+  {   105,   9,   9,  14,    3,  -14 },   // 0x2A '*'
+  {   116,   9,  11,  14,    3,  -11 },   // 0x2B '+'
+  {   129,   5,   7,  14,    3,   -3 },   // 0x2C ','
+  {   134,  11,   1,  14,    2,   -6 },   // 0x2D '-'
+  {   136,   3,   3,  14,    5,   -2 },   // 0x2E '.'
+  {   138,   9,  18,  14,    3,  -15 },   // 0x2F '/'
+  {   159,   9,  15,  14,    3,  -14 },   // 0x30 '0'
+  {   176,   7,  14,  14,    4,  -13 },   // 0x31 '1'
+  {   189,   9,  15,  14,    2,  -14 },   // 0x32 '2'
+  {   206,  10,  15,  14,    2,  -14 },   // 0x33 '3'
+  {   225,   8,  15,  14,    3,  -14 },   // 0x34 '4'
+  {   240,   9,  15,  14,    3,  -14 },   // 0x35 '5'
+  {   257,   9,  15,  14,    3,  -14 },   // 0x36 '6'
+  {   274,   8,  15,  14,    3,  -14 },   // 0x37 '7'
+  {   289,   9,  15,  14,    3,  -14 },   // 0x38 '8'
+  {   306,   9,  15,  14,    3,  -14 },   // 0x39 '9'
+  {   323,   3,  10,  14,    5,   -9 },   // 0x3A ':'
+  {   327,   5,  13,  14,    3,   -9 },   // 0x3B ';'
+  {   336,  11,  11,  14,    2,  -11 },   // 0x3C '<'
+  {   352,  12,   4,  14,    1,   -8 },   // 0x3D '='
+  {   358,  11,  11,  14,    2,  -11 },   // 0x3E '>'
+  {   374,   9,  14,  14,    3,  -13 },   // 0x3F '?'
+  {   390,   9,  16,  14,    3,  -14 },   // 0x40 '@'
+  {   408,  14,  14,  14,    0,  -13 },   // 0x41 'A'
+  {   433,  11,  14,  14,    2,  -13 },   // 0x42 'B'
+  {   453,  10,  14,  14,    2,  -13 },   // 0x43 'C'
+  {   471,  10,  14,  14,    2,  -13 },   // 0x44 'D'
+  {   489,  11,  14,  14,    2,  -13 },   // 0x45 'E'
+  {   509,  11,  14,  14,    2,  -13 },   // 0x46 'F'
+  {   529,  11,  14,  14,    2,  -13 },   // 0x47 'G'
+  {   549,  10,  14,  14,    2,  -13 },   // 0x48 'H'
+  {   567,   7,  14,  14,    4,  -13 },   // 0x49 'I'
+  {   580,  11,  14,  14,    2,  -13 },   // 0x4A 'J'
+  {   600,  12,  14,  14,    2,  -13 },   // 0x4B 'K'
+  {   621,  11,  14,  14,    2,  -13 },   // 0x4C 'L'
+  {   641,  13,  14,  14,    1,  -13 },   // 0x4D 'M'
+  {   664,  12,  14,  14,    1,  -13 },   // 0x4E 'N'
+  {   685,  12,  14,  14,    1,  -13 },   // 0x4F 'O'
+  {   706,  10,  14,  14,    2,  -13 },   // 0x50 'P'
+  {   724,  12,  17,  14,    1,  -13 },   // 0x51 'Q'
+  {   750,  12,  14,  14,    2,  -13 },   // 0x52 'R'
+  {   771,  10,  14,  14,    2,  -13 },   // 0x53 'S'
+  {   789,  11,  14,  14,    2,  -13 },   // 0x54 'T'
+  {   809,  12,  14,  14,    1,  -13 },   // 0x55 'U'
+  {   830,  14,  14,  14,    0,  -13 },   // 0x56 'V'
+  {   855,  14,  14,  14,    0,  -13 },   // 0x57 'W'
+  {   880,  12,  14,  14,    1,  -13 },   // 0x58 'X'
+  {   901,  12,  14,  14,    1,  -13 },   // 0x59 'Y'
+  {   922,   9,  14,  14,    3,  -13 },   // 0x5A 'Z'
+  {   938,   3,  18,  14,    7,  -14 },   // 0x5B '['
+  {   945,   9,  18,  14,    3,  -15 },   // 0x5C '\'
+  {   966,   3,  18,  14,    5,  -14 },   // 0x5D ']'
+  {   973,   9,   6,  14,    3,  -14 },   // 0x5E '^'
+  {   980,  14,   1,  14,    0,    3 },   // 0x5F '_'
+  {   982,   4,   4,  14,    4,  -15 },   // 0x60 '`'
+  {   984,  10,  10,  14,    2,   -9 },   // 0x61 'a'
+  {   997,  13,  15,  14,    0,  -14 },   // 0x62 'b'
+  {  1022,  11,  10,  14,    2,   -9 },   // 0x63 'c'
+  {  1036,  11,  15,  14,    2,  -14 },   // 0x64 'd'
+  {  1057,  10,  10,  14,    2,   -9 },   // 0x65 'e'
+  {  1070,   9,  15,  14,    4,  -14 },   // 0x66 'f'
+  {  1087,  11,  14,  14,    2,   -9 },   // 0x67 'g'
+  {  1107,  10,  15,  14,    2,  -14 },   // 0x68 'h'
+  {  1126,   9,  15,  14,    3,  -14 },   // 0x69 'i'
+  {  1143,   7,  19,  14,    3,  -14 },   // 0x6A 'j'
+  {  1160,  12,  15,  14,    1,  -14 },   // 0x6B 'k'
+  {  1183,   9,  15,  14,    3,  -14 },   // 0x6C 'l'
+  {  1200,  13,  10,  14,    1,   -9 },   // 0x6D 'm'
+  {  1217,  12,  10,  14,    1,   -9 },   // 0x6E 'n'
+  {  1232,  11,  10,  14,    2,   -9 },   // 0x6F 'o'
+  {  1246,  12,  14,  14,    1,   -9 },   // 0x70 'p'
+  {  1267,  11,  14,  14,    2,   -9 },   // 0x71 'q'
+  {  1287,  10,  10,  14,    3,   -9 },   // 0x72 'r'
+  {  1300,  10,  10,  14,    2,   -9 },   // 0x73 's'
+  {  1313,  11,  14,  14,    1,  -13 },   // 0x74 't'
+  {  1333,  11,  10,  14,    2,   -9 },   // 0x75 'u'
+  {  1347,  13,  10,  14,    1,   -9 },   // 0x76 'v'
+  {  1364,  13,  10,  14,    1,   -9 },   // 0x77 'w'
+  {  1381,  12,  10,  14,    1,   -9 },   // 0x78 'x'
+  {  1396,  12,  14,  14,    1,   -9 },   // 0x79 'y'
+  {  1417,   9,  10,  14,    3,   -9 },   // 0x7A 'z'
+  {  1429,   5,  18,  14,    5,  -14 },   // 0x7B '{'
+  {  1441,   1,  18,  14,    7,  -14 },   // 0x7C '|'
+  {  1444,   5,  18,  14,    5,  -14 },   // 0x7D '}'
+  {  1456,  10,   3,  14,    2,   -7 } }; // 0x7E '~'
+
+const GFXfont FreeMono12pt7b PROGMEM = {
+  (uint8_t  *)FreeMono12pt7bBitmaps,
+  (GFXglyph *)FreeMono12pt7bGlyphs,
+  0x20, 0x7E, 24 };
+
+// Approx. 2132 bytes
diff --git a/libraries/fonts/FreeMono9pt7b.h b/libraries/fonts/FreeMono9pt7b.h
new file mode 100755
index 0000000..c82d786
--- /dev/null
+++ b/libraries/fonts/FreeMono9pt7b.h
@@ -0,0 +1,176 @@
+const uint8_t FreeMono9pt7bBitmaps[] PROGMEM = {
+  0xAA, 0xA8, 0x0C, 0xED, 0x24, 0x92, 0x48, 0x24, 0x48, 0x91, 0x2F, 0xE4,
+  0x89, 0x7F, 0x28, 0x51, 0x22, 0x40, 0x08, 0x3E, 0x62, 0x40, 0x30, 0x0E,
+  0x01, 0x81, 0xC3, 0xBE, 0x08, 0x08, 0x71, 0x12, 0x23, 0x80, 0x23, 0xB8,
+  0x0E, 0x22, 0x44, 0x70, 0x38, 0x81, 0x02, 0x06, 0x1A, 0x65, 0x46, 0xC8,
+  0xEC, 0xE9, 0x24, 0x5A, 0xAA, 0xA9, 0x40, 0xA9, 0x55, 0x5A, 0x80, 0x10,
+  0x22, 0x4B, 0xE3, 0x05, 0x11, 0x00, 0x10, 0x20, 0x47, 0xF1, 0x02, 0x04,
+  0x00, 0x6B, 0x48, 0xFF, 0x00, 0xF0, 0x02, 0x08, 0x10, 0x60, 0x81, 0x04,
+  0x08, 0x20, 0x41, 0x02, 0x08, 0x00, 0x38, 0x8A, 0x0C, 0x18, 0x30, 0x60,
+  0xC1, 0x82, 0x88, 0xE0, 0x27, 0x28, 0x42, 0x10, 0x84, 0x21, 0x3E, 0x38,
+  0x8A, 0x08, 0x10, 0x20, 0x82, 0x08, 0x61, 0x03, 0xF8, 0x7C, 0x06, 0x02,
+  0x02, 0x1C, 0x06, 0x01, 0x01, 0x01, 0x42, 0x3C, 0x18, 0xA2, 0x92, 0x8A,
+  0x28, 0xBF, 0x08, 0x21, 0xC0, 0x7C, 0x81, 0x03, 0xE4, 0x40, 0x40, 0x81,
+  0x03, 0x88, 0xE0, 0x1E, 0x41, 0x04, 0x0B, 0x98, 0xB0, 0xC1, 0xC2, 0x88,
+  0xE0, 0xFE, 0x04, 0x08, 0x20, 0x40, 0x82, 0x04, 0x08, 0x20, 0x40, 0x38,
+  0x8A, 0x0C, 0x14, 0x47, 0x11, 0x41, 0x83, 0x8C, 0xE0, 0x38, 0x8A, 0x1C,
+  0x18, 0x68, 0xCE, 0x81, 0x04, 0x13, 0xC0, 0xF0, 0x0F, 0x6C, 0x00, 0xD2,
+  0xD2, 0x00, 0x03, 0x04, 0x18, 0x60, 0x60, 0x18, 0x04, 0x03, 0xFF, 0x80,
+  0x00, 0x1F, 0xF0, 0x40, 0x18, 0x03, 0x00, 0x60, 0x20, 0x60, 0xC0, 0x80,
+  0x3D, 0x84, 0x08, 0x30, 0xC2, 0x00, 0x00, 0x00, 0x30, 0x3C, 0x46, 0x82,
+  0x8E, 0xB2, 0xA2, 0xA2, 0x9F, 0x80, 0x80, 0x40, 0x3C, 0x3C, 0x01, 0x40,
+  0x28, 0x09, 0x01, 0x10, 0x42, 0x0F, 0xC1, 0x04, 0x40, 0x9E, 0x3C, 0xFE,
+  0x21, 0x90, 0x48, 0x67, 0xE2, 0x09, 0x02, 0x81, 0x41, 0xFF, 0x80, 0x3E,
+  0xB0, 0xF0, 0x30, 0x08, 0x04, 0x02, 0x00, 0x80, 0x60, 0x8F, 0x80, 0xFE,
+  0x21, 0x90, 0x68, 0x14, 0x0A, 0x05, 0x02, 0x83, 0x43, 0x7F, 0x00, 0xFF,
+  0x20, 0x90, 0x08, 0x87, 0xC2, 0x21, 0x00, 0x81, 0x40, 0xFF, 0xC0, 0xFF,
+  0xA0, 0x50, 0x08, 0x87, 0xC2, 0x21, 0x00, 0x80, 0x40, 0x78, 0x00, 0x1E,
+  0x98, 0x6C, 0x0A, 0x00, 0x80, 0x20, 0xF8, 0x0B, 0x02, 0x60, 0x87, 0xC0,
+  0xE3, 0xA0, 0x90, 0x48, 0x27, 0xF2, 0x09, 0x04, 0x82, 0x41, 0x71, 0xC0,
+  0xF9, 0x08, 0x42, 0x10, 0x84, 0x27, 0xC0, 0x1F, 0x02, 0x02, 0x02, 0x02,
+  0x02, 0x82, 0x82, 0xC6, 0x78, 0xE3, 0xA1, 0x11, 0x09, 0x05, 0x83, 0x21,
+  0x08, 0x84, 0x41, 0x70, 0xC0, 0xE0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x41,
+  0x41, 0x41, 0xFF, 0xE0, 0xEC, 0x19, 0x45, 0x28, 0xA4, 0xA4, 0x94, 0x91,
+  0x12, 0x02, 0x40, 0x5C, 0x1C, 0xC3, 0xB0, 0x94, 0x4A, 0x24, 0x92, 0x49,
+  0x14, 0x8A, 0x43, 0x70, 0x80, 0x1E, 0x31, 0x90, 0x50, 0x18, 0x0C, 0x06,
+  0x02, 0x82, 0x63, 0x0F, 0x00, 0xFE, 0x43, 0x41, 0x41, 0x42, 0x7C, 0x40,
+  0x40, 0x40, 0xF0, 0x1C, 0x31, 0x90, 0x50, 0x18, 0x0C, 0x06, 0x02, 0x82,
+  0x63, 0x1F, 0x04, 0x07, 0x92, 0x30, 0xFE, 0x21, 0x90, 0x48, 0x24, 0x23,
+  0xE1, 0x10, 0x84, 0x41, 0x70, 0xC0, 0x3A, 0xCD, 0x0A, 0x03, 0x01, 0x80,
+  0xC1, 0xC7, 0x78, 0xFF, 0xC4, 0x62, 0x21, 0x00, 0x80, 0x40, 0x20, 0x10,
+  0x08, 0x1F, 0x00, 0xE3, 0xA0, 0x90, 0x48, 0x24, 0x12, 0x09, 0x04, 0x82,
+  0x22, 0x0E, 0x00, 0xF1, 0xE8, 0x10, 0x82, 0x10, 0x42, 0x10, 0x22, 0x04,
+  0x80, 0x50, 0x0C, 0x00, 0x80, 0xF1, 0xE8, 0x09, 0x11, 0x25, 0x44, 0xA8,
+  0x55, 0x0C, 0xA1, 0x8C, 0x31, 0x84, 0x30, 0xE3, 0xA0, 0x88, 0x82, 0x80,
+  0x80, 0xC0, 0x90, 0x44, 0x41, 0x71, 0xC0, 0xE3, 0xA0, 0x88, 0x82, 0x81,
+  0x40, 0x40, 0x20, 0x10, 0x08, 0x1F, 0x00, 0xFD, 0x0A, 0x20, 0x81, 0x04,
+  0x10, 0x21, 0x83, 0xFC, 0xEA, 0xAA, 0xAA, 0xC0, 0x80, 0x81, 0x03, 0x02,
+  0x04, 0x04, 0x08, 0x08, 0x10, 0x10, 0x20, 0x20, 0xD5, 0x55, 0x55, 0xC0,
+  0x10, 0x51, 0x22, 0x28, 0x20, 0xFF, 0xE0, 0x88, 0x80, 0x7E, 0x00, 0x80,
+  0x47, 0xEC, 0x14, 0x0A, 0x0C, 0xFB, 0xC0, 0x20, 0x10, 0x0B, 0xC6, 0x12,
+  0x05, 0x02, 0x81, 0x40, 0xB0, 0xB7, 0x80, 0x3A, 0x8E, 0x0C, 0x08, 0x10,
+  0x10, 0x9E, 0x03, 0x00, 0x80, 0x47, 0xA4, 0x34, 0x0A, 0x05, 0x02, 0x81,
+  0x21, 0x8F, 0x60, 0x3C, 0x43, 0x81, 0xFF, 0x80, 0x80, 0x61, 0x3E, 0x3D,
+  0x04, 0x3E, 0x41, 0x04, 0x10, 0x41, 0x0F, 0x80, 0x3D, 0xA1, 0xA0, 0x50,
+  0x28, 0x14, 0x09, 0x0C, 0x7A, 0x01, 0x01, 0x87, 0x80, 0xC0, 0x20, 0x10,
+  0x0B, 0xC6, 0x32, 0x09, 0x04, 0x82, 0x41, 0x20, 0xB8, 0xE0, 0x10, 0x01,
+  0xC0, 0x81, 0x02, 0x04, 0x08, 0x11, 0xFC, 0x10, 0x3E, 0x10, 0x84, 0x21,
+  0x08, 0x42, 0x3F, 0x00, 0xC0, 0x40, 0x40, 0x4F, 0x44, 0x58, 0x70, 0x48,
+  0x44, 0x42, 0xC7, 0x70, 0x20, 0x40, 0x81, 0x02, 0x04, 0x08, 0x10, 0x23,
+  0xF8, 0xB7, 0x64, 0x62, 0x31, 0x18, 0x8C, 0x46, 0x23, 0x91, 0x5E, 0x31,
+  0x90, 0x48, 0x24, 0x12, 0x09, 0x05, 0xC7, 0x3E, 0x31, 0xA0, 0x30, 0x18,
+  0x0C, 0x05, 0x8C, 0x7C, 0xDE, 0x30, 0x90, 0x28, 0x14, 0x0A, 0x05, 0x84,
+  0xBC, 0x40, 0x20, 0x38, 0x00, 0x3D, 0xA1, 0xA0, 0x50, 0x28, 0x14, 0x09,
+  0x0C, 0x7A, 0x01, 0x00, 0x80, 0xE0, 0xCE, 0xA1, 0x82, 0x04, 0x08, 0x10,
+  0x7C, 0x3A, 0x8D, 0x0B, 0x80, 0xF0, 0x70, 0xDE, 0x40, 0x40, 0xFC, 0x40,
+  0x40, 0x40, 0x40, 0x40, 0x41, 0x3E, 0xC3, 0x41, 0x41, 0x41, 0x41, 0x41,
+  0x43, 0x3D, 0xE3, 0xA0, 0x90, 0x84, 0x42, 0x20, 0xA0, 0x50, 0x10, 0xE3,
+  0xC0, 0x92, 0x4B, 0x25, 0x92, 0xA9, 0x98, 0x44, 0xE3, 0x31, 0x05, 0x01,
+  0x01, 0x41, 0x11, 0x05, 0xC7, 0xE3, 0xA0, 0x90, 0x84, 0x42, 0x40, 0xA0,
+  0x60, 0x10, 0x10, 0x08, 0x3E, 0x00, 0xFD, 0x08, 0x20, 0x82, 0x08, 0x10,
+  0xBF, 0x29, 0x24, 0xA2, 0x49, 0x26, 0xFF, 0xF8, 0x89, 0x24, 0x8A, 0x49,
+  0x2C, 0x61, 0x24, 0x30 };
+
+const GFXglyph FreeMono9pt7bGlyphs[] PROGMEM = {
+  {     0,   0,   0,  11,    0,    1 },   // 0x20 ' '
+  {     0,   2,  11,  11,    4,  -10 },   // 0x21 '!'
+  {     3,   6,   5,  11,    2,  -10 },   // 0x22 '"'
+  {     7,   7,  12,  11,    2,  -10 },   // 0x23 '#'
+  {    18,   8,  12,  11,    1,  -10 },   // 0x24 '$'
+  {    30,   7,  11,  11,    2,  -10 },   // 0x25 '%'
+  {    40,   7,  10,  11,    2,   -9 },   // 0x26 '&'
+  {    49,   3,   5,  11,    4,  -10 },   // 0x27 '''
+  {    51,   2,  13,  11,    5,  -10 },   // 0x28 '('
+  {    55,   2,  13,  11,    4,  -10 },   // 0x29 ')'
+  {    59,   7,   7,  11,    2,  -10 },   // 0x2A '*'
+  {    66,   7,   7,  11,    2,   -8 },   // 0x2B '+'
+  {    73,   3,   5,  11,    2,   -1 },   // 0x2C ','
+  {    75,   9,   1,  11,    1,   -5 },   // 0x2D '-'
+  {    77,   2,   2,  11,    4,   -1 },   // 0x2E '.'
+  {    78,   7,  13,  11,    2,  -11 },   // 0x2F '/'
+  {    90,   7,  11,  11,    2,  -10 },   // 0x30 '0'
+  {   100,   5,  11,  11,    3,  -10 },   // 0x31 '1'
+  {   107,   7,  11,  11,    2,  -10 },   // 0x32 '2'
+  {   117,   8,  11,  11,    1,  -10 },   // 0x33 '3'
+  {   128,   6,  11,  11,    3,  -10 },   // 0x34 '4'
+  {   137,   7,  11,  11,    2,  -10 },   // 0x35 '5'
+  {   147,   7,  11,  11,    2,  -10 },   // 0x36 '6'
+  {   157,   7,  11,  11,    2,  -10 },   // 0x37 '7'
+  {   167,   7,  11,  11,    2,  -10 },   // 0x38 '8'
+  {   177,   7,  11,  11,    2,  -10 },   // 0x39 '9'
+  {   187,   2,   8,  11,    4,   -7 },   // 0x3A ':'
+  {   189,   3,  11,  11,    3,   -7 },   // 0x3B ';'
+  {   194,   8,   8,  11,    1,   -8 },   // 0x3C '<'
+  {   202,   9,   4,  11,    1,   -6 },   // 0x3D '='
+  {   207,   9,   8,  11,    1,   -8 },   // 0x3E '>'
+  {   216,   7,  10,  11,    2,   -9 },   // 0x3F '?'
+  {   225,   8,  12,  11,    2,  -10 },   // 0x40 '@'
+  {   237,  11,  10,  11,    0,   -9 },   // 0x41 'A'
+  {   251,   9,  10,  11,    1,   -9 },   // 0x42 'B'
+  {   263,   9,  10,  11,    1,   -9 },   // 0x43 'C'
+  {   275,   9,  10,  11,    1,   -9 },   // 0x44 'D'
+  {   287,   9,  10,  11,    1,   -9 },   // 0x45 'E'
+  {   299,   9,  10,  11,    1,   -9 },   // 0x46 'F'
+  {   311,  10,  10,  11,    1,   -9 },   // 0x47 'G'
+  {   324,   9,  10,  11,    1,   -9 },   // 0x48 'H'
+  {   336,   5,  10,  11,    3,   -9 },   // 0x49 'I'
+  {   343,   8,  10,  11,    2,   -9 },   // 0x4A 'J'
+  {   353,   9,  10,  11,    1,   -9 },   // 0x4B 'K'
+  {   365,   8,  10,  11,    2,   -9 },   // 0x4C 'L'
+  {   375,  11,  10,  11,    0,   -9 },   // 0x4D 'M'
+  {   389,   9,  10,  11,    1,   -9 },   // 0x4E 'N'
+  {   401,   9,  10,  11,    1,   -9 },   // 0x4F 'O'
+  {   413,   8,  10,  11,    1,   -9 },   // 0x50 'P'
+  {   423,   9,  13,  11,    1,   -9 },   // 0x51 'Q'
+  {   438,   9,  10,  11,    1,   -9 },   // 0x52 'R'
+  {   450,   7,  10,  11,    2,   -9 },   // 0x53 'S'
+  {   459,   9,  10,  11,    1,   -9 },   // 0x54 'T'
+  {   471,   9,  10,  11,    1,   -9 },   // 0x55 'U'
+  {   483,  11,  10,  11,    0,   -9 },   // 0x56 'V'
+  {   497,  11,  10,  11,    0,   -9 },   // 0x57 'W'
+  {   511,   9,  10,  11,    1,   -9 },   // 0x58 'X'
+  {   523,   9,  10,  11,    1,   -9 },   // 0x59 'Y'
+  {   535,   7,  10,  11,    2,   -9 },   // 0x5A 'Z'
+  {   544,   2,  13,  11,    5,  -10 },   // 0x5B '['
+  {   548,   7,  13,  11,    2,  -11 },   // 0x5C '\'
+  {   560,   2,  13,  11,    4,  -10 },   // 0x5D ']'
+  {   564,   7,   5,  11,    2,  -10 },   // 0x5E '^'
+  {   569,  11,   1,  11,    0,    2 },   // 0x5F '_'
+  {   571,   3,   3,  11,    3,  -11 },   // 0x60 '`'
+  {   573,   9,   8,  11,    1,   -7 },   // 0x61 'a'
+  {   582,   9,  11,  11,    1,  -10 },   // 0x62 'b'
+  {   595,   7,   8,  11,    2,   -7 },   // 0x63 'c'
+  {   602,   9,  11,  11,    1,  -10 },   // 0x64 'd'
+  {   615,   8,   8,  11,    1,   -7 },   // 0x65 'e'
+  {   623,   6,  11,  11,    3,  -10 },   // 0x66 'f'
+  {   632,   9,  11,  11,    1,   -7 },   // 0x67 'g'
+  {   645,   9,  11,  11,    1,  -10 },   // 0x68 'h'
+  {   658,   7,  10,  11,    2,   -9 },   // 0x69 'i'
+  {   667,   5,  13,  11,    3,   -9 },   // 0x6A 'j'
+  {   676,   8,  11,  11,    2,  -10 },   // 0x6B 'k'
+  {   687,   7,  11,  11,    2,  -10 },   // 0x6C 'l'
+  {   697,   9,   8,  11,    1,   -7 },   // 0x6D 'm'
+  {   706,   9,   8,  11,    1,   -7 },   // 0x6E 'n'
+  {   715,   9,   8,  11,    1,   -7 },   // 0x6F 'o'
+  {   724,   9,  11,  11,    1,   -7 },   // 0x70 'p'
+  {   737,   9,  11,  11,    1,   -7 },   // 0x71 'q'
+  {   750,   7,   8,  11,    3,   -7 },   // 0x72 'r'
+  {   757,   7,   8,  11,    2,   -7 },   // 0x73 's'
+  {   764,   8,  10,  11,    2,   -9 },   // 0x74 't'
+  {   774,   8,   8,  11,    1,   -7 },   // 0x75 'u'
+  {   782,   9,   8,  11,    1,   -7 },   // 0x76 'v'
+  {   791,   9,   8,  11,    1,   -7 },   // 0x77 'w'
+  {   800,   9,   8,  11,    1,   -7 },   // 0x78 'x'
+  {   809,   9,  11,  11,    1,   -7 },   // 0x79 'y'
+  {   822,   7,   8,  11,    2,   -7 },   // 0x7A 'z'
+  {   829,   3,  13,  11,    4,  -10 },   // 0x7B '{'
+  {   834,   1,  13,  11,    5,  -10 },   // 0x7C '|'
+  {   836,   3,  13,  11,    4,  -10 },   // 0x7D '}'
+  {   841,   7,   3,  11,    2,   -6 } }; // 0x7E '~'
+
+const GFXfont FreeMono9pt7b PROGMEM = {
+  (uint8_t  *)FreeMono9pt7bBitmaps,
+  (GFXglyph *)FreeMono9pt7bGlyphs,
+  0x20, 0x7E, 18 };
+
+// Approx. 1516 bytes
diff --git a/libraries/fonts/FreeSans12pt7b.h b/libraries/fonts/FreeSans12pt7b.h
new file mode 100755
index 0000000..9ecbb8f
--- /dev/null
+++ b/libraries/fonts/FreeSans12pt7b.h
@@ -0,0 +1,270 @@
+const uint8_t FreeSans12pt7bBitmaps[] PROGMEM = {
+  0xFF, 0xFF, 0xFF, 0xF0, 0xF0, 0xCF, 0x3C, 0xF3, 0x8A, 0x20, 0x06, 0x30,
+  0x31, 0x03, 0x18, 0x18, 0xC7, 0xFF, 0xBF, 0xFC, 0x31, 0x03, 0x18, 0x18,
+  0xC7, 0xFF, 0xBF, 0xFC, 0x31, 0x01, 0x18, 0x18, 0xC0, 0xC6, 0x06, 0x30,
+  0x04, 0x03, 0xE1, 0xFF, 0x72, 0x6C, 0x47, 0x88, 0xF1, 0x07, 0x20, 0x7E,
+  0x03, 0xF0, 0x17, 0x02, 0x3C, 0x47, 0x88, 0xF1, 0x1B, 0x26, 0x7F, 0xC3,
+  0xE0, 0x10, 0x02, 0x00, 0x00, 0x06, 0x03, 0xC0, 0x40, 0x7E, 0x0C, 0x0E,
+  0x70, 0x80, 0xC3, 0x18, 0x0C, 0x31, 0x00, 0xE7, 0x30, 0x07, 0xE6, 0x00,
+  0x3C, 0x40, 0x00, 0x0C, 0x7C, 0x00, 0x8F, 0xE0, 0x19, 0xC7, 0x01, 0x18,
+  0x30, 0x31, 0x83, 0x02, 0x1C, 0x70, 0x40, 0xFE, 0x04, 0x07, 0xC0, 0x0F,
+  0x00, 0x7E, 0x03, 0x9C, 0x0C, 0x30, 0x30, 0xC0, 0xE7, 0x01, 0xF8, 0x03,
+  0x80, 0x3E, 0x01, 0xCC, 0x6E, 0x19, 0xB0, 0x7C, 0xC0, 0xF3, 0x03, 0xCE,
+  0x1F, 0x9F, 0xE6, 0x1E, 0x1C, 0xFF, 0xA0, 0x08, 0x8C, 0x66, 0x31, 0x98,
+  0xC6, 0x31, 0x8C, 0x63, 0x08, 0x63, 0x08, 0x61, 0x0C, 0x20, 0x82, 0x18,
+  0xC3, 0x18, 0xC3, 0x18, 0xC6, 0x31, 0x8C, 0x62, 0x31, 0x88, 0xC4, 0x62,
+  0x00, 0x10, 0x23, 0x5B, 0xE3, 0x8D, 0x91, 0x00, 0x0C, 0x03, 0x00, 0xC0,
+  0x30, 0xFF, 0xFF, 0xF0, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0xF5, 0x60,
+  0xFF, 0xF0, 0xF0, 0x02, 0x0C, 0x10, 0x20, 0xC1, 0x02, 0x0C, 0x10, 0x20,
+  0xC1, 0x02, 0x0C, 0x10, 0x20, 0xC1, 0x00, 0x1F, 0x07, 0xF1, 0xC7, 0x30,
+  0x6E, 0x0F, 0x80, 0xF0, 0x1E, 0x03, 0xC0, 0x78, 0x0F, 0x01, 0xE0, 0x3C,
+  0x0E, 0xC1, 0x9C, 0x71, 0xFC, 0x1F, 0x00, 0x08, 0xCF, 0xFF, 0x8C, 0x63,
+  0x18, 0xC6, 0x31, 0x8C, 0x63, 0x18, 0x1F, 0x0F, 0xF9, 0x87, 0x60, 0x7C,
+  0x06, 0x00, 0xC0, 0x18, 0x07, 0x01, 0xC0, 0xF0, 0x78, 0x1C, 0x06, 0x00,
+  0x80, 0x30, 0x07, 0xFF, 0xFF, 0xE0, 0x3F, 0x0F, 0xF3, 0x87, 0x60, 0x6C,
+  0x0C, 0x01, 0x80, 0x70, 0x7C, 0x0F, 0x80, 0x18, 0x01, 0x80, 0x3C, 0x07,
+  0x80, 0xD8, 0x73, 0xFC, 0x1F, 0x00, 0x01, 0x80, 0x70, 0x0E, 0x03, 0xC0,
+  0xD8, 0x1B, 0x06, 0x61, 0x8C, 0x21, 0x8C, 0x33, 0x06, 0x7F, 0xFF, 0xFE,
+  0x03, 0x00, 0x60, 0x0C, 0x01, 0x80, 0x3F, 0xCF, 0xF9, 0x80, 0x30, 0x06,
+  0x00, 0xDE, 0x1F, 0xE7, 0x0E, 0x00, 0xE0, 0x0C, 0x01, 0x80, 0x30, 0x07,
+  0x81, 0xF8, 0x73, 0xFC, 0x1F, 0x00, 0x0F, 0x07, 0xF9, 0xC3, 0x30, 0x74,
+  0x01, 0x80, 0x33, 0xC7, 0xFE, 0xF0, 0xDC, 0x1F, 0x01, 0xE0, 0x3C, 0x06,
+  0xC1, 0xDC, 0x71, 0xFC, 0x1F, 0x00, 0xFF, 0xFF, 0xFC, 0x01, 0x00, 0x60,
+  0x18, 0x02, 0x00, 0xC0, 0x30, 0x06, 0x01, 0x80, 0x30, 0x04, 0x01, 0x80,
+  0x30, 0x06, 0x01, 0x80, 0x30, 0x00, 0x1F, 0x07, 0xF1, 0xC7, 0x30, 0x66,
+  0x0C, 0xC1, 0x8C, 0x61, 0xFC, 0x3F, 0x8E, 0x3B, 0x01, 0xE0, 0x3C, 0x07,
+  0x80, 0xD8, 0x31, 0xFC, 0x1F, 0x00, 0x1F, 0x07, 0xF1, 0xC7, 0x70, 0x6C,
+  0x07, 0x80, 0xF0, 0x1E, 0x07, 0x61, 0xEF, 0xFC, 0x79, 0x80, 0x30, 0x05,
+  0x81, 0x98, 0x73, 0xFC, 0x1E, 0x00, 0xF0, 0x00, 0x03, 0xC0, 0xF0, 0x00,
+  0x0F, 0x56, 0x00, 0x00, 0x07, 0x01, 0xE0, 0xF8, 0x3C, 0x0F, 0x00, 0xE0,
+  0x07, 0xC0, 0x0F, 0x00, 0x3C, 0x00, 0xF0, 0x01, 0xFF, 0xFF, 0xFF, 0x00,
+  0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x0E, 0x00, 0x78, 0x01, 0xF0, 0x07,
+  0xC0, 0x0F, 0x00, 0x70, 0x1E, 0x0F, 0x03, 0xC0, 0xF0, 0x08, 0x00, 0x1F,
+  0x1F, 0xEE, 0x1B, 0x03, 0xC0, 0xC0, 0x30, 0x0C, 0x06, 0x03, 0x81, 0xC0,
+  0xE0, 0x30, 0x0C, 0x03, 0x00, 0x00, 0x00, 0x0C, 0x03, 0x00, 0x00, 0xFE,
+  0x00, 0x0F, 0xFE, 0x00, 0xF0, 0x3E, 0x07, 0x00, 0x3C, 0x38, 0x00, 0x30,
+  0xC1, 0xE0, 0x66, 0x0F, 0xD9, 0xD8, 0x61, 0xC3, 0xC3, 0x07, 0x0F, 0x1C,
+  0x1C, 0x3C, 0x60, 0x60, 0xF1, 0x81, 0x83, 0xC6, 0x06, 0x1B, 0x18, 0x38,
+  0xEE, 0x71, 0xE7, 0x18, 0xFD, 0xF8, 0x71, 0xE7, 0xC0, 0xE0, 0x00, 0x01,
+  0xE0, 0x00, 0x01, 0xFF, 0xC0, 0x01, 0xFC, 0x00, 0x03, 0xC0, 0x03, 0xC0,
+  0x03, 0xC0, 0x07, 0xE0, 0x06, 0x60, 0x06, 0x60, 0x0E, 0x70, 0x0C, 0x30,
+  0x0C, 0x30, 0x1C, 0x38, 0x18, 0x18, 0x1F, 0xF8, 0x3F, 0xFC, 0x30, 0x1C,
+  0x30, 0x0C, 0x70, 0x0E, 0x60, 0x06, 0x60, 0x06, 0xFF, 0xC7, 0xFF, 0x30,
+  0x19, 0x80, 0x6C, 0x03, 0x60, 0x1B, 0x00, 0xD8, 0x0C, 0xFF, 0xC7, 0xFF,
+  0x30, 0x0D, 0x80, 0x3C, 0x01, 0xE0, 0x0F, 0x00, 0x78, 0x06, 0xFF, 0xF7,
+  0xFE, 0x00, 0x07, 0xE0, 0x3F, 0xF0, 0xE0, 0x73, 0x80, 0x66, 0x00, 0x6C,
+  0x00, 0x30, 0x00, 0x60, 0x00, 0xC0, 0x01, 0x80, 0x03, 0x00, 0x06, 0x00,
+  0x06, 0x00, 0x6C, 0x00, 0xDC, 0x03, 0x1E, 0x0E, 0x1F, 0xF8, 0x0F, 0xC0,
+  0xFF, 0x83, 0xFF, 0x8C, 0x07, 0x30, 0x0E, 0xC0, 0x1B, 0x00, 0x7C, 0x00,
+  0xF0, 0x03, 0xC0, 0x0F, 0x00, 0x3C, 0x00, 0xF0, 0x03, 0xC0, 0x1F, 0x00,
+  0x6C, 0x03, 0xB0, 0x1C, 0xFF, 0xE3, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xC0,
+  0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xFF, 0xEF, 0xFE, 0xC0,
+  0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0x00, 0x60, 0x0C, 0x01, 0x80, 0x30, 0x06, 0x00, 0xFF, 0xDF,
+  0xFB, 0x00, 0x60, 0x0C, 0x01, 0x80, 0x30, 0x06, 0x00, 0xC0, 0x18, 0x00,
+  0x07, 0xF0, 0x1F, 0xFC, 0x3C, 0x1E, 0x70, 0x06, 0x60, 0x03, 0xE0, 0x00,
+  0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x7F, 0xC0, 0x7F, 0xC0, 0x03, 0xC0, 0x03,
+  0x60, 0x03, 0x60, 0x07, 0x30, 0x0F, 0x3C, 0x1F, 0x1F, 0xFB, 0x07, 0xE1,
+  0xC0, 0x1E, 0x00, 0xF0, 0x07, 0x80, 0x3C, 0x01, 0xE0, 0x0F, 0x00, 0x78,
+  0x03, 0xFF, 0xFF, 0xFF, 0xF0, 0x07, 0x80, 0x3C, 0x01, 0xE0, 0x0F, 0x00,
+  0x78, 0x03, 0xC0, 0x1E, 0x00, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x01,
+  0x80, 0xC0, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x03, 0x01, 0x80, 0xC0, 0x60,
+  0x3C, 0x1E, 0x0F, 0x07, 0xC7, 0x7F, 0x1F, 0x00, 0xC0, 0x3B, 0x01, 0xCC,
+  0x0E, 0x30, 0x70, 0xC3, 0x83, 0x1C, 0x0C, 0xE0, 0x33, 0x80, 0xDE, 0x03,
+  0xDC, 0x0E, 0x38, 0x30, 0x60, 0xC1, 0xC3, 0x03, 0x8C, 0x06, 0x30, 0x1C,
+  0xC0, 0x3B, 0x00, 0x60, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x0C,
+  0x03, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0x00,
+  0xFF, 0xFF, 0xF0, 0xE0, 0x07, 0xE0, 0x07, 0xF0, 0x0F, 0xF0, 0x0F, 0xD0,
+  0x0F, 0xD8, 0x1B, 0xD8, 0x1B, 0xD8, 0x1B, 0xCC, 0x33, 0xCC, 0x33, 0xCC,
+  0x33, 0xC6, 0x63, 0xC6, 0x63, 0xC6, 0x63, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3,
+  0xC3, 0xC1, 0x83, 0xE0, 0x1F, 0x00, 0xFC, 0x07, 0xE0, 0x3D, 0x81, 0xEE,
+  0x0F, 0x30, 0x79, 0xC3, 0xC6, 0x1E, 0x18, 0xF0, 0xE7, 0x83, 0x3C, 0x1D,
+  0xE0, 0x6F, 0x01, 0xF8, 0x0F, 0xC0, 0x3E, 0x01, 0xC0, 0x03, 0xE0, 0x0F,
+  0xFC, 0x0F, 0x07, 0x86, 0x00, 0xC6, 0x00, 0x33, 0x00, 0x1B, 0x00, 0x07,
+  0x80, 0x03, 0xC0, 0x01, 0xE0, 0x00, 0xF0, 0x00, 0x78, 0x00, 0x36, 0x00,
+  0x33, 0x00, 0x18, 0xC0, 0x18, 0x78, 0x3C, 0x1F, 0xFC, 0x03, 0xF8, 0x00,
+  0xFF, 0x8F, 0xFE, 0xC0, 0x6C, 0x03, 0xC0, 0x3C, 0x03, 0xC0, 0x3C, 0x07,
+  0xFF, 0xEF, 0xFC, 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0x00,
+  0xC0, 0x0C, 0x00, 0x03, 0xE0, 0x0F, 0xFC, 0x0F, 0x07, 0x86, 0x00, 0xC6,
+  0x00, 0x33, 0x00, 0x1B, 0x00, 0x07, 0x80, 0x03, 0xC0, 0x01, 0xE0, 0x00,
+  0xF0, 0x00, 0x78, 0x00, 0x36, 0x00, 0x33, 0x01, 0x98, 0xC0, 0xFC, 0x78,
+  0x3C, 0x1F, 0xFF, 0x03, 0xF9, 0x80, 0x00, 0x40, 0xFF, 0xC3, 0xFF, 0xCC,
+  0x03, 0xB0, 0x06, 0xC0, 0x1B, 0x00, 0x6C, 0x01, 0xB0, 0x0C, 0xFF, 0xE3,
+  0xFF, 0xCC, 0x03, 0xB0, 0x06, 0xC0, 0x1B, 0x00, 0x6C, 0x01, 0xB0, 0x06,
+  0xC0, 0x1B, 0x00, 0x70, 0x0F, 0xE0, 0x7F, 0xC3, 0x83, 0x9C, 0x07, 0x60,
+  0x0D, 0x80, 0x06, 0x00, 0x1E, 0x00, 0x3F, 0x80, 0x3F, 0xC0, 0x0F, 0x80,
+  0x07, 0xC0, 0x0F, 0x00, 0x3E, 0x00, 0xDE, 0x0E, 0x3F, 0xF0, 0x3F, 0x80,
+  0xFF, 0xFF, 0xFF, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60,
+  0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60,
+  0x06, 0x00, 0x60, 0xC0, 0x1E, 0x00, 0xF0, 0x07, 0x80, 0x3C, 0x01, 0xE0,
+  0x0F, 0x00, 0x78, 0x03, 0xC0, 0x1E, 0x00, 0xF0, 0x07, 0x80, 0x3C, 0x01,
+  0xE0, 0x0F, 0x80, 0xEE, 0x0E, 0x3F, 0xE0, 0x7C, 0x00, 0x60, 0x06, 0xC0,
+  0x1D, 0xC0, 0x31, 0x80, 0x63, 0x01, 0xC7, 0x03, 0x06, 0x06, 0x0C, 0x1C,
+  0x1C, 0x30, 0x18, 0x60, 0x31, 0xC0, 0x73, 0x00, 0x66, 0x00, 0xDC, 0x01,
+  0xF0, 0x01, 0xE0, 0x03, 0xC0, 0x07, 0x00, 0xE0, 0x30, 0x1D, 0x80, 0xE0,
+  0x76, 0x07, 0x81, 0xD8, 0x1E, 0x06, 0x70, 0x7C, 0x18, 0xC1, 0xB0, 0xE3,
+  0x0C, 0xC3, 0x8C, 0x33, 0x0C, 0x38, 0xC6, 0x30, 0x67, 0x18, 0xC1, 0x98,
+  0x67, 0x06, 0x61, 0xD8, 0x1D, 0x83, 0x60, 0x3C, 0x0D, 0x80, 0xF0, 0x3E,
+  0x03, 0xC0, 0x70, 0x0F, 0x01, 0xC0, 0x18, 0x07, 0x00, 0x70, 0x0E, 0x60,
+  0x38, 0xE0, 0x60, 0xE1, 0xC0, 0xC3, 0x01, 0xCC, 0x01, 0xF8, 0x01, 0xE0,
+  0x03, 0x80, 0x07, 0x80, 0x1F, 0x00, 0x33, 0x00, 0xE7, 0x03, 0x86, 0x06,
+  0x0E, 0x1C, 0x0E, 0x70, 0x0C, 0xC0, 0x1C, 0x60, 0x06, 0x70, 0x0E, 0x30,
+  0x1C, 0x38, 0x18, 0x1C, 0x38, 0x0C, 0x30, 0x0E, 0x70, 0x06, 0x60, 0x03,
+  0xC0, 0x03, 0xC0, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01,
+  0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0xFF, 0xFF, 0xFF, 0xC0, 0x0E,
+  0x00, 0xE0, 0x0E, 0x00, 0x60, 0x07, 0x00, 0x70, 0x07, 0x00, 0x30, 0x03,
+  0x80, 0x38, 0x03, 0x80, 0x18, 0x01, 0xC0, 0x1C, 0x00, 0xFF, 0xFF, 0xFF,
+  0xC0, 0xFF, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCF,
+  0xF0, 0x81, 0x81, 0x02, 0x06, 0x04, 0x08, 0x18, 0x10, 0x20, 0x60, 0x40,
+  0x81, 0x81, 0x02, 0x06, 0x04, 0xFF, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33,
+  0x33, 0x33, 0x33, 0x3F, 0xF0, 0x0C, 0x0E, 0x05, 0x86, 0xC3, 0x21, 0x19,
+  0x8C, 0x83, 0xC1, 0x80, 0xFF, 0xFE, 0xE3, 0x8C, 0x30, 0x3F, 0x07, 0xF8,
+  0xE1, 0xCC, 0x0C, 0x00, 0xC0, 0x1C, 0x3F, 0xCF, 0x8C, 0xC0, 0xCC, 0x0C,
+  0xE3, 0xC7, 0xEF, 0x3C, 0x70, 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xC0,
+  0x0C, 0xF8, 0xDF, 0xCF, 0x0E, 0xE0, 0x7C, 0x03, 0xC0, 0x3C, 0x03, 0xC0,
+  0x3C, 0x03, 0xE0, 0x6F, 0x0E, 0xDF, 0xCC, 0xF8, 0x1F, 0x0F, 0xE7, 0x1B,
+  0x83, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x38, 0x37, 0x1C, 0xFE, 0x1F,
+  0x00, 0x00, 0x60, 0x0C, 0x01, 0x80, 0x30, 0x06, 0x3C, 0xCF, 0xFB, 0x8F,
+  0xE0, 0xF8, 0x0F, 0x01, 0xE0, 0x3C, 0x07, 0x80, 0xF8, 0x3B, 0x8F, 0x3F,
+  0x63, 0xCC, 0x1F, 0x07, 0xF1, 0xC7, 0x70, 0x3C, 0x07, 0xFF, 0xFF, 0xFE,
+  0x00, 0xC0, 0x1C, 0x0D, 0xC3, 0x1F, 0xE1, 0xF0, 0x3B, 0xD8, 0xC6, 0x7F,
+  0xEC, 0x63, 0x18, 0xC6, 0x31, 0x8C, 0x63, 0x00, 0x1E, 0x67, 0xFD, 0xC7,
+  0xF0, 0x7C, 0x07, 0x80, 0xF0, 0x1E, 0x03, 0xC0, 0x7C, 0x1D, 0xC7, 0x9F,
+  0xB1, 0xE6, 0x00, 0xC0, 0x3E, 0x0E, 0x7F, 0xC7, 0xE0, 0xC0, 0x30, 0x0C,
+  0x03, 0x00, 0xC0, 0x33, 0xCD, 0xFB, 0xC7, 0xE0, 0xF0, 0x3C, 0x0F, 0x03,
+  0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x30, 0xF0, 0x3F, 0xFF, 0xFF,
+  0xF0, 0x33, 0x00, 0x03, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x3F,
+  0xE0, 0xC0, 0x18, 0x03, 0x00, 0x60, 0x0C, 0x01, 0x83, 0x30, 0xC6, 0x30,
+  0xCC, 0x1B, 0x83, 0xF0, 0x77, 0x0C, 0x61, 0x8E, 0x30, 0xE6, 0x0C, 0xC1,
+  0xD8, 0x18, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xCF, 0x1F, 0x6F, 0xDF, 0xFC,
+  0x78, 0xFC, 0x18, 0x3C, 0x0C, 0x1E, 0x06, 0x0F, 0x03, 0x07, 0x81, 0x83,
+  0xC0, 0xC1, 0xE0, 0x60, 0xF0, 0x30, 0x78, 0x18, 0x3C, 0x0C, 0x18, 0xCF,
+  0x37, 0xEF, 0x1F, 0x83, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C,
+  0x0F, 0x03, 0xC0, 0xC0, 0x1F, 0x07, 0xF1, 0xC7, 0x70, 0x7C, 0x07, 0x80,
+  0xF0, 0x1E, 0x03, 0xC0, 0x7C, 0x1D, 0xC7, 0x1F, 0xC1, 0xF0, 0xCF, 0x8D,
+  0xFC, 0xF0, 0xEE, 0x06, 0xC0, 0x3C, 0x03, 0xC0, 0x3C, 0x03, 0xC0, 0x3E,
+  0x07, 0xF0, 0xEF, 0xFC, 0xCF, 0x8C, 0x00, 0xC0, 0x0C, 0x00, 0xC0, 0x00,
+  0x1E, 0x67, 0xFD, 0xC7, 0xF0, 0x7C, 0x07, 0x80, 0xF0, 0x1E, 0x03, 0xC0,
+  0x7C, 0x1D, 0xC7, 0x9F, 0xF1, 0xE6, 0x00, 0xC0, 0x18, 0x03, 0x00, 0x60,
+  0xCF, 0x7F, 0x38, 0xC3, 0x0C, 0x30, 0xC3, 0x0C, 0x30, 0xC0, 0x3E, 0x1F,
+  0xEE, 0x1B, 0x00, 0xC0, 0x3C, 0x07, 0xF0, 0x3E, 0x01, 0xF0, 0x3E, 0x1D,
+  0xFE, 0x3E, 0x00, 0x63, 0x19, 0xFF, 0xB1, 0x8C, 0x63, 0x18, 0xC6, 0x31,
+  0xE7, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0,
+  0xF0, 0x7E, 0x3D, 0xFB, 0x3C, 0xC0, 0xE0, 0x66, 0x06, 0x60, 0x67, 0x0C,
+  0x30, 0xC3, 0x0C, 0x39, 0x81, 0x98, 0x19, 0x81, 0xF0, 0x0F, 0x00, 0xE0,
+  0x0E, 0x00, 0xC1, 0xC1, 0xB0, 0xE1, 0xD8, 0x70, 0xCC, 0x2C, 0x66, 0x36,
+  0x31, 0x9B, 0x18, 0xCD, 0x98, 0x64, 0x6C, 0x16, 0x36, 0x0F, 0x1A, 0x07,
+  0x8F, 0x03, 0x83, 0x80, 0xC1, 0xC0, 0x60, 0xEE, 0x18, 0xC6, 0x0C, 0xC1,
+  0xF0, 0x1C, 0x01, 0x80, 0x78, 0x1B, 0x03, 0x30, 0xC7, 0x30, 0x66, 0x06,
+  0xE0, 0x6C, 0x0D, 0x83, 0x38, 0x63, 0x0C, 0x63, 0x0E, 0x60, 0xCC, 0x1B,
+  0x03, 0x60, 0x3C, 0x07, 0x00, 0xE0, 0x18, 0x03, 0x00, 0xE0, 0x78, 0x0E,
+  0x00, 0xFF, 0xFF, 0xF0, 0x18, 0x0C, 0x07, 0x03, 0x81, 0xC0, 0x60, 0x30,
+  0x18, 0x0E, 0x03, 0xFF, 0xFF, 0xC0, 0x19, 0xCC, 0x63, 0x18, 0xC6, 0x31,
+  0x99, 0x86, 0x18, 0xC6, 0x31, 0x8C, 0x63, 0x1C, 0x60, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFC, 0xC7, 0x18, 0xC6, 0x31, 0x8C, 0x63, 0x0C, 0x33, 0x31,
+  0x8C, 0x63, 0x18, 0xC6, 0x73, 0x00, 0x70, 0x3E, 0x09, 0xE4, 0x1F, 0x03,
+  0x80 };
+
+const GFXglyph FreeSans12pt7bGlyphs[] PROGMEM = {
+  {     0,   0,   0,   6,    0,    1 },   // 0x20 ' '
+  {     0,   2,  18,   8,    3,  -17 },   // 0x21 '!'
+  {     5,   6,   6,   8,    1,  -16 },   // 0x22 '"'
+  {    10,  13,  16,  13,    0,  -15 },   // 0x23 '#'
+  {    36,  11,  20,  13,    1,  -17 },   // 0x24 '$'
+  {    64,  20,  17,  21,    1,  -16 },   // 0x25 '%'
+  {   107,  14,  17,  16,    1,  -16 },   // 0x26 '&'
+  {   137,   2,   6,   5,    1,  -16 },   // 0x27 '''
+  {   139,   5,  23,   8,    2,  -17 },   // 0x28 '('
+  {   154,   5,  23,   8,    1,  -17 },   // 0x29 ')'
+  {   169,   7,   7,   9,    1,  -17 },   // 0x2A '*'
+  {   176,  10,  11,  14,    2,  -10 },   // 0x2B '+'
+  {   190,   2,   6,   7,    2,   -1 },   // 0x2C ','
+  {   192,   6,   2,   8,    1,   -7 },   // 0x2D '-'
+  {   194,   2,   2,   6,    2,   -1 },   // 0x2E '.'
+  {   195,   7,  18,   7,    0,  -17 },   // 0x2F '/'
+  {   211,  11,  17,  13,    1,  -16 },   // 0x30 '0'
+  {   235,   5,  17,  13,    3,  -16 },   // 0x31 '1'
+  {   246,  11,  17,  13,    1,  -16 },   // 0x32 '2'
+  {   270,  11,  17,  13,    1,  -16 },   // 0x33 '3'
+  {   294,  11,  17,  13,    1,  -16 },   // 0x34 '4'
+  {   318,  11,  17,  13,    1,  -16 },   // 0x35 '5'
+  {   342,  11,  17,  13,    1,  -16 },   // 0x36 '6'
+  {   366,  11,  17,  13,    1,  -16 },   // 0x37 '7'
+  {   390,  11,  17,  13,    1,  -16 },   // 0x38 '8'
+  {   414,  11,  17,  13,    1,  -16 },   // 0x39 '9'
+  {   438,   2,  13,   6,    2,  -12 },   // 0x3A ':'
+  {   442,   2,  16,   6,    2,  -11 },   // 0x3B ';'
+  {   446,  12,  12,  14,    1,  -11 },   // 0x3C '<'
+  {   464,  12,   6,  14,    1,   -8 },   // 0x3D '='
+  {   473,  12,  12,  14,    1,  -11 },   // 0x3E '>'
+  {   491,  10,  18,  13,    2,  -17 },   // 0x3F '?'
+  {   514,  22,  21,  24,    1,  -17 },   // 0x40 '@'
+  {   572,  16,  18,  16,    0,  -17 },   // 0x41 'A'
+  {   608,  13,  18,  16,    2,  -17 },   // 0x42 'B'
+  {   638,  15,  18,  17,    1,  -17 },   // 0x43 'C'
+  {   672,  14,  18,  17,    2,  -17 },   // 0x44 'D'
+  {   704,  12,  18,  15,    2,  -17 },   // 0x45 'E'
+  {   731,  11,  18,  14,    2,  -17 },   // 0x46 'F'
+  {   756,  16,  18,  18,    1,  -17 },   // 0x47 'G'
+  {   792,  13,  18,  17,    2,  -17 },   // 0x48 'H'
+  {   822,   2,  18,   7,    2,  -17 },   // 0x49 'I'
+  {   827,   9,  18,  13,    1,  -17 },   // 0x4A 'J'
+  {   848,  14,  18,  16,    2,  -17 },   // 0x4B 'K'
+  {   880,  10,  18,  14,    2,  -17 },   // 0x4C 'L'
+  {   903,  16,  18,  20,    2,  -17 },   // 0x4D 'M'
+  {   939,  13,  18,  18,    2,  -17 },   // 0x4E 'N'
+  {   969,  17,  18,  19,    1,  -17 },   // 0x4F 'O'
+  {  1008,  12,  18,  16,    2,  -17 },   // 0x50 'P'
+  {  1035,  17,  19,  19,    1,  -17 },   // 0x51 'Q'
+  {  1076,  14,  18,  17,    2,  -17 },   // 0x52 'R'
+  {  1108,  14,  18,  16,    1,  -17 },   // 0x53 'S'
+  {  1140,  12,  18,  15,    1,  -17 },   // 0x54 'T'
+  {  1167,  13,  18,  17,    2,  -17 },   // 0x55 'U'
+  {  1197,  15,  18,  15,    0,  -17 },   // 0x56 'V'
+  {  1231,  22,  18,  22,    0,  -17 },   // 0x57 'W'
+  {  1281,  15,  18,  16,    0,  -17 },   // 0x58 'X'
+  {  1315,  16,  18,  16,    0,  -17 },   // 0x59 'Y'
+  {  1351,  13,  18,  15,    1,  -17 },   // 0x5A 'Z'
+  {  1381,   4,  23,   7,    2,  -17 },   // 0x5B '['
+  {  1393,   7,  18,   7,    0,  -17 },   // 0x5C '\'
+  {  1409,   4,  23,   7,    1,  -17 },   // 0x5D ']'
+  {  1421,   9,   9,  11,    1,  -16 },   // 0x5E '^'
+  {  1432,  15,   1,  13,   -1,    4 },   // 0x5F '_'
+  {  1434,   5,   4,   6,    1,  -17 },   // 0x60 '`'
+  {  1437,  12,  13,  13,    1,  -12 },   // 0x61 'a'
+  {  1457,  12,  18,  13,    1,  -17 },   // 0x62 'b'
+  {  1484,  10,  13,  12,    1,  -12 },   // 0x63 'c'
+  {  1501,  11,  18,  13,    1,  -17 },   // 0x64 'd'
+  {  1526,  11,  13,  13,    1,  -12 },   // 0x65 'e'
+  {  1544,   5,  18,   7,    1,  -17 },   // 0x66 'f'
+  {  1556,  11,  18,  13,    1,  -12 },   // 0x67 'g'
+  {  1581,  10,  18,  13,    1,  -17 },   // 0x68 'h'
+  {  1604,   2,  18,   5,    2,  -17 },   // 0x69 'i'
+  {  1609,   4,  23,   6,    0,  -17 },   // 0x6A 'j'
+  {  1621,  11,  18,  12,    1,  -17 },   // 0x6B 'k'
+  {  1646,   2,  18,   5,    1,  -17 },   // 0x6C 'l'
+  {  1651,  17,  13,  19,    1,  -12 },   // 0x6D 'm'
+  {  1679,  10,  13,  13,    1,  -12 },   // 0x6E 'n'
+  {  1696,  11,  13,  13,    1,  -12 },   // 0x6F 'o'
+  {  1714,  12,  17,  13,    1,  -12 },   // 0x70 'p'
+  {  1740,  11,  17,  13,    1,  -12 },   // 0x71 'q'
+  {  1764,   6,  13,   8,    1,  -12 },   // 0x72 'r'
+  {  1774,  10,  13,  12,    1,  -12 },   // 0x73 's'
+  {  1791,   5,  16,   7,    1,  -15 },   // 0x74 't'
+  {  1801,  10,  13,  13,    1,  -12 },   // 0x75 'u'
+  {  1818,  12,  13,  12,    0,  -12 },   // 0x76 'v'
+  {  1838,  17,  13,  17,    0,  -12 },   // 0x77 'w'
+  {  1866,  11,  13,  11,    0,  -12 },   // 0x78 'x'
+  {  1884,  11,  18,  11,    0,  -12 },   // 0x79 'y'
+  {  1909,  10,  13,  12,    1,  -12 },   // 0x7A 'z'
+  {  1926,   5,  23,   8,    1,  -17 },   // 0x7B '{'
+  {  1941,   2,  23,   6,    2,  -17 },   // 0x7C '|'
+  {  1947,   5,  23,   8,    2,  -17 },   // 0x7D '}'
+  {  1962,  10,   5,  12,    1,  -10 } }; // 0x7E '~'
+
+const GFXfont FreeSans12pt7b PROGMEM = {
+  (uint8_t  *)FreeSans12pt7bBitmaps,
+  (GFXglyph *)FreeSans12pt7bGlyphs,
+  0x20, 0x7E, 29 };
+
+// Approx. 2641 bytes
diff --git a/libraries/fonts/FreeSans9pt7b.h b/libraries/fonts/FreeSans9pt7b.h
new file mode 100755
index 0000000..1f006a1
--- /dev/null
+++ b/libraries/fonts/FreeSans9pt7b.h
@@ -0,0 +1,201 @@
+const uint8_t FreeSans9pt7bBitmaps[] PROGMEM = {
+  0xFF, 0xFF, 0xF8, 0xC0, 0xDE, 0xF7, 0x20, 0x09, 0x86, 0x41, 0x91, 0xFF,
+  0x13, 0x04, 0xC3, 0x20, 0xC8, 0xFF, 0x89, 0x82, 0x61, 0x90, 0x10, 0x1F,
+  0x14, 0xDA, 0x3D, 0x1E, 0x83, 0x40, 0x78, 0x17, 0x08, 0xF4, 0x7A, 0x35,
+  0x33, 0xF0, 0x40, 0x20, 0x38, 0x10, 0xEC, 0x20, 0xC6, 0x20, 0xC6, 0x40,
+  0xC6, 0x40, 0x6C, 0x80, 0x39, 0x00, 0x01, 0x3C, 0x02, 0x77, 0x02, 0x63,
+  0x04, 0x63, 0x04, 0x77, 0x08, 0x3C, 0x0E, 0x06, 0x60, 0xCC, 0x19, 0x81,
+  0xE0, 0x18, 0x0F, 0x03, 0x36, 0xC2, 0xD8, 0x73, 0x06, 0x31, 0xE3, 0xC4,
+  0xFE, 0x13, 0x26, 0x6C, 0xCC, 0xCC, 0xC4, 0x66, 0x23, 0x10, 0x8C, 0x46,
+  0x63, 0x33, 0x33, 0x32, 0x66, 0x4C, 0x80, 0x25, 0x7E, 0xA5, 0x00, 0x30,
+  0xC3, 0x3F, 0x30, 0xC3, 0x0C, 0xD6, 0xF0, 0xC0, 0x08, 0x44, 0x21, 0x10,
+  0x84, 0x42, 0x11, 0x08, 0x00, 0x3C, 0x66, 0x42, 0xC3, 0xC3, 0xC3, 0xC3,
+  0xC3, 0xC3, 0xC3, 0x42, 0x66, 0x3C, 0x11, 0x3F, 0x33, 0x33, 0x33, 0x33,
+  0x30, 0x3E, 0x31, 0xB0, 0x78, 0x30, 0x18, 0x1C, 0x1C, 0x1C, 0x18, 0x18,
+  0x10, 0x08, 0x07, 0xF8, 0x3C, 0x66, 0xC3, 0xC3, 0x03, 0x06, 0x1C, 0x07,
+  0x03, 0xC3, 0xC3, 0x66, 0x3C, 0x0C, 0x18, 0x71, 0x62, 0xC9, 0xA3, 0x46,
+  0xFE, 0x18, 0x30, 0x60, 0xC0, 0x7F, 0x20, 0x10, 0x08, 0x08, 0x07, 0xF3,
+  0x8C, 0x03, 0x01, 0x80, 0xF0, 0x6C, 0x63, 0xE0, 0x1E, 0x31, 0x98, 0x78,
+  0x0C, 0x06, 0xF3, 0x8D, 0x83, 0xC1, 0xE0, 0xD0, 0x6C, 0x63, 0xE0, 0xFF,
+  0x03, 0x02, 0x06, 0x04, 0x0C, 0x08, 0x18, 0x18, 0x18, 0x10, 0x30, 0x30,
+  0x3E, 0x31, 0xB0, 0x78, 0x3C, 0x1B, 0x18, 0xF8, 0xC6, 0xC1, 0xE0, 0xF0,
+  0x6C, 0x63, 0xE0, 0x3C, 0x66, 0xC2, 0xC3, 0xC3, 0xC3, 0x67, 0x3B, 0x03,
+  0x03, 0xC2, 0x66, 0x3C, 0xC0, 0x00, 0x30, 0xC0, 0x00, 0x00, 0x64, 0xA0,
+  0x00, 0x81, 0xC7, 0x8E, 0x0C, 0x07, 0x80, 0x70, 0x0E, 0x01, 0x80, 0xFF,
+  0x80, 0x00, 0x1F, 0xF0, 0x00, 0x70, 0x0E, 0x01, 0xC0, 0x18, 0x38, 0x71,
+  0xC0, 0x80, 0x00, 0x3E, 0x31, 0xB0, 0x78, 0x30, 0x18, 0x18, 0x38, 0x18,
+  0x18, 0x0C, 0x00, 0x00, 0x01, 0x80, 0x03, 0xF0, 0x06, 0x0E, 0x06, 0x01,
+  0x86, 0x00, 0x66, 0x1D, 0xBB, 0x31, 0xCF, 0x18, 0xC7, 0x98, 0x63, 0xCC,
+  0x31, 0xE6, 0x11, 0xB3, 0x99, 0xCC, 0xF7, 0x86, 0x00, 0x01, 0x80, 0x00,
+  0x70, 0x40, 0x0F, 0xE0, 0x06, 0x00, 0xF0, 0x0F, 0x00, 0x90, 0x19, 0x81,
+  0x98, 0x10, 0x83, 0x0C, 0x3F, 0xC2, 0x04, 0x60, 0x66, 0x06, 0xC0, 0x30,
+  0xFF, 0x18, 0x33, 0x03, 0x60, 0x6C, 0x0D, 0x83, 0x3F, 0xC6, 0x06, 0xC0,
+  0x78, 0x0F, 0x01, 0xE0, 0x6F, 0xF8, 0x1F, 0x86, 0x19, 0x81, 0xA0, 0x3C,
+  0x01, 0x80, 0x30, 0x06, 0x00, 0xC0, 0x68, 0x0D, 0x83, 0x18, 0x61, 0xF0,
+  0xFF, 0x18, 0x33, 0x03, 0x60, 0x3C, 0x07, 0x80, 0xF0, 0x1E, 0x03, 0xC0,
+  0x78, 0x0F, 0x03, 0x60, 0xCF, 0xF0, 0xFF, 0xE0, 0x30, 0x18, 0x0C, 0x06,
+  0x03, 0xFD, 0x80, 0xC0, 0x60, 0x30, 0x18, 0x0F, 0xF8, 0xFF, 0xC0, 0xC0,
+  0xC0, 0xC0, 0xC0, 0xFE, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0x0F, 0x83,
+  0x0E, 0x60, 0x66, 0x03, 0xC0, 0x0C, 0x00, 0xC1, 0xFC, 0x03, 0xC0, 0x36,
+  0x03, 0x60, 0x73, 0x0F, 0x0F, 0x10, 0xC0, 0x78, 0x0F, 0x01, 0xE0, 0x3C,
+  0x07, 0x80, 0xFF, 0xFE, 0x03, 0xC0, 0x78, 0x0F, 0x01, 0xE0, 0x3C, 0x06,
+  0xFF, 0xFF, 0xFF, 0xC0, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC1, 0x83, 0x07,
+  0x8F, 0x1E, 0x27, 0x80, 0xC0, 0xD8, 0x33, 0x0C, 0x63, 0x0C, 0xC1, 0xB8,
+  0x3F, 0x07, 0x30, 0xC3, 0x18, 0x63, 0x06, 0x60, 0x6C, 0x0C, 0xC0, 0xC0,
+  0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xFF, 0xE0,
+  0x3F, 0x01, 0xFC, 0x1F, 0xE0, 0xFD, 0x05, 0xEC, 0x6F, 0x63, 0x79, 0x13,
+  0xCD, 0x9E, 0x6C, 0xF1, 0x47, 0x8E, 0x3C, 0x71, 0x80, 0xE0, 0x7C, 0x0F,
+  0xC1, 0xE8, 0x3D, 0x87, 0x98, 0xF1, 0x1E, 0x33, 0xC3, 0x78, 0x6F, 0x07,
+  0xE0, 0x7C, 0x0E, 0x0F, 0x81, 0x83, 0x18, 0x0C, 0xC0, 0x6C, 0x01, 0xE0,
+  0x0F, 0x00, 0x78, 0x03, 0xC0, 0x1B, 0x01, 0x98, 0x0C, 0x60, 0xC0, 0xF8,
+  0x00, 0xFF, 0x30, 0x6C, 0x0F, 0x03, 0xC0, 0xF0, 0x6F, 0xF3, 0x00, 0xC0,
+  0x30, 0x0C, 0x03, 0x00, 0xC0, 0x00, 0x0F, 0x81, 0x83, 0x18, 0x0C, 0xC0,
+  0x6C, 0x01, 0xE0, 0x0F, 0x00, 0x78, 0x03, 0xC0, 0x1B, 0x01, 0x98, 0x6C,
+  0x60, 0xC0, 0xFB, 0x00, 0x08, 0xFF, 0x8C, 0x0E, 0xC0, 0x6C, 0x06, 0xC0,
+  0x6C, 0x0C, 0xFF, 0x8C, 0x0E, 0xC0, 0x6C, 0x06, 0xC0, 0x6C, 0x06, 0xC0,
+  0x70, 0x3F, 0x18, 0x6C, 0x0F, 0x03, 0xC0, 0x1E, 0x01, 0xF0, 0x0E, 0x00,
+  0xF0, 0x3C, 0x0D, 0x86, 0x3F, 0x00, 0xFF, 0x86, 0x03, 0x01, 0x80, 0xC0,
+  0x60, 0x30, 0x18, 0x0C, 0x06, 0x03, 0x01, 0x80, 0xC0, 0xC0, 0x78, 0x0F,
+  0x01, 0xE0, 0x3C, 0x07, 0x80, 0xF0, 0x1E, 0x03, 0xC0, 0x78, 0x0F, 0x01,
+  0xB0, 0x61, 0xF0, 0xC0, 0x6C, 0x0D, 0x81, 0x10, 0x63, 0x0C, 0x61, 0x04,
+  0x60, 0xCC, 0x19, 0x01, 0x60, 0x3C, 0x07, 0x00, 0x60, 0xC1, 0x81, 0x30,
+  0xE1, 0x98, 0x70, 0xCC, 0x28, 0x66, 0x26, 0x21, 0x13, 0x30, 0xC8, 0x98,
+  0x6C, 0x4C, 0x14, 0x34, 0x0A, 0x1A, 0x07, 0x07, 0x03, 0x03, 0x80, 0x81,
+  0x80, 0x60, 0x63, 0x0C, 0x30, 0xC1, 0x98, 0x0F, 0x00, 0xE0, 0x06, 0x00,
+  0xF0, 0x19, 0x01, 0x98, 0x30, 0xC6, 0x0E, 0x60, 0x60, 0xC0, 0x36, 0x06,
+  0x30, 0xC3, 0x0C, 0x19, 0x81, 0xD8, 0x0F, 0x00, 0x60, 0x06, 0x00, 0x60,
+  0x06, 0x00, 0x60, 0x06, 0x00, 0xFF, 0xC0, 0x60, 0x30, 0x0C, 0x06, 0x03,
+  0x01, 0xC0, 0x60, 0x30, 0x18, 0x06, 0x03, 0x00, 0xFF, 0xC0, 0xFB, 0x6D,
+  0xB6, 0xDB, 0x6D, 0xB6, 0xE0, 0x84, 0x10, 0x84, 0x10, 0x84, 0x10, 0x84,
+  0x10, 0x80, 0xED, 0xB6, 0xDB, 0x6D, 0xB6, 0xDB, 0xE0, 0x30, 0x60, 0xA2,
+  0x44, 0xD8, 0xA1, 0x80, 0xFF, 0xC0, 0xC6, 0x30, 0x7E, 0x71, 0xB0, 0xC0,
+  0x60, 0xF3, 0xDB, 0x0D, 0x86, 0xC7, 0x3D, 0xC0, 0xC0, 0x60, 0x30, 0x1B,
+  0xCE, 0x36, 0x0F, 0x07, 0x83, 0xC1, 0xE0, 0xF0, 0x7C, 0x6D, 0xE0, 0x3C,
+  0x66, 0xC3, 0xC0, 0xC0, 0xC0, 0xC0, 0xC3, 0x66, 0x3C, 0x03, 0x03, 0x03,
+  0x3B, 0x67, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0x67, 0x3B, 0x3C, 0x66,
+  0xC3, 0xC3, 0xFF, 0xC0, 0xC0, 0xC3, 0x66, 0x3C, 0x36, 0x6F, 0x66, 0x66,
+  0x66, 0x66, 0x60, 0x3B, 0x67, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0x67,
+  0x3B, 0x03, 0x03, 0xC6, 0x7C, 0xC0, 0xC0, 0xC0, 0xDE, 0xE3, 0xC3, 0xC3,
+  0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xFF, 0xFF, 0xC0, 0x30, 0x03,
+  0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0xE0, 0xC0, 0x60, 0x30, 0x18, 0x4C,
+  0x46, 0x63, 0x61, 0xF0, 0xEC, 0x62, 0x31, 0x98, 0x6C, 0x30, 0xFF, 0xFF,
+  0xFF, 0xC0, 0xDE, 0xF7, 0x1C, 0xF0, 0xC7, 0x86, 0x3C, 0x31, 0xE1, 0x8F,
+  0x0C, 0x78, 0x63, 0xC3, 0x1E, 0x18, 0xC0, 0xDE, 0xE3, 0xC3, 0xC3, 0xC3,
+  0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0x3C, 0x66, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3,
+  0xC3, 0x66, 0x3C, 0xDE, 0x71, 0xB0, 0x78, 0x3C, 0x1E, 0x0F, 0x07, 0x83,
+  0xE3, 0x6F, 0x30, 0x18, 0x0C, 0x00, 0x3B, 0x67, 0xC3, 0xC3, 0xC3, 0xC3,
+  0xC3, 0xC3, 0x67, 0x3B, 0x03, 0x03, 0x03, 0xDF, 0x31, 0x8C, 0x63, 0x18,
+  0xC6, 0x00, 0x3E, 0xE3, 0xC0, 0xC0, 0xE0, 0x3C, 0x07, 0xC3, 0xE3, 0x7E,
+  0x66, 0xF6, 0x66, 0x66, 0x66, 0x67, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3,
+  0xC3, 0xC3, 0xC7, 0x7B, 0xC1, 0xA0, 0x98, 0xCC, 0x42, 0x21, 0xB0, 0xD0,
+  0x28, 0x1C, 0x0C, 0x00, 0xC6, 0x1E, 0x38, 0x91, 0xC4, 0xCA, 0x66, 0xD3,
+  0x16, 0xD0, 0xA6, 0x87, 0x1C, 0x38, 0xC0, 0xC6, 0x00, 0x43, 0x62, 0x36,
+  0x1C, 0x18, 0x1C, 0x3C, 0x26, 0x62, 0x43, 0xC1, 0x21, 0x98, 0xCC, 0x42,
+  0x61, 0xB0, 0xD0, 0x38, 0x1C, 0x0C, 0x06, 0x03, 0x01, 0x03, 0x00, 0xFE,
+  0x0C, 0x30, 0xC1, 0x86, 0x18, 0x20, 0xC1, 0xFC, 0x36, 0x66, 0x66, 0x6E,
+  0xCE, 0x66, 0x66, 0x66, 0x30, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0xC6, 0x66,
+  0x66, 0x67, 0x37, 0x66, 0x66, 0x66, 0xC0, 0x61, 0x24, 0x38 };
+
+const GFXglyph FreeSans9pt7bGlyphs[] PROGMEM = {
+  {     0,   0,   0,   5,    0,    1 },   // 0x20 ' '
+  {     0,   2,  13,   6,    2,  -12 },   // 0x21 '!'
+  {     4,   5,   4,   6,    1,  -12 },   // 0x22 '"'
+  {     7,  10,  12,  10,    0,  -11 },   // 0x23 '#'
+  {    22,   9,  16,  10,    1,  -13 },   // 0x24 '$'
+  {    40,  16,  13,  16,    1,  -12 },   // 0x25 '%'
+  {    66,  11,  13,  12,    1,  -12 },   // 0x26 '&'
+  {    84,   2,   4,   4,    1,  -12 },   // 0x27 '''
+  {    85,   4,  17,   6,    1,  -12 },   // 0x28 '('
+  {    94,   4,  17,   6,    1,  -12 },   // 0x29 ')'
+  {   103,   5,   5,   7,    1,  -12 },   // 0x2A '*'
+  {   107,   6,   8,  11,    3,   -7 },   // 0x2B '+'
+  {   113,   2,   4,   5,    2,    0 },   // 0x2C ','
+  {   114,   4,   1,   6,    1,   -4 },   // 0x2D '-'
+  {   115,   2,   1,   5,    1,    0 },   // 0x2E '.'
+  {   116,   5,  13,   5,    0,  -12 },   // 0x2F '/'
+  {   125,   8,  13,  10,    1,  -12 },   // 0x30 '0'
+  {   138,   4,  13,  10,    3,  -12 },   // 0x31 '1'
+  {   145,   9,  13,  10,    1,  -12 },   // 0x32 '2'
+  {   160,   8,  13,  10,    1,  -12 },   // 0x33 '3'
+  {   173,   7,  13,  10,    2,  -12 },   // 0x34 '4'
+  {   185,   9,  13,  10,    1,  -12 },   // 0x35 '5'
+  {   200,   9,  13,  10,    1,  -12 },   // 0x36 '6'
+  {   215,   8,  13,  10,    0,  -12 },   // 0x37 '7'
+  {   228,   9,  13,  10,    1,  -12 },   // 0x38 '8'
+  {   243,   8,  13,  10,    1,  -12 },   // 0x39 '9'
+  {   256,   2,  10,   5,    1,   -9 },   // 0x3A ':'
+  {   259,   3,  12,   5,    1,   -8 },   // 0x3B ';'
+  {   264,   9,   9,  11,    1,   -8 },   // 0x3C '<'
+  {   275,   9,   4,  11,    1,   -5 },   // 0x3D '='
+  {   280,   9,   9,  11,    1,   -8 },   // 0x3E '>'
+  {   291,   9,  13,  10,    1,  -12 },   // 0x3F '?'
+  {   306,  17,  16,  18,    1,  -12 },   // 0x40 '@'
+  {   340,  12,  13,  12,    0,  -12 },   // 0x41 'A'
+  {   360,  11,  13,  12,    1,  -12 },   // 0x42 'B'
+  {   378,  11,  13,  13,    1,  -12 },   // 0x43 'C'
+  {   396,  11,  13,  13,    1,  -12 },   // 0x44 'D'
+  {   414,   9,  13,  11,    1,  -12 },   // 0x45 'E'
+  {   429,   8,  13,  11,    1,  -12 },   // 0x46 'F'
+  {   442,  12,  13,  14,    1,  -12 },   // 0x47 'G'
+  {   462,  11,  13,  13,    1,  -12 },   // 0x48 'H'
+  {   480,   2,  13,   5,    2,  -12 },   // 0x49 'I'
+  {   484,   7,  13,  10,    1,  -12 },   // 0x4A 'J'
+  {   496,  11,  13,  12,    1,  -12 },   // 0x4B 'K'
+  {   514,   8,  13,  10,    1,  -12 },   // 0x4C 'L'
+  {   527,  13,  13,  15,    1,  -12 },   // 0x4D 'M'
+  {   549,  11,  13,  13,    1,  -12 },   // 0x4E 'N'
+  {   567,  13,  13,  14,    1,  -12 },   // 0x4F 'O'
+  {   589,  10,  13,  12,    1,  -12 },   // 0x50 'P'
+  {   606,  13,  14,  14,    1,  -12 },   // 0x51 'Q'
+  {   629,  12,  13,  13,    1,  -12 },   // 0x52 'R'
+  {   649,  10,  13,  12,    1,  -12 },   // 0x53 'S'
+  {   666,   9,  13,  11,    1,  -12 },   // 0x54 'T'
+  {   681,  11,  13,  13,    1,  -12 },   // 0x55 'U'
+  {   699,  11,  13,  12,    0,  -12 },   // 0x56 'V'
+  {   717,  17,  13,  17,    0,  -12 },   // 0x57 'W'
+  {   745,  12,  13,  12,    0,  -12 },   // 0x58 'X'
+  {   765,  12,  13,  12,    0,  -12 },   // 0x59 'Y'
+  {   785,  10,  13,  11,    1,  -12 },   // 0x5A 'Z'
+  {   802,   3,  17,   5,    1,  -12 },   // 0x5B '['
+  {   809,   5,  13,   5,    0,  -12 },   // 0x5C '\'
+  {   818,   3,  17,   5,    0,  -12 },   // 0x5D ']'
+  {   825,   7,   7,   8,    1,  -12 },   // 0x5E '^'
+  {   832,  10,   1,  10,    0,    3 },   // 0x5F '_'
+  {   834,   4,   3,   5,    0,  -12 },   // 0x60 '`'
+  {   836,   9,  10,  10,    1,   -9 },   // 0x61 'a'
+  {   848,   9,  13,  10,    1,  -12 },   // 0x62 'b'
+  {   863,   8,  10,   9,    1,   -9 },   // 0x63 'c'
+  {   873,   8,  13,  10,    1,  -12 },   // 0x64 'd'
+  {   886,   8,  10,  10,    1,   -9 },   // 0x65 'e'
+  {   896,   4,  13,   5,    1,  -12 },   // 0x66 'f'
+  {   903,   8,  14,  10,    1,   -9 },   // 0x67 'g'
+  {   917,   8,  13,  10,    1,  -12 },   // 0x68 'h'
+  {   930,   2,  13,   4,    1,  -12 },   // 0x69 'i'
+  {   934,   4,  17,   4,    0,  -12 },   // 0x6A 'j'
+  {   943,   9,  13,   9,    1,  -12 },   // 0x6B 'k'
+  {   958,   2,  13,   4,    1,  -12 },   // 0x6C 'l'
+  {   962,  13,  10,  15,    1,   -9 },   // 0x6D 'm'
+  {   979,   8,  10,  10,    1,   -9 },   // 0x6E 'n'
+  {   989,   8,  10,  10,    1,   -9 },   // 0x6F 'o'
+  {   999,   9,  13,  10,    1,   -9 },   // 0x70 'p'
+  {  1014,   8,  13,  10,    1,   -9 },   // 0x71 'q'
+  {  1027,   5,  10,   6,    1,   -9 },   // 0x72 'r'
+  {  1034,   8,  10,   9,    1,   -9 },   // 0x73 's'
+  {  1044,   4,  12,   5,    1,  -11 },   // 0x74 't'
+  {  1050,   8,  10,  10,    1,   -9 },   // 0x75 'u'
+  {  1060,   9,  10,   9,    0,   -9 },   // 0x76 'v'
+  {  1072,  13,  10,  13,    0,   -9 },   // 0x77 'w'
+  {  1089,   8,  10,   9,    0,   -9 },   // 0x78 'x'
+  {  1099,   9,  14,   9,    0,   -9 },   // 0x79 'y'
+  {  1115,   7,  10,   9,    1,   -9 },   // 0x7A 'z'
+  {  1124,   4,  17,   6,    1,  -12 },   // 0x7B '{'
+  {  1133,   2,  17,   4,    2,  -12 },   // 0x7C '|'
+  {  1138,   4,  17,   6,    1,  -12 },   // 0x7D '}'
+  {  1147,   7,   3,   9,    1,   -7 } }; // 0x7E '~'
+
+const GFXfont FreeSans9pt7b PROGMEM = {
+  (uint8_t  *)FreeSans9pt7bBitmaps,
+  (GFXglyph *)FreeSans9pt7bGlyphs,
+  0x20, 0x7E, 22 };
+
+// Approx. 1822 bytes
diff --git a/libraries/fonts/Picopixel.h b/libraries/fonts/Picopixel.h
new file mode 100755
index 0000000..0ed6543
--- /dev/null
+++ b/libraries/fonts/Picopixel.h
@@ -0,0 +1,123 @@
+// Picopixel by Sebastian Weber.  A tiny font
+// with all characters within a 6 pixel height.
+
+const uint8_t PicopixelBitmaps[] PROGMEM = {
+  0xE8, 0xB4, 0x57, 0xD5, 0xF5, 0x00, 0x4E, 0x3E, 0x80, 0xA5, 0x4A, 0x4A,
+  0x5A, 0x50, 0xC0, 0x6A, 0x40, 0x95, 0x80, 0xAA, 0x80, 0x5D, 0x00, 0x60,
+  0xE0, 0x80, 0x25, 0x48, 0x56, 0xD4, 0x75, 0x40, 0xC5, 0x4E, 0xC5, 0x1C,
+  0x97, 0x92, 0xF3, 0x1C, 0x53, 0x54, 0xE5, 0x48, 0x55, 0x54, 0x55, 0x94,
+  0xA0, 0x46, 0x64, 0xE3, 0x80, 0x98, 0xC5, 0x04, 0x56, 0xC6, 0x57, 0xDA,
+  0xD7, 0x5C, 0x72, 0x46, 0xD6, 0xDC, 0xF3, 0xCE, 0xF3, 0x48, 0x72, 0xD4,
+  0xB7, 0xDA, 0xF8, 0x24, 0xD4, 0xBB, 0x5A, 0x92, 0x4E, 0x8E, 0xEB, 0x58,
+  0x80, 0x9D, 0xB9, 0x90, 0x56, 0xD4, 0xD7, 0x48, 0x56, 0xD4, 0x40, 0xD7,
+  0x5A, 0x71, 0x1C, 0xE9, 0x24, 0xB6, 0xD4, 0xB6, 0xA4, 0x8C, 0x6B, 0x55,
+  0x00, 0xB5, 0x5A, 0xB5, 0x24, 0xE5, 0x4E, 0xEA, 0xC0, 0x91, 0x12, 0xD5,
+  0xC0, 0x54, 0xF0, 0x90, 0xC7, 0xF0, 0x93, 0x5E, 0x71, 0x80, 0x25, 0xDE,
+  0x5E, 0x30, 0x6E, 0x80, 0x77, 0x9C, 0x93, 0x5A, 0xB8, 0x45, 0x60, 0x92,
+  0xEA, 0xAA, 0x40, 0xD5, 0x6A, 0xD6, 0x80, 0x55, 0x00, 0xD7, 0x40, 0x75,
+  0x90, 0xE8, 0x71, 0xE0, 0xBA, 0x40, 0xB5, 0x80, 0xB5, 0x00, 0x8D, 0x54,
+  0xAA, 0x80, 0xAC, 0xE0, 0xE5, 0x70, 0x6A, 0x26, 0xFC, 0xC8, 0xAC, 0x5A };
+
+const GFXglyph PicopixelGlyphs[] PROGMEM = {
+  {     0,   0,   0,   2,    0,    1 },   // 0x20 ' '
+  {     0,   1,   5,   2,    0,   -4 },   // 0x21 '!'
+  {     1,   3,   2,   4,    0,   -4 },   // 0x22 '"'
+  {     2,   5,   5,   6,    0,   -4 },   // 0x23 '#'
+  {     6,   3,   6,   4,    0,   -4 },   // 0x24 '$'
+  {     9,   3,   5,   4,    0,   -4 },   // 0x25 '%'
+  {    11,   4,   5,   5,    0,   -4 },   // 0x26 '&'
+  {    14,   1,   2,   2,    0,   -4 },   // 0x27 '''
+  {    15,   2,   5,   3,    0,   -4 },   // 0x28 '('
+  {    17,   2,   5,   3,    0,   -4 },   // 0x29 ')'
+  {    19,   3,   3,   4,    0,   -3 },   // 0x2A '*'
+  {    21,   3,   3,   4,    0,   -3 },   // 0x2B '+'
+  {    23,   2,   2,   3,    0,    0 },   // 0x2C ','
+  {    24,   3,   1,   4,    0,   -2 },   // 0x2D '-'
+  {    25,   1,   1,   2,    0,    0 },   // 0x2E '.'
+  {    26,   3,   5,   4,    0,   -4 },   // 0x2F '/'
+  {    28,   3,   5,   4,    0,   -4 },   // 0x30 '0'
+  {    30,   2,   5,   3,    0,   -4 },   // 0x31 '1'
+  {    32,   3,   5,   4,    0,   -4 },   // 0x32 '2'
+  {    34,   3,   5,   4,    0,   -4 },   // 0x33 '3'
+  {    36,   3,   5,   4,    0,   -4 },   // 0x34 '4'
+  {    38,   3,   5,   4,    0,   -4 },   // 0x35 '5'
+  {    40,   3,   5,   4,    0,   -4 },   // 0x36 '6'
+  {    42,   3,   5,   4,    0,   -4 },   // 0x37 '7'
+  {    44,   3,   5,   4,    0,   -4 },   // 0x38 '8'
+  {    46,   3,   5,   4,    0,   -4 },   // 0x39 '9'
+  {    48,   1,   3,   2,    0,   -3 },   // 0x3A ':'
+  {    49,   2,   4,   3,    0,   -3 },   // 0x3B ';'
+  {    50,   2,   3,   3,    0,   -3 },   // 0x3C '<'
+  {    51,   3,   3,   4,    0,   -3 },   // 0x3D '='
+  {    53,   2,   3,   3,    0,   -3 },   // 0x3E '>'
+  {    54,   3,   5,   4,    0,   -4 },   // 0x3F '?'
+  {    56,   3,   5,   4,    0,   -4 },   // 0x40 '@'
+  {    58,   3,   5,   4,    0,   -4 },   // 0x41 'A'
+  {    60,   3,   5,   4,    0,   -4 },   // 0x42 'B'
+  {    62,   3,   5,   4,    0,   -4 },   // 0x43 'C'
+  {    64,   3,   5,   4,    0,   -4 },   // 0x44 'D'
+  {    66,   3,   5,   4,    0,   -4 },   // 0x45 'E'
+  {    68,   3,   5,   4,    0,   -4 },   // 0x46 'F'
+  {    70,   3,   5,   4,    0,   -4 },   // 0x47 'G'
+  {    72,   3,   5,   4,    0,   -4 },   // 0x48 'H'
+  {    74,   1,   5,   2,    0,   -4 },   // 0x49 'I'
+  {    75,   3,   5,   4,    0,   -4 },   // 0x4A 'J'
+  {    77,   3,   5,   4,    0,   -4 },   // 0x4B 'K'
+  {    79,   3,   5,   4,    0,   -4 },   // 0x4C 'L'
+  {    81,   5,   5,   6,    0,   -4 },   // 0x4D 'M'
+  {    85,   4,   5,   5,    0,   -4 },   // 0x4E 'N'
+  {    88,   3,   5,   4,    0,   -4 },   // 0x4F 'O'
+  {    90,   3,   5,   4,    0,   -4 },   // 0x50 'P'
+  {    92,   3,   6,   4,    0,   -4 },   // 0x51 'Q'
+  {    95,   3,   5,   4,    0,   -4 },   // 0x52 'R'
+  {    97,   3,   5,   4,    0,   -4 },   // 0x53 'S'
+  {    99,   3,   5,   4,    0,   -4 },   // 0x54 'T'
+  {   101,   3,   5,   4,    0,   -4 },   // 0x55 'U'
+  {   103,   3,   5,   4,    0,   -4 },   // 0x56 'V'
+  {   105,   5,   5,   6,    0,   -4 },   // 0x57 'W'
+  {   109,   3,   5,   4,    0,   -4 },   // 0x58 'X'
+  {   111,   3,   5,   4,    0,   -4 },   // 0x59 'Y'
+  {   113,   3,   5,   4,    0,   -4 },   // 0x5A 'Z'
+  {   115,   2,   5,   3,    0,   -4 },   // 0x5B '['
+  {   117,   3,   5,   4,    0,   -4 },   // 0x5C '\'
+  {   119,   2,   5,   3,    0,   -4 },   // 0x5D ']'
+  {   121,   3,   2,   4,    0,   -4 },   // 0x5E '^'
+  {   122,   4,   1,   4,    0,    1 },   // 0x5F '_'
+  {   123,   2,   2,   3,    0,   -4 },   // 0x60 '`'
+  {   124,   3,   4,   4,    0,   -3 },   // 0x61 'a'
+  {   126,   3,   5,   4,    0,   -4 },   // 0x62 'b'
+  {   128,   3,   3,   4,    0,   -2 },   // 0x63 'c'
+  {   130,   3,   5,   4,    0,   -4 },   // 0x64 'd'
+  {   132,   3,   4,   4,    0,   -3 },   // 0x65 'e'
+  {   134,   2,   5,   3,    0,   -4 },   // 0x66 'f'
+  {   136,   3,   5,   4,    0,   -3 },   // 0x67 'g'
+  {   138,   3,   5,   4,    0,   -4 },   // 0x68 'h'
+  {   140,   1,   5,   2,    0,   -4 },   // 0x69 'i'
+  {   141,   2,   6,   3,    0,   -4 },   // 0x6A 'j'
+  {   143,   3,   5,   4,    0,   -4 },   // 0x6B 'k'
+  {   145,   2,   5,   3,    0,   -4 },   // 0x6C 'l'
+  {   147,   5,   3,   6,    0,   -2 },   // 0x6D 'm'
+  {   149,   3,   3,   4,    0,   -2 },   // 0x6E 'n'
+  {   151,   3,   3,   4,    0,   -2 },   // 0x6F 'o'
+  {   153,   3,   4,   4,    0,   -2 },   // 0x70 'p'
+  {   155,   3,   4,   4,    0,   -2 },   // 0x71 'q'
+  {   157,   2,   3,   3,    0,   -2 },   // 0x72 'r'
+  {   158,   3,   4,   4,    0,   -3 },   // 0x73 's'
+  {   160,   2,   5,   3,    0,   -4 },   // 0x74 't'
+  {   162,   3,   3,   4,    0,   -2 },   // 0x75 'u'
+  {   164,   3,   3,   4,    0,   -2 },   // 0x76 'v'
+  {   166,   5,   3,   6,    0,   -2 },   // 0x77 'w'
+  {   168,   3,   3,   4,    0,   -2 },   // 0x78 'x'
+  {   170,   3,   4,   4,    0,   -2 },   // 0x79 'y'
+  {   172,   3,   4,   4,    0,   -3 },   // 0x7A 'z'
+  {   174,   3,   5,   4,    0,   -4 },   // 0x7B '{'
+  {   176,   1,   6,   2,    0,   -4 },   // 0x7C '|'
+  {   177,   3,   5,   4,    0,   -4 },   // 0x7D '}'
+  {   179,   4,   2,   5,    0,   -3 } }; // 0x7E '~'
+
+const GFXfont Picopixel PROGMEM = {
+  (uint8_t  *)PicopixelBitmaps,
+  (GFXglyph *)PicopixelGlyphs,
+  0x20, 0x7E, 7 };
+
+// Approx. 852 bytes
diff --git a/tools/ESP32FS/tool/esp32fs.jar b/tools/ESP32FS/tool/esp32fs.jar
new file mode 100755
index 0000000..7eca30e
Binary files /dev/null and b/tools/ESP32FS/tool/esp32fs.jar differ