Fix typos in OBP40 config

Fix vertical time axis label in graphical charts

boards/obp70_s3_n16r8.json

@@ -0,0 +1,56 @@
+{
+  "build": {
+    "arduino":{
+      "ldscript": "esp32s3_out.ld",
+      "partitions": "default_16MB.csv",
+      "memory_type": "qio_opi"
+    },
+    "core": "esp32",
+    "extra_flags": [
+      "-DBOARD_HAS_PSRAM",
+      "-DARDUINO_ESP32S3_DEV",
+      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_CDC_ON_BOOT=1",
+      "-DARDUINO_RUNNING_CORE=1",
+      "-DARDUINO_EVENT_RUNNING_CORE=1"
+    ],
+    "f_cpu": "240000000L",
+    "f_flash": "80000000L",
+    "flash_mode": "qio",
+    "hwids": [
+      [
+        "0x303A",
+        "0x1001"
+      ]
+    ],
+    "mcu": "esp32s3",
+    "variant": "obp70s3"
+  },
+  "connectivity": [
+    "bluetooth",
+    "wifi"
+  ],
+  "debug": {
+    "default_tool": "esp-builtin",
+    "onboard_tools": [
+      "esp-builtin"
+    ],
+    "openocd_target": "esp32s3.cfg"
+  },
+  "frameworks": [
+    "arduino",
+    "espidf"
+  ],
+  "name": "OBP70 ESP32-S3-N16R8 16 MB QD, 8 MB PSRAM)",
+  "upload": {
+    "flash_size": "16MB",
+    "maximum_ram_size": 327680,
+    "maximum_size": 16777216,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": true,
+    "require_upload_port": true,
+    "speed": 460800
+  },
+  "url": "https://open-boat-projects.org/en/diy-multifunktionsdisplay-obp-60/",
+  "vendor": "Open Boat Projects"
+}

lib/gwwifi/GWWifi.h

@@ -2,6 +2,9 @@
 #define _GWWIFI_H
 #include <WiFi.h>
 #include <GWConfig.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+
 class GwWifi{
     private:
         const GwConfigHandler *config;
@@ -16,13 +19,19 @@ class GwWifi{
         bool apActive=false;
         bool fixedApPass=true;
         bool clientIsConnected=false;
+        SemaphoreHandle_t wifiMutex=nullptr;
+        static const TickType_t WIFI_MUTEX_TIMEOUT=pdMS_TO_TICKS(1000);
+        bool acquireMutex();
+        void releaseMutex();
     public:
         const char *AP_password = "esp32nmea2k"; 
         GwWifi(const GwConfigHandler *config,GwLog *log, bool fixedApPass=true);
+        ~GwWifi();
         void setup();
         void loop();
         bool clientConnected();
-        bool connectClient();
+        bool connectClient();          // Blocking version
+        bool connectClientAsync();     // Non-blocking version for other tasks
         String apIP();
         bool isApActive(){return apActive;}
         bool isClientActive(){return wifiClient->asBoolean();}

lib/gwwifi/GwWifi.cpp

@@ -1,7 +1,6 @@
 #include <esp_wifi.h>
 #include "GWWifi.h"
 
-
 GwWifi::GwWifi(const GwConfigHandler *config,GwLog *log, bool fixedApPass){
     this->config=config;
     this->logger=log;
@@ -9,6 +8,28 @@ GwWifi::GwWifi(const GwConfigHandler *config,GwLog *log, bool fixedApPass){
     wifiSSID=config->getConfigItem(config->wifiSSID,true);
     wifiPass=config->getConfigItem(config->wifiPass,true);
     this->fixedApPass=fixedApPass;
+    wifiMutex=xSemaphoreCreateMutex();
+    if (wifiMutex==nullptr){
+        LOG_DEBUG(GwLog::ERROR,"GwWifi: unable to create mutex");
+    }
+}
+
+GwWifi::~GwWifi(){
+    if (wifiMutex!=nullptr){
+        vSemaphoreDelete(wifiMutex);
+        wifiMutex=nullptr;
+    }
+}
+
+bool GwWifi::acquireMutex(){
+    if (wifiMutex==nullptr) return false;
+    return xSemaphoreTake(wifiMutex,WIFI_MUTEX_TIMEOUT)==pdTRUE;
+}
+
+void GwWifi::releaseMutex(){
+    if (wifiMutex!=nullptr){
+        xSemaphoreGive(wifiMutex);
+    }
 }
 void GwWifi::setup(){
     LOG_DEBUG(GwLog::LOG,"Wifi setup");
@@ -85,8 +106,14 @@ bool GwWifi::connectInternal(){
     if (wifiClient->asBoolean()){
         clientIsConnected=false;
         LOG_DEBUG(GwLog::LOG,"creating wifiClient ssid=%s",wifiSSID->asString().c_str());
+        // CRITICAL SECTION: WiFi-Operationen müssen serialisiert werden
+        if (!acquireMutex()){
+            LOG_DEBUG(GwLog::ERROR,"GwWifi: mutex timeout in connectInternal");
+            return false;
+        }
         WiFi.setAutoReconnect(false); //#102
         wl_status_t rt=WiFi.begin(wifiSSID->asCString(),wifiPass->asCString());
+        releaseMutex();
         LOG_DEBUG(GwLog::LOG,"wifiClient connect returns %d",(int)rt);
         lastConnectStart=millis();
         return true;
@@ -104,8 +131,42 @@ void GwWifi::loop(){
             if (lastConnectStart > now || (lastConnectStart + RETRY_MILLIS) < now)
             {
                 LOG_DEBUG(GwLog::LOG,"wifiClient: retry connect to %s", wifiSSID->asCString());
-                WiFi.disconnect();
+
-                connectInternal();
+                // Keep locked sections short to avoid cross-core stalls/WDT.
+                if (acquireMutex()){
+                    WiFi.disconnect(true);
+                    releaseMutex();
+                }
+                else{
+                    LOG_DEBUG(GwLog::ERROR,"GwWifi: mutex timeout in loop (disconnect)");
+                }
+
+                delay(300);
+
+                if (acquireMutex()){
+                    esp_err_t stopErr=esp_wifi_stop();
+                    releaseMutex();
+                    if (stopErr != ESP_OK){
+                        LOG_DEBUG(GwLog::ERROR,"GwWifi: esp_wifi_stop failed: %d",(int)stopErr);
+                    }
+                }
+                else{
+                    LOG_DEBUG(GwLog::ERROR,"GwWifi: mutex timeout in loop (stop)");
+                }
+
+                delay(100);
+
+                if (acquireMutex()){
+                    esp_err_t startErr=esp_wifi_start();
+                    releaseMutex();
+                    if (startErr != ESP_OK){
+                        LOG_DEBUG(GwLog::ERROR,"GwWifi: esp_wifi_start failed: %d",(int)startErr);
+                    }
+                    connectInternal();
+                }
+                else{
+                    LOG_DEBUG(GwLog::ERROR,"GwWifi: mutex timeout in loop (start)");
+                }
             }
         }
         else{
@@ -126,11 +187,42 @@ void GwWifi::loop(){
         }
     }
 }
+
 bool GwWifi::clientConnected(){
-    return WiFi.status() == WL_CONNECTED;
+    // CRITICAL SECTION: WiFi.status() muss geschützt werden
+    if (!acquireMutex()){
+        LOG_DEBUG(GwLog::ERROR,"GwWifi: mutex timeout in clientConnected");
+        return false;  // Conservative: nehme an, nicht verbunden
+    }
+    bool result = WiFi.status() == WL_CONNECTED;
+    releaseMutex();
+    return result;
 };
+
 bool GwWifi::connectClient(){
+    // CRITICAL SECTION: Disconnect und Connect müssen atomar sein
+    if (!acquireMutex()){
+        LOG_DEBUG(GwLog::ERROR,"GwWifi: mutex timeout in connectClient");
+        return false;
+    }
     WiFi.disconnect();
+    releaseMutex();
+    return connectInternal();
+}
+
+bool GwWifi::connectClientAsync(){
+    // Non-blocking version: Versuche Mutex zu nehmen, gib aber sofort auf
+    // Ideal für Tasks, die nicht blockieren dürfen
+    if (wifiMutex==nullptr){
+        LOG_DEBUG(GwLog::ERROR,"GwWifi: mutex not initialized in connectClientAsync");
+        return false;
+    }
+    if (xSemaphoreTake(wifiMutex, 0)!=pdTRUE){
+        LOG_DEBUG(GwLog::LOG,"GwWifi: connectClientAsync skipped - WiFi busy");
+        return false;  // WiFi ist aktuell busy, versuche es später nochmal
+    }
+    WiFi.disconnect();
+    xSemaphoreGive(wifiMutex);
     return connectInternal();
 }
 

lib/obp60task/Changes_to_original.txt

@@ -0,0 +1,14 @@
+Changes to original project (wellenvogel)
+
+* esp32-nmea2000-obp60/gwwifi/GwWifi.cpp
+    - any fixes for reconnect handling
+* GWStatisticsw.h
+    - changed time source for log messages   
+* esp32-nmea2000-obp60/platformio.ini
+    - change to newer versions for AsyncTCP and AsyncWebServer (better handling for bad WiFi connections)
+
+    From AsyncTCP-esphome @ 2.0.1
+         ottowinter/ESPAsyncWebServer-esphome@2.0.1
+
+    To AsyncTCP-esphome @ 2.1.1
+         ottowinter/ESPAsyncWebServer-esphome@3.4.0

lib/obp60task/Code_Size.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+dir="$1"
+
+total=0
+
+while IFS= read -r -d '' file; do
+    lines=$(wc -l < "$file")
+    echo "$file : $lines"
+    total=$((total + lines))
+done < <(find "$dir" \( -name "*.c" -o -name "*.cpp" -o -name "*.h" \) -type f -print0)
+
+echo "-----------------------"
+echo "Over all files: $total"

lib/obp60task/ConfigMenu.cpp

@@ -1,217 +0,0 @@
-/*
-  Menu system for online configuration
-
-  A menu consists of a list of menuitems.
-
-  Graphical representation is stored:
-     upper left corner: x, y
-     bounding box:
-  A menu consists of three columns
-    - menu text, if selected highlighted
-    - menu value with optional unit
-    - menu description or additional data for value
-
-*/
-#include "ConfigMenu.h"
-
-ConfigMenuItem::ConfigMenuItem(String itemtype, String itemlabel, uint16_t itemval, String itemunit) {
-    if (! (itemtype == "int" or itemtype == "bool")) {
-        valtype = "int";
-    } else {
-        valtype = itemtype;
-    }
-    label = itemlabel;
-    min = 0;
-    max = std::numeric_limits<uint16_t>::max();
-    value = itemval;
-    unit = itemunit;
-    step = 1;
-}
-
-void ConfigMenuItem::setRange(uint16_t valmin, uint16_t valmax, std::vector<uint16_t> valsteps) {
-    min = valmin;
-    max = valmax;
-    steps = valsteps;
-    step = steps[0];
-};
-
-bool ConfigMenuItem::checkRange(uint16_t checkval) {
-    return (checkval >= min) and (checkval <= max);
-}
-
-String ConfigMenuItem::getLabel() {
-    return label;
-};
-
-uint16_t ConfigMenuItem::getValue() {
-    return value;
-}
-
-bool ConfigMenuItem::setValue(uint16_t newval) {
-    if (valtype == "int") {
-        if (newval >= min and newval <= max) {
-            value = newval;
-            return true;
-        }
-        return false; // out of range
-    } else if (valtype == "bool") {
-        value = (newval != 0) ? 1 : 0;
-        return true;
-    }
-    return false; // invalid type
-};
-
-void ConfigMenuItem::incValue() {
-    // increase value by step
-    if (valtype == "int") {
-        if (value + step < max) {
-            value += step;
-        } else {
-            value = max;
-        }
-    } else if (valtype == "bool") {
-        value = !value;
-    }
-};
-
-void ConfigMenuItem::decValue() {
-    // decrease value by step
-    if (valtype == "int") {
-        if (value - step > min) {
-            value -= step;
-        } else {
-            value = min;
-        }
-    } else if (valtype == "bool") {
-        value = !value;
-    }
-};
-
-String ConfigMenuItem::getUnit() {
-    return unit;
-}
-
-uint16_t ConfigMenuItem::getStep() {
-    return step;
-}
-
-void ConfigMenuItem::setStep(uint16_t newstep) {
-    if (std::find(steps.begin(), steps.end(), newstep) == steps.end()) {
-        return; // invalid step: not in list of possible steps
-    }
-    step = newstep;
-}
-
-int8_t ConfigMenuItem::getPos() {
-    return position;
-};
-
-void ConfigMenuItem::setPos(int8_t newpos) {
-    position = newpos;
-};
-
-String ConfigMenuItem::getType() {
-    return valtype;
-}
-
-ConfigMenu::ConfigMenu(String menutitle, uint16_t menu_x, uint16_t menu_y) {
-    title = menutitle;
-    x = menu_x;
-    y = menu_y;
-};
-
-ConfigMenuItem* ConfigMenu::addItem(String key, String label, String valtype, uint16_t val, String valunit) {
-    if (items.find(key) != items.end()) {
-        // duplicate keys not allowed
-        return nullptr;
-    }
-    ConfigMenuItem *itm = new ConfigMenuItem(valtype, label, val, valunit);
-    items.insert(std::pair<String, ConfigMenuItem*>(key, itm));
-    // Append key to index, index starting with 0
-    int8_t ix = items.size() - 1;
-    index[ix] = key;
-    itm->setPos(ix);
-    return itm;
-};
-
-void ConfigMenu::setItemDimension(uint16_t itemwidth, uint16_t itemheight) {
-    w = itemwidth;
-    h = itemheight;
-};
-
-void ConfigMenu::setItemActive(String key) {
-    if (items.find(key) != items.end()) {
-        activeitem = items[key]->getPos();
-    } else {
-        activeitem = -1;
-    }
-};
-
-int8_t ConfigMenu::getActiveIndex() {
-    return activeitem;
-}
-
-ConfigMenuItem* ConfigMenu::getActiveItem() {
-    if (activeitem < 0) {
-        return nullptr;
-    }
-    return items[index[activeitem]];
-};
-
-ConfigMenuItem* ConfigMenu::getItemByIndex(uint8_t ix) {
-    if (ix > index.size() - 1) {
-        return nullptr;
-    }
-    return items[index[ix]];
-};
-
-ConfigMenuItem* ConfigMenu::getItemByKey(String key) {
-    if (items.find(key) == items.end()) {
-        return nullptr;
-    }
-    return items[key];
-};
-
-uint8_t ConfigMenu::getItemCount() {
-    return items.size();
-};
-
-void ConfigMenu::goPrev() {
-    if (activeitem == 0) {
-        activeitem = items.size() - 1;
-    } else {
-        activeitem--;
-    }
-}
-
-void ConfigMenu::goNext() {
-    if (activeitem == items.size() - 1) {
-        activeitem = 0;
-    } else {
-        activeitem++;
-    }
-}
-
-Point ConfigMenu::getXY() {
-    return {static_cast<double>(x), static_cast<double>(y)};
-}
-
-Rect ConfigMenu::getRect() {
-    return {static_cast<double>(x), static_cast<double>(y),
-            static_cast<double>(w), static_cast<double>(h)};
-}
-
-Rect ConfigMenu::getItemRect(int8_t index) {
-    return {static_cast<double>(x), static_cast<double>(y + index * h),
-            static_cast<double>(w), static_cast<double>(h)};
-}
-
-void ConfigMenu::setCallback(void (*callback)()) {
-    fptrCallback = callback;
-}
-
-void ConfigMenu::storeValues() {
-    if (fptrCallback) {
-        fptrCallback();
-    }
-}

lib/obp60task/ConfigMenu.h

@@ -1,67 +0,0 @@
-#pragma once
-
-#include <Arduino.h>
-#include <vector>
-#include <map>
-#include "Graphics.h"  // for Point and Rect
-
-class ConfigMenuItem {
-private:
-    String label;
-    uint16_t value;
-    String unit;
-    String desc; // optional data to display
-    String valtype; // "int" | "bool" -> TODO "list"
-    uint16_t min;
-    uint16_t max;
-    std::vector<uint16_t> steps;
-    uint16_t step;
-    int8_t position; // counted fom 0
-
-public:
-    ConfigMenuItem(String itemtype, String itemlabel, uint16_t itemval, String itemunit);
-    void setRange(uint16_t valmin, uint16_t valmax, std::vector<uint16_t> steps);
-    bool checkRange(uint16_t checkval);
-    String getLabel();
-    uint16_t getValue();
-    bool setValue(uint16_t newval);
-    void incValue();
-    void decValue();
-    String getUnit();
-    uint16_t getStep();
-    void setStep(uint16_t newstep);
-    int8_t getPos();
-    void setPos(int8_t newpos);
-    String getType();
-};
-
-class ConfigMenu {
-private:
-    String title;
-    std::map <String,ConfigMenuItem*> items;
-    std::map <uint8_t,String> index;
-    int8_t activeitem = -1; // refers to position of item
-    uint16_t x;
-    uint16_t y;
-    uint16_t w;
-    uint16_t h;
-    void (*fptrCallback)();
-
-public:
-    ConfigMenu(String title, uint16_t menu_x, uint16_t menu_y);
-    ConfigMenuItem* addItem(String key, String label, String valtype, uint16_t val, String valunit);
-    void setItemDimension(uint16_t itemwidth, uint16_t itemheight);
-    int8_t getActiveIndex();
-    void setItemActive(String key);
-    ConfigMenuItem* getActiveItem();
-    ConfigMenuItem* getItemByIndex(uint8_t index);
-    ConfigMenuItem* getItemByKey(String key);
-    uint8_t getItemCount();
-    void goPrev();
-    void goNext();
-    Point getXY();
-    Rect getRect();
-    Rect getItemRect(int8_t index);
-    void setCallback(void (*callback)());
-    void storeValues();
-};

lib/obp60task/ImageDecoder.cpp

@@ -2,13 +2,22 @@
 #include <mbedtls/base64.h>
 
 // Decoder for Base64 content
-bool ImageDecoder::decodeBase64(const String& base64, uint8_t* outBuffer, size_t outSize, size_t& decodedSize) {
+bool ImageDecoder::decodeBase64(const char* base64, size_t base64Len, uint8_t* outBuffer, size_t outSize, size_t& decodedSize) {
+    if (base64 == nullptr) {
+        decodedSize = 0;
+        return false;
+    }
     int ret = mbedtls_base64_decode(
         outBuffer,
         outSize,
         &decodedSize,
-        (const unsigned char*)base64.c_str(),
+        (const unsigned char*)base64,
-        base64.length()
+        base64Len
     );
     return (ret == 0);
 }
+
+// Decoder for Base64 content
+bool ImageDecoder::decodeBase64(const String& base64, uint8_t* outBuffer, size_t outSize, size_t& decodedSize) {
+    return decodeBase64(base64.c_str(), base64.length(), outBuffer, outSize, decodedSize);
+}

lib/obp60task/ImageDecoder.h

@@ -5,5 +5,6 @@
 
 class ImageDecoder {
 public:
+    bool decodeBase64(const char* base64, size_t base64Len, uint8_t* outBuffer, size_t outSize, size_t& decodedSize);
     bool decodeBase64(const String& base64, uint8_t* outBuffer, size_t outSize, size_t& decodedSize);
 };

lib/obp60task/LedSpiTask.cpp

@@ -14,6 +14,30 @@ https://controllerstech.com/ws2812-leds-using-spi/
 
 */
 
+String Color::toHex() {
+    char hexColor[8];
+    sprintf(hexColor, "#%02X%02X%02X", r, g, b);
+    return String(hexColor);
+}
+
+String Color::toName() {
+    static std::map<int, String> const names = {
+        {0xff0000, "Red"},
+        {0x00ff00, "Green"},
+        {0x0000ff, "Blue",},
+        {0xff9900, "Orange"},
+        {0xffff00, "Yellow"},
+        {0x3366ff, "Aqua"},
+        {0xff0066, "Violet"},
+        {0xffffff, "White"}
+    };
+    int color = (r << 16) + (g << 8) + b;
+    auto it = names.find(color);
+    if (it == names.end()) {
+        return toHex();
+    }
+    return it->second;
+}
 
 static uint8_t mulcolor(uint8_t f1, uint8_t f2){
     uint16_t rt=f1;

lib/obp60task/LedSpiTask.h

@@ -10,7 +10,7 @@ class Color{
     uint8_t g;
     uint8_t b;
     Color():r(0),g(0),b(0){}
-    Color(uint8_t cr, uint8_t cg,uint8_t cb):
+    Color(uint8_t cr, uint8_t cg, uint8_t cb):
         b(cb),g(cg),r(cr){}
     Color(const Color &o):b(o.b),g(o.g),r(o.r){}
     bool equal(const Color &o) const{
@@ -22,6 +22,8 @@ class Color{
     bool operator != (const Color &other) const{
         return ! equal(other);
     }
+    String toHex();
+    String toName();
 };
 
 static Color COLOR_GREEN=Color(0,255,0);

lib/obp60task/NetworkClient.cpp

@@ -1,16 +1,140 @@
 #include "NetworkClient.h"
+#include "GWWifi.h"             // WiFi management (thread-safe)
+
+extern GwWifi gwWifi;   // Extern declaration of global WiFi instance
 
 extern "C" {
     #include "puff.h"
 }
 
+static uint32_t crc32_update(uint32_t crc, const uint8_t* data, size_t len) {
+    crc = ~crc;
+    for (size_t i = 0; i < len; ++i) {
+        crc ^= data[i];
+        for (int bit = 0; bit < 8; ++bit) {
+            uint32_t mask = -(int32_t)(crc & 1U);
+            crc = (crc >> 1) ^ (0xEDB88320U & mask);
+        }
+    }
+    return ~crc;
+}
+
 // Constructor
 NetworkClient::NetworkClient(size_t reserveSize)
     : _doc(reserveSize),
-      _valid(false)
+      _valid(false),
+      _jsonRaw(nullptr),
+      _jsonRawLen(0),
+      _imageWidth(0),
+      _imageHeight(0),
+      _numberPixels(0),
+      _pictureBase64(nullptr),
+      _pictureBase64Len(0)
 {
 }
 
+NetworkClient::~NetworkClient() {
+    if (_jsonRaw != nullptr) {
+        free(_jsonRaw);
+        _jsonRaw = nullptr;
+        _jsonRawLen = 0;
+    }
+}
+
+bool NetworkClient::findJsonIntField(const char* json, size_t len, const char* key, int& outValue) {
+    if (json == nullptr || key == nullptr || len == 0) {
+        return false;
+    }
+
+    char pattern[64];
+    int plen = snprintf(pattern, sizeof(pattern), "\"%s\"", key);
+    if (plen <= 0 || (size_t)plen >= sizeof(pattern)) {
+        return false;
+    }
+
+    const char* keyPos = strstr(json, pattern);
+    if (keyPos == nullptr) {
+        return false;
+    }
+
+    const char* end = json + len;
+    const char* colon = strchr(keyPos + plen, ':');
+    if (colon == nullptr || colon >= end) {
+        return false;
+    }
+
+    const char* p = colon + 1;
+    while (p < end && (*p == ' ' || *p == '\t' || *p == '\r' || *p == '\n')) {
+        ++p;
+    }
+    if (p >= end) {
+        return false;
+    }
+
+    char* parseEnd = nullptr;
+    long value = strtol(p, &parseEnd, 10);
+    if (parseEnd == p) {
+        return false;
+    }
+    outValue = (int)value;
+    return true;
+}
+
+bool NetworkClient::extractJsonStringInPlace(char* json, size_t len, const char* key, char*& outValue, size_t& outLen) {
+    outValue = nullptr;
+    outLen = 0;
+
+    if (json == nullptr || key == nullptr || len == 0) {
+        return false;
+    }
+
+    char pattern[64];
+    int plen = snprintf(pattern, sizeof(pattern), "\"%s\"", key);
+    if (plen <= 0 || (size_t)plen >= sizeof(pattern)) {
+        return false;
+    }
+
+    char* keyPos = strstr(json, pattern);
+    if (keyPos == nullptr) {
+        return false;
+    }
+
+    char* end = json + len;
+    char* colon = strchr(keyPos + plen, ':');
+    if (colon == nullptr || colon >= end) {
+        return false;
+    }
+
+    char* p = colon + 1;
+    while (p < end && (*p == ' ' || *p == '\t' || *p == '\r' || *p == '\n')) {
+        ++p;
+    }
+    if (p >= end || *p != '"') {
+        return false;
+    }
+
+    char* valueStart = p + 1;
+    char* cur = valueStart;
+    while (cur < end) {
+        if (*cur == '\\') {
+            ++cur;
+            if (cur < end) {
+                ++cur;
+            }
+            continue;
+        }
+        if (*cur == '"') {
+            *cur = '\0';
+            outValue = valueStart;
+            outLen = (size_t)(cur - valueStart);
+            return true;
+        }
+        ++cur;
+    }
+
+    return false;
+}
+
 // Skip GZIP Header an goto DEFLATE content
 int NetworkClient::skipGzipHeader(const uint8_t* data, size_t len) {
     if (len < 10) return -1;
@@ -48,11 +172,18 @@ int NetworkClient::skipGzipHeader(const uint8_t* data, size_t len) {
 // HTTP GET + GZIP Decompression (reading in chunks)
 bool NetworkClient::httpGetGzip(const String& url, uint8_t*& outData, size_t& outLen) {
 
-    const size_t capacity = READLIMIT;   // Read limit for data (can be adjusted in NetworkClient.h)
+    const size_t capacity = READLIMIT;          // Read limit for data (can be adjusted in NetworkClient.h)
     uint8_t* buffer = (uint8_t*)malloc(capacity);
 
+    // If not with WiFi connectetd then return without any activities
+    if (!gwWifi.clientConnected()) {
+        if (DEBUGING) {Serial.println("No WiFi connection");}
+        return false;
+    }
+    
+    // If frame buffer not correct allocated then return without any activities
     if (!buffer) {
-        if (DEBUG) {Serial.println("Malloc failed (buffer");}
+        if (DEBUGING) {Serial.println("Malloc failed buffer");}
         return false;
     }
 
@@ -63,20 +194,50 @@ bool NetworkClient::httpGetGzip(const String& url, uint8_t*& outData, size_t& ou
     http.setTimeout(TCPREADTIMEOUT);            // Read timeout in ms (can be adjusted in NetworkClient.h)
 
     http.begin(url);
+
+    // NEW: force server to close the connection after the response (prevents "stuck" keep-alive reads)
+    http.addHeader("Connection", "close");
+
+    // NEW: request gzip, but we will only decompress if the server actually answers with gzip
     http.addHeader("Accept-Encoding", "gzip");
 
+    // NEW: register headers BEFORE GET() (more reliable with Arduino HTTPClient)
+    if (DEBUGING) {
+        // We need follow key words
+        const char* keys[] = {
+            "Content-Encoding",
+            "Transfer-Encoding",
+            "Content-Length"
+        };
+        // Read header
+        http.collectHeaders(keys, 3);
+    }
+
     int code = http.GET();
     if (code != HTTP_CODE_OK) {
-        Serial.printf("HTTP ERROR: %d\n", code);
+        Serial.printf("HTTP Client ERROR: %d (%s)\n", code, http.errorToString(code).c_str());
 
         // Hard reset HTTP + socket
         WiFiClient* tmp = http.getStreamPtr();
         if (tmp) tmp->stop();   // Force close TCP socket
-        http.end();
         
+        http.end();
         free(buffer);
         return false;
     }
+    else{       
+        if (DEBUGING) {
+            String ce = http.header("Content-Encoding");
+            String te = http.header("Transfer-Encoding");
+            String cl = http.header("Content-Length");
+
+            // Print header informations
+            Serial.printf("Content-Encoding=%s Transfer-Encoding=%s Content-Length=%s\n",
+                        ce.c_str(),
+                        te.c_str(),
+                        cl.c_str());
+        }                
+    }
 
     WiFiClient* stream = http.getStreamPtr();
 
@@ -85,55 +246,251 @@ bool NetworkClient::httpGetGzip(const String& url, uint8_t*& outData, size_t& ou
     const uint32_t READ_TIMEOUT = READDATATIMEOUT;   // Timeout for reading data (can be adjusted in NetworkClient.h)
 
     bool complete = false;
+    bool aborting = false;   // NEW: remember if we must force-close socket
 
-    while (http.connected() && !complete) {
+    // NEW: detect if server really sent gzip
+    String ce = http.header("Content-Encoding");
+    bool isGzip = ce.equalsIgnoreCase("gzip");
 
-        size_t avail = stream->available();
+    // NEW: read expected body size if provided by server (prevents waiting forever for missing bytes)
+    int total = http.getSize();  // returns Content-Length, or -1 if unknown/chunked
 
-        if (avail == 0) {
+    // NEW: fail fast if server claims something larger than our buffer
-            if (millis() - lastData > READ_TIMEOUT) {
+    if (total > 0 && (size_t)total > capacity) {
-                Serial.println("TIMEOUT waiting for data!");
+        Serial.println("Response exceeds READLIMIT.");
-                break;
+        aborting = true;
-            }
-            delay(1);
-            continue;
-        }
-
-        if (len + avail > capacity)
-            avail = capacity - len;
-
-        int read = stream->readBytes(buffer + len, avail);
-        len += read;
-        lastData = millis();
-
-        if (DEBUG) {Serial.printf("Read chunk: %d (total: %d)\n", read, (int)len);}
-
-        if (len < 20) continue;  // Not enough data for header
-
-        int headerOffset = skipGzipHeader(buffer, len);
-        if (headerOffset < 0) continue;
-
-        unsigned long testLen = len * 8; // Dynamic expansion
-        uint8_t* test = (uint8_t*)malloc(testLen);
-
-        if (!test) continue;
-
-        unsigned long srcLen = len - headerOffset;
-
-        int res = puff(test, &testLen, buffer + headerOffset, &srcLen);
-        if (res == 0) {
-            if (DEBUG) {Serial.printf("Decompress OK! Size: %lu bytes\n", testLen);}
-            outData = test;
-            outLen = testLen;
-            complete = true;
-            break;
-        }
-
-        free(test);
     }
 
-    // --- Added: Force-close connection in all cases to avoid stuck TCP sockets ---
+    // NEW: if not gzip, we will not try to decompress (prevents false "Decompress OK" / random success)
-    if (stream) stream->stop();
+    // You can either handle plain JSON here or just fail-fast.
+    if (!isGzip && !aborting) {
+        if (DEBUGING) {
+            Serial.println("Server response is NOT gzip (Content-Encoding != gzip).");
+            Serial.println("Either disable Accept-Encoding: gzip or add plain-body handling here.");
+        }
+
+        // --- Plain-body handling (recommended): read full body into outData as-is ---
+        // NEW: try to read Content-Length bytes if available (more robust)
+        if (total > 0 && (size_t)total > capacity) {
+            Serial.println("Plain response exceeds READLIMIT.");
+            aborting = true;
+        } else {
+            // Read until we have all bytes (Content-Length) or until connection closes + buffer drains
+            while ((http.connected() || (stream && stream->available())) && !aborting) {
+                size_t avail = stream ? stream->available() : 0;
+                if (avail == 0) {
+                    if (millis() - lastData > READ_TIMEOUT) {
+                        Serial.println("TIMEOUT waiting for data (plain)!");
+                        aborting = true;
+                        break;
+                    }
+                    delay(1);
+                    continue;
+                }
+
+                if (len >= capacity) {
+                    Serial.println("READLIMIT reached, aborting (plain).");
+                    aborting = true;
+                    break;
+                }
+
+                if (len + avail > capacity)
+                    avail = capacity - len;
+
+                int read = stream->readBytes(buffer + len, avail);
+                if (read > 0) {
+                    len += (size_t)read;
+                    lastData = millis();
+                }
+
+                // NEW: stop reading as soon as we have the full response
+                if (total > 0 && (int)len >= total) {
+                    break; // we got full body
+                }
+            }
+        }
+
+        if (aborting) {
+            // --- Added: Force-close connection only if aborted to avoid TCP RST storms ---
+            if (stream) stream->stop();   // Force close TCP socket
+            http.end();
+            free(buffer);
+            return false;
+        }
+
+        if (total > 0 && (int)len != total) {
+            Serial.printf("Plain response incomplete: got=%d expected=%d\n", (int)len, total);
+            if (stream) stream->stop();
+            http.end();
+            free(buffer);
+            return false;
+        }
+
+        // Return plain body to caller
+        outData = (uint8_t*)malloc(len + 1);
+        if (!outData) {
+            Serial.println("Malloc failed outData (plain).");
+            // --- Added: Force-close connection only if aborted to avoid TCP RST storms ---
+            if (stream) stream->stop();   // Force close TCP socket
+            http.end();
+            free(buffer);
+            return false;
+        }
+        memcpy(outData, buffer, len);
+        outData[len] = 0;
+        outLen = len;
+
+        http.end();
+        free(buffer);
+        return true;
+    }
+
+    // --- GZIP path (only if Content-Encoding is gzip) ---
+    if (!aborting) {
+
+        // NEW: read exactly Content-Length bytes when available (prevents partial-body timeout loops)
+        while ((http.connected() || (stream && stream->available())) && !complete && !aborting) {
+
+            size_t avail = stream ? stream->available() : 0;
+
+            if (avail == 0) {
+                // NEW: if Content-Length is known and we already read it all, stop immediately
+                if (total > 0 && (int)len >= total) {
+                    break;
+                }
+
+                if (millis() - lastData > READ_TIMEOUT) {
+                    Serial.println("TIMEOUT waiting for data!");
+                    aborting = true;   // NEW: mark abnormal exit
+                    break;
+                }
+                delay(1);
+                continue;
+            }
+
+            // NEW: safety check if buffer limit is reached
+            if (len >= capacity) {
+                Serial.println("READLIMIT reached, aborting.");
+                aborting = true;
+                break;
+            }
+
+            // NEW: if Content-Length is known, do not read beyond it
+            if (total > 0) {
+                size_t remaining = (size_t)total - len;
+                if (avail > remaining) avail = remaining;
+            }
+
+            if (len + avail > capacity)
+                avail = capacity - len;
+
+            int read = stream->readBytes(buffer + len, avail);
+            if (read <= 0) {
+                // NEW: avoid tight loop if read returns zero
+                delay(1);
+                continue;
+            }
+
+            len += (size_t)read;
+            lastData = millis();
+
+            if (DEBUGING) {Serial.printf("Read chunk: %d (total: %d)\n", read, (int)len);}
+
+            // NEW: if Content-Length is known and fully received, we can stop reading
+            if (total > 0 && (int)len >= total) {
+                break;
+            }
+        }
+
+        // NEW: only attempt gzip parse/decompress after we have a complete body (when Content-Length is known)
+        // This avoids wasting heap with repeated malloc/free and reduces fragmentation over long runtimes.
+        if (!aborting) {
+            if (total > 0 && (int)len != total) {
+                Serial.printf("GZIP response incomplete: got=%d expected=%d\n", (int)len, total);
+                aborting = true;
+            }
+        }
+
+        if (!aborting) {
+            if (len < 20) {
+                aborting = true;
+            } else {
+                int headerOffset = skipGzipHeader(buffer, len);
+                if (headerOffset < 0) {
+                    aborting = true;
+                } else {
+                    size_t deflateLen = len - (size_t)headerOffset;
+                    // GZIP trailer (CRC32 + ISIZE) is 8 bytes and not part of deflate stream.
+                    if (deflateLen >= 8) {
+                        deflateLen -= 8;
+                    }
+
+                    unsigned long srcLenForSize = (unsigned long)deflateLen;
+                    unsigned long outNeeded = 0;
+                    int sizeRes = puff(NIL, &outNeeded, buffer + headerOffset, &srcLenForSize);
+
+                    if (sizeRes != 0) {
+                        if (DEBUGING) {
+                            Serial.printf("Decompress size probe failed: res=%d src=%lu\n", sizeRes, srcLenForSize);
+                        }
+                        aborting = true;
+                    } else {
+                        uint8_t* test = (uint8_t*)malloc((size_t)outNeeded + 1);
+                        if (!test) {
+                            Serial.println("Malloc failed test buffer, aborting.");
+                            aborting = true;
+                        } else {
+                            unsigned long srcLen = (unsigned long)deflateLen;
+                            unsigned long testLen = outNeeded;
+                            int res = puff(test, &testLen, buffer + headerOffset, &srcLen);
+
+                            if (res == 0) {
+                                uint32_t trailerCrc =
+                                    (uint32_t)buffer[len - 8] |
+                                    ((uint32_t)buffer[len - 7] << 8) |
+                                    ((uint32_t)buffer[len - 6] << 16) |
+                                    ((uint32_t)buffer[len - 5] << 24);
+                                uint32_t trailerIsize =
+                                    (uint32_t)buffer[len - 4] |
+                                    ((uint32_t)buffer[len - 3] << 8) |
+                                    ((uint32_t)buffer[len - 2] << 16) |
+                                    ((uint32_t)buffer[len - 1] << 24);
+                                uint32_t calcCrc = crc32_update(0, test, (size_t)testLen);
+                                uint32_t calcIsize = (uint32_t)testLen;
+
+                                if (calcCrc != trailerCrc || calcIsize != trailerIsize) {
+                                    Serial.printf(
+                                        "GZIP CRC/ISIZE mismatch crc=%08lx/%08lx isize=%lu/%lu\n",
+                                        (unsigned long)calcCrc,
+                                        (unsigned long)trailerCrc,
+                                        (unsigned long)calcIsize,
+                                        (unsigned long)trailerIsize
+                                    );
+                                    free(test);
+                                    aborting = true;
+                                } else {
+                                    test[testLen] = 0;
+                                    if (DEBUGING) {Serial.printf("Decompress OK! Size: %lu bytes\n", testLen);}
+                                    outData = test;
+                                    outLen = (size_t)testLen;
+                                    complete = true;
+                                }
+                            } else {
+                                if (DEBUGING) {
+                                    Serial.printf("Decompress failed: res=%d out=%lu src=%lu\n", res, testLen, srcLen);
+                                }
+                                free(test);
+                                aborting = true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // --- Added: Force-close connection only if aborted to avoid TCP RST storms ---
+    if (aborting && stream) stream->stop();   // NEW: stop() only on abnormal termination
 
     http.end();
     free(buffer);
@@ -150,6 +507,18 @@ bool NetworkClient::httpGetGzip(const String& url, uint8_t*& outData, size_t& ou
 bool NetworkClient::fetchAndDecompressJson(const String& url) {
 
     _valid = false;
+    _doc.clear();
+    _imageWidth = 0;
+    _imageHeight = 0;
+    _numberPixels = 0;
+    _pictureBase64 = nullptr;
+    _pictureBase64Len = 0;
+
+    if (_jsonRaw != nullptr) {
+        free(_jsonRaw);
+        _jsonRaw = nullptr;
+        _jsonRawLen = 0;
+    }
 
     uint8_t* raw = nullptr;
     size_t rawLen = 0;
@@ -159,15 +528,38 @@ bool NetworkClient::fetchAndDecompressJson(const String& url) {
         return false;
     }
 
-    DeserializationError err = deserializeJson(_doc, raw, rawLen);
+    char* json = reinterpret_cast<char*>(raw);
-    free(raw);
+    bool ok = true;
+    ok = findJsonIntField(json, rawLen, "number_pixels", _numberPixels) && ok;
+    ok = findJsonIntField(json, rawLen, "width", _imageWidth) && ok;
+    ok = findJsonIntField(json, rawLen, "height", _imageHeight) && ok;
+    ok = extractJsonStringInPlace(json, rawLen, "picture_base64", _pictureBase64, _pictureBase64Len) && ok;
 
-    if (err) {
+    if (!ok) {
-        Serial.printf("JSON ERROR: %s\n", err.c_str());
+        Serial.println("JSON field extraction failed.");
+        free(raw);
         return false;
     }
 
-    if (DEBUG) {Serial.println("JSON OK!");}
+    if (_imageWidth <= 0 || _imageHeight <= 0 || _pictureBase64Len == 0) {
+        Serial.printf("JSON invalid geometry/data w=%d h=%d b64=%u\n",
+                      _imageWidth,
+                      _imageHeight,
+                      (unsigned int)_pictureBase64Len);
+        free(raw);
+        return false;
+    }
+
+    _jsonRaw = raw;
+    _jsonRawLen = rawLen;
+
+    if (DEBUGING) {
+        Serial.printf("JSON fields OK: num=%d w=%d h=%d b64=%u\n",
+                      _numberPixels,
+                      _imageWidth,
+                      _imageHeight,
+                      (unsigned int)_pictureBase64Len);
+    }
     _valid = true;
     return true;
 }
@@ -176,6 +568,26 @@ JsonDocument& NetworkClient::json() {
     return _doc;
 }
 
+int NetworkClient::imageWidth() const {
+    return _imageWidth;
+}
+
+int NetworkClient::imageHeight() const {
+    return _imageHeight;
+}
+
+int NetworkClient::numberPixels() const {
+    return _numberPixels;
+}
+
+const char* NetworkClient::pictureBase64() const {
+    return _pictureBase64;
+}
+
+size_t NetworkClient::pictureBase64Len() const {
+    return _pictureBase64Len;
+}
+
 bool NetworkClient::isValid() const {
     return _valid;
 }

lib/obp60task/NetworkClient.h

@@ -3,7 +3,7 @@
 #include <WiFi.h>
 #include <HTTPClient.h>
 
-#define DEBUG false             // Debug flag for NetworkClient for more live information
+#define DEBUGING true             // Debug flag for NetworkClient for more live information
 #define READLIMIT 200000        // HTTP read limit in byte for gzip content (can be adjusted)
 #define CONNECTIONTIMEOUT 3000  // Timeout in ms for HTTP connection 
 #define TCPREADTIMEOUT 2000     // Timeout in ms for read HTTP client stack
@@ -12,16 +12,31 @@
 class NetworkClient {
 public:
     NetworkClient(size_t reserveSize = 0);
+    ~NetworkClient();
 
     bool fetchAndDecompressJson(const String& url);
     JsonDocument& json();
+    int imageWidth() const;
+    int imageHeight() const;
+    int numberPixels() const;
+    const char* pictureBase64() const;
+    size_t pictureBase64Len() const;
     bool isValid() const;
 
 private:
     DynamicJsonDocument _doc;
     bool _valid;
+    uint8_t* _jsonRaw;
+    size_t _jsonRawLen;
+    int _imageWidth;
+    int _imageHeight;
+    int _numberPixels;
+    char* _pictureBase64;
+    size_t _pictureBase64Len;
 
     int skipGzipHeader(const uint8_t* data, size_t len);
     bool httpGetGzip(const String& url, uint8_t*& outData, size_t& outLen);
+    static bool findJsonIntField(const char* json, size_t len, const char* key, int& outValue);
+    static bool extractJsonStringInPlace(char* json, size_t len, const char* key, char*& outValue, size_t& outLen);
 };
 

lib/obp60task/OBP60Extensions.cpp

@@ -56,6 +56,61 @@ GxEPD2_BW<GxEPD2_420_SE0420NQ04, GxEPD2_420_SE0420NQ04::HEIGHT> display(GxEPD2_4
 GxEPD2_BW<GxEPD2_420_SE0420NQ04, GxEPD2_420_SE0420NQ04::HEIGHT> & getdisplay(){return display;}
 #endif
 
+#ifdef TFT_DISPLAY
+// panel device + offscreen shadow framebuffer
+static LGFX panelDisplay;
+static LGFXCanvas shadowDisplay(&panelDisplay);
+static LGFXCanvas scaleDisplay(&panelDisplay);
+static bool shadowDisplayInitialized = false;
+static bool scaleDisplayInitialized = false;
+static uint16_t scaleDisplayWidth = 0;
+static uint16_t scaleDisplayHeight = 0;
+
+LGFXCanvas & getdisplay(){return shadowDisplay;}
+LGFX & getpaneldisplay(){return panelDisplay;}
+LGFXCanvas & getscaleddisplay(){return scaleDisplay;}
+
+bool initDisplayShadowBuffer(){
+    if (shadowDisplayInitialized) return true;
+
+    shadowDisplay.setPsram(true);
+    shadowDisplay.setColorDepth(16);
+    shadowDisplay.setTextDatum(textdatum_t::baseline_left);
+
+    if (shadowDisplay.createSprite(GxEPD_WIDTH, GxEPD_HEIGHT) == nullptr) {
+        shadowDisplayInitialized = false;
+        return false;
+    }
+
+    shadowDisplay.fillScreen(GxEPD_BLACK);
+    shadowDisplayInitialized = true;
+    return true;
+}
+
+bool initDisplayScaleBuffer(uint16_t width, uint16_t height){
+    if (scaleDisplayInitialized && scaleDisplayWidth == width && scaleDisplayHeight == height) {
+        return true;
+    }
+
+    scaleDisplay.deleteSprite();
+    scaleDisplay.setPsram(true);
+    scaleDisplay.setColorDepth(16);
+    scaleDisplay.setTextDatum(textdatum_t::baseline_left);
+
+    if (scaleDisplay.createSprite(width, height) == nullptr) {
+        scaleDisplayInitialized = false;
+        scaleDisplayWidth = 0;
+        scaleDisplayHeight = 0;
+        return false;
+    }
+
+    scaleDisplayWidth = width;
+    scaleDisplayHeight = height;
+    scaleDisplayInitialized = true;
+    return true;
+}
+#endif
+
 // Horter I2C moduls
 PCF8574 pcf8574_Modul1(PCF8574_I2C_ADDR1); // First digital IO modul PCF8574 from Horter
 
@@ -86,7 +141,7 @@ void hardwareInit(GwApi *api)
     GwLog *logger = api->getLogger();
     GwConfigHandler *config = api->getConfig();
 
-    Wire.begin();
+    Wire.begin(OBP_I2C_SDA, OBP_I2C_SCL);
     // Init PCF8574 digital outputs
     Wire.setClock(I2C_SPEED_LOW);   // Set I2C clock on 10 kHz
     if(pcf8574_Modul1.begin()){        // Initialize PCF8574
@@ -175,7 +230,7 @@ void hardwareInit(GwApi *api)
 void powerInit(String powermode) {
     // Max Power | Only 5.0V | Min Power
     if (powermode == "Max Power" || powermode == "Only 5.0V") {
-#ifdef HARDWARE_V21
+#ifdef BOARD_OBP60S3
         setPortPin(OBP_POWER_50, true); // Power on 5.0V rail
 #endif
 #ifdef BOARD_OBP40S3
@@ -183,7 +238,7 @@ void powerInit(String powermode) {
         setPortPin(OBP_POWER_SD, true); // Power on SD card
 #endif
     } else { // Min Power
-#ifdef HARDWARE_V21
+#ifdef BOARD_OBP60S3
         setPortPin(OBP_POWER_50, false); // Power off 5.0V rail
 #endif
 #ifdef BOARD_OBP40S3
@@ -251,8 +306,12 @@ void deepSleep(CommonData &common){
     getdisplay().setFont(&Ubuntu_Bold8pt8b);
     getdisplay().setCursor(65, 175);
     getdisplay().print("To wake up press key and wait 5s");
-    getdisplay().nextPage();                // Update display contents
+    displayNextPage();                // Update display contents
+    #ifdef TFT_DISPLAY
+    getpaneldisplay().powerSave(true);      // Display power save
+    #else
     getdisplay().powerOff();                // Display power off
+    #endif
     setPortPin(OBP_POWER_50, false);        // Power off ePaper display
     // Stop system
     esp_deep_sleep_start();                 // Deep Sleep with weakup via touch pin
@@ -276,8 +335,12 @@ void deepSleep(CommonData &common){
     getdisplay().setFont(&Ubuntu_Bold8pt8b);
     getdisplay().setCursor(65, 175);
     getdisplay().print("To wake up press wheel and wait 5s");
-    getdisplay().nextPage();                // Partial update
+    displayNextPage();                // Partial update
+    #ifdef TFT_DISPLAY
+    getpaneldisplay().powerSave(true);      // Display power save
+    #else
     getdisplay().powerOff();                // Display power off
+    #endif
     setPortPin(OBP_POWER_EPD, false);       // Power off ePaper display
     setPortPin(OBP_POWER_SD, false);        // Power off SD card
     // Stop system
@@ -475,36 +538,14 @@ std::vector<String> wordwrap(String &line, uint16_t maxwidth) {
     return lines;
 }
 
-// Helper function to just get the exact width of a string
-uint16_t getStringPixelWidth(const char* str, const GFXfont* font) {
-    int16_t minx = INT16_MAX;
-    int16_t maxx = INT16_MIN;
-    int16_t cursor_x = 0;
-    while (*str) {
-        char c = *str++;
-        if (c < font->first || c > font->last) {
-            continue;
-        }
-        GFXglyph* glyph = &font->glyph[c - font->first];
-        if (glyph->width > 0) {
-            int16_t glyphStart = cursor_x + glyph->xOffset;
-            int16_t glyphEnd = glyphStart + glyph->width;
-            if (glyphStart < minx) minx = glyphStart;
-            if (glyphEnd > maxx) maxx = glyphEnd;
-        }
-        cursor_x += glyph->xAdvance;
-    }
-    if (minx > maxx)
-        return 0;
-    return maxx - minx;
-}
-
 // Draw centered text
 void drawTextCenter(int16_t cx, int16_t cy, String text) {
     int16_t x1, y1;
     uint16_t w, h;
-    getdisplay().getTextBounds(text, 0, 150, &x1, &y1, &w, &h);
+    displayGetTextBounds(text, 0, 0, &x1, &y1, &w, &h);
-    getdisplay().setCursor(cx - w / 2, cy + h / 2);
+    int16_t cursorX = cx - (x1 + static_cast<int16_t>(w / 2));
+    int16_t cursorY = cy - (y1 + static_cast<int16_t>(h / 2));
+    getdisplay().setCursor(cursorX, cursorY);
     getdisplay().print(text);
 }
 
@@ -512,19 +553,20 @@ void drawTextCenter(int16_t cx, int16_t cy, String text) {
 void drawButtonCenter(int16_t cx, int16_t cy, int8_t sx, int8_t sy, String text, uint16_t fg, uint16_t bg, bool inverted) {
     int16_t x1, y1;
     uint16_t w, h;
-    uint16_t color;
+    displayGetTextBounds(text, 0, 0, &x1, &y1, &w, &h);
-
+    int16_t cursorX = cx - (x1 + static_cast<int16_t>(w / 2));
-    getdisplay().getTextBounds(text, cx, cy, &x1, &y1, &w, &h); // Find text center
+    int16_t cursorY = cy - (y1 + static_cast<int16_t>(h / 2));
-    getdisplay().setCursor(cx - w/2, cy + h/2);                 // Set cursor to center
     //getdisplay().drawPixel(cx, cy, fg);                         // Debug pixel for center position
     if (inverted) {
         getdisplay().fillRoundRect(cx - sx / 2, cy - sy / 2, sx, sy, 5, fg); // Draw button
         getdisplay().setTextColor(bg);
+        getdisplay().setCursor(cursorX, cursorY);                 // Set cursor to center
         getdisplay().print(text);                               // Draw text
      }
      else{
         getdisplay().drawRoundRect(cx - sx / 2, cy - sy / 2, sx, sy, 5, fg); // Draw button
         getdisplay().setTextColor(fg);
+        getdisplay().setCursor(cursorX, cursorY);                 // Set cursor to center
         getdisplay().print(text);                               // Draw text
      }
 }
@@ -533,7 +575,12 @@ void drawButtonCenter(int16_t cx, int16_t cy, int8_t sx, int8_t sy, String text,
 void drawTextRalign(int16_t x, int16_t y, String text) {
     int16_t x1, y1;
     uint16_t w, h;
+#ifdef TFT_DISPLAY
+    w = getdisplay().textWidth(text);
+    h = getdisplay().fontHeight();
+#else
     getdisplay().getTextBounds(text, 0, 150, &x1, &y1, &w, &h);
+#endif
     getdisplay().setCursor(x - w - 1, y); // '-1' required since some strings wrap around w/o it
     getdisplay().print(text);
 }
@@ -619,7 +666,7 @@ void displayHeader(CommonData &commonData, GwApi::BoatValue *date, GwApi::BoatVa
         usbRxOld = commonData.status.usbRx;
         usbTxOld = commonData.status.usbTx;
 
-#ifdef HARDWARE_V21
+#ifdef BOARD_OBP60S3
         // Display key lock status
         if (commonData.keylock) {
             getdisplay().drawXBitmap(170, 1, lock_bits, icon_width, icon_height, commonData.fgcolor);
@@ -662,19 +709,20 @@ void displayHeader(CommonData &commonData, GwApi::BoatValue *date, GwApi::BoatVa
         // Date and time
         String fmttype = commonData.config->getString(commonData.config->dateFormat);
         String timesource = commonData.config->getString(commonData.config->timeSource);
+        double tz = commonData.config->getString(commonData.config->timeZone).toDouble();
         getdisplay().setTextColor(commonData.fgcolor);
         getdisplay().setFont(&Ubuntu_Bold8pt8b);
         getdisplay().setCursor(230, 15);
         if (timesource == "RTC" or timesource == "iRTC") {
             // TODO take DST into account
             if (commonData.data.rtcValid) {
-                time_t tv = mktime(&commonData.data.rtcTime) + (int)(commonData.tz * 3600);
+                time_t tv = mktime(&commonData.data.rtcTime) + (int)(tz * 3600);
                 struct tm *local_tm = localtime(&tv);
                 getdisplay().print(formatTime('m', local_tm->tm_hour, local_tm->tm_min, 0));
                 getdisplay().print(" ");
                 getdisplay().print(formatDate(fmttype, local_tm->tm_year + 1900, local_tm->tm_mon + 1, local_tm->tm_mday));
                 getdisplay().print(" ");
-                getdisplay().print(commonData.tz == 0 ? "UTC" : "LOT");
+                getdisplay().print(tz == 0 ? "UTC" : "LOT");
             } else {
                 drawTextRalign(396, 15, "RTC invalid");
             }
@@ -689,7 +737,7 @@ void displayHeader(CommonData &commonData, GwApi::BoatValue *date, GwApi::BoatVa
                 getdisplay().print(" ");
                 getdisplay().print(actdate);
                 getdisplay().print(" ");
-                getdisplay().print(commonData.tz == 0 ? "UTC" : "LOT");
+                getdisplay().print(tz == 0 ? "UTC" : "LOT");
             }
             else{
                 if(commonData.config->getBool(commonData.config->useSimuData) == true){
@@ -711,7 +759,7 @@ void displayFooter(CommonData &commonData) {
     getdisplay().setFont(&Atari16px);
     getdisplay().setTextColor(commonData.fgcolor);
 
-#ifdef HARDWARE_V21
+#ifdef BOARD_OBP60S3
     // Frame around key icon area
     if (! commonData.keylock) {
         // horizontal elements
@@ -946,7 +994,7 @@ void solarGraphic(uint x, uint y, int pcolor, int bcolor){
 
 }
 
-// Generator graphic with fill level
+// Generator graphic
 void generatorGraphic(uint x, uint y, int pcolor, int bcolor){
     // Show battery
         int xb = x;     // X position
@@ -963,6 +1011,81 @@ void generatorGraphic(uint x, uint y, int pcolor, int bcolor){
         getdisplay().print("G");
 }
 
+// Display rudder position as horizontal bargraph with configurable +/- range (degrees)
+void displayRudderPosition(int rudderPosition, uint8_t rangeDeg, uint16_t cx, uint16_t cy, uint16_t fg, uint16_t bg){
+    const int w = 360;
+    const int h = 20;
+    const int t = 3; // Line thickness
+    const int halfw = w/2;
+    const int halfh = h/2;
+    // Calculate top-left of bar (cx,cy are center of 0°)
+    int left = int(cx) - halfw;
+    int top = int(cy) - halfh;
+
+    // clamp provided range to allowed bounds [10,45]
+    if (rangeDeg < 10) rangeDeg = 10;
+    if (rangeDeg > 45) rangeDeg = 45;
+
+    // Pixels per degree for +/-rangeDeg -> total span = 2*rangeDeg
+    const float pxPerDeg = float(w) / (2.0f * float(rangeDeg));
+
+    // Draw outer border (thickness t)
+    for (int i = 0; i < t; i++) {
+        getdisplay().drawRect(left + i, top + i, w - 2 * i, h - 2 * i, fg);
+    }
+
+    // Fill inner area with background
+    getdisplay().fillRect(left + t, top + t, w - 2 * t, h - 2 * t, bg);
+
+    // Draw center line
+    getdisplay().drawRect(cx - 1, top + 1, 3 , h - 2, fg);
+
+    // Clamp rudder position to -rangeDeg..rangeDeg
+    if (rudderPosition > (int)rangeDeg) rudderPosition = (int)rangeDeg;
+    if (rudderPosition < -((int)rangeDeg)) rudderPosition = -((int)rangeDeg);
+
+    // Compute fill width in pixels
+    int fillPx = int(round(rudderPosition * pxPerDeg)); // positive -> right
+
+    // Fill area from center to position (if non-zero)
+    int centerx = cx;
+    int innerTop = top + t;
+    int innerH = h - 2 * t;
+    if (fillPx > 0) {
+        // Right side
+        getdisplay().fillRect(centerx, innerTop, fillPx, innerH, fg);
+    } else if (fillPx < 0) {
+        // Left side
+        getdisplay().fillRect(centerx + fillPx, innerTop, -fillPx, innerH, fg);
+    }
+
+    
+    // Draw tick marks every 5° and labels outside the bar
+    getdisplay().setTextColor(fg);
+    getdisplay().setFont(&Ubuntu_Bold8pt8b);
+    for (int angle = -((int)rangeDeg); angle <= (int)rangeDeg; angle += 5) {
+        int xpos = int(round(centerx + angle * pxPerDeg));
+        // Vertical tick inside bar
+        getdisplay().drawLine(xpos, top, xpos, top + h + 2, fg);
+        // Label outside: below the bar
+        String lbl = String(angle);
+        int16_t bx, by;
+        uint16_t bw, bh;
+        #ifdef TFT_DISPLAY
+            // LovyanGFX: compute width/height manually
+            bw = getdisplay().textWidth(lbl);
+            bh = getdisplay().fontHeight();
+            bx = 0; by = 0;
+        #else
+            getdisplay().getTextBounds(lbl, 0, 0, &bx, &by, &bw, &bh);
+        #endif
+        int16_t tx = xpos - bw/2;
+        int16_t ty = top + h + bh + 5; // A little spacing
+        getdisplay().setCursor(tx, ty);
+        getdisplay().print(lbl);
+    }
+}
+
 // Function to handle HTTP image request
 // http://192.168.15.1/api/user/OBP60Task/screenshot
 void doImageRequest(GwApi *api, int *pageno, const PageStruct pages[MAX_PAGE_NUMBER], AsyncWebServerRequest *request) {
@@ -974,9 +1097,16 @@ void doImageRequest(GwApi *api, int *pageno, const PageStruct pages[MAX_PAGE_NUM
 
     logger->logDebug(GwLog::LOG,"handle image request [%s]: %s", imgformat, filename);
 
-    uint8_t *fb = getdisplay().getBuffer(); // EPD framebuffer
+    uint8_t *fb = nullptr; // EPD framebuffer
     std::vector<uint8_t> imageBuffer;       // image in webserver transferbuffer
     String mimetype;
+    #ifndef TFT_DISPLAY
+        fb = getdisplay().getBuffer(); // available only for EPD
+    #endif
+    if (!fb) {
+        request->send(500, "text/plain", "screenshot not available");
+        return;
+    }
 
     if (imgformat == "gif") {
         // GIF is commpressed with LZW, so small

lib/obp60task/OBP60Extensions.h

@@ -5,14 +5,28 @@
 #include "OBP60Hardware.h"
 #include "LedSpiTask.h"
 #include "Graphics.h"
-#include <GxEPD2_BW.h>                  // E-paper lib V2
+#include <GxEPD2_BW.h>                  // GxEPD2 lib for b/w E-Ink displays
 #include <Adafruit_FRAM_I2C.h>          // I2C FRAM
 #include <math.h>
 
+#ifdef TFT_DISPLAY
+    #if !defined(TFT_320x480_ST7796) && !defined(TFT_320x480_ILI9488)
+        #error "TFT_DISPLAY requires one panel type: TFT_320x480_ST7796 or TFT_320x480_ILI9488"
+    #endif
+    #if defined(TFT_320x480_ST7796) && defined(TFT_320x480_ILI9488)
+        #error "Select exactly one TFT panel type: TFT_320x480_ST7796 or TFT_320x480_ILI9488"
+    #endif
+    #include <LovyanGFX.hpp>            // TFT LCD lib for 320x480 color displays
+    #undef GxEPD_WHITE
+    #define GxEPD_WHITE  TFT_WHITE      // Replacement color for white on TFT (OBPHardware.h)
+    #undef GxEPD_BLACK
+    #define GxEPD_BLACK  TFT_BLACK      // Replacement color for black on TFT (OBPHardware.h)
+#endif
+
 #ifdef BOARD_OBP40S3
-#include "esp_vfs_fat.h"
+    #include "esp_vfs_fat.h"
-#include "sdmmc_cmd.h"
+    #include "sdmmc_cmd.h"
-#define MOUNT_POINT "/sdcard"
+    #define MOUNT_POINT "/sdcard"
 #endif
 
 // FRAM address reservations 32kB: 0x0000 - 0x7FFF
@@ -74,11 +88,621 @@ GxEPD2_BW<GxEPD2_420_GYE042A87, GxEPD2_420_GYE042A87::HEIGHT> & getdisplay();
 GxEPD2_BW<GxEPD2_420_SE0420NQ04, GxEPD2_420_SE0420NQ04::HEIGHT> & getdisplay();
 #endif
 
+#ifdef TFT_DISPLAY
+// LovyanGFX based display wrapper for TFT panels
+class LGFX : public lgfx::LGFX_Device {
+public:
+  lgfx::Bus_SPI _bus_instance;
+
+  #ifdef TFT_320x480_ST7796
+  LGFX(void) {
+    {
+      auto cfg = _bus_instance.config();
+      cfg.spi_host = SPI2_HOST;
+      cfg.spi_mode = 0;
+      cfg.freq_write = 80000000;    // High speed ST7796
+      cfg.freq_read  = 16000000;
+      cfg.pin_sclk = OBP_SPI_CLK;
+      cfg.pin_mosi = OBP_SPI_DIN;
+      cfg.pin_miso = -1;
+      cfg.pin_dc   = OBP_SPI_DC;
+      _bus_instance.config(cfg);
+      _panel_instance.setBus(&_bus_instance);
+    }
+    {
+      auto cfg = _panel_instance.config();
+      cfg.pin_cs  = OBP_SPI_CS;
+      cfg.pin_rst = OBP_SPI_RST;
+      cfg.pin_busy = -1;
+      cfg.panel_width  = 320;       // Native width resolution
+      cfg.panel_height = 480;       // Native hight resolution
+      cfg.offset_x     = 0;         // No panel offset: full framebuffer mapping
+      cfg.offset_y     = 0;         // No panel offset: full framebuffer mapping
+      cfg.offset_rotation = 3;      // Rotate display content conter clock wise 90 deg ST7796
+      cfg.dummy_read_pixel = 8;
+      cfg.dummy_read_bits  = 1;
+      cfg.memory_width     = 320;
+      cfg.memory_height    = 480;
+      // cfg.pwm_control not available in this LovyanGFX version
+      cfg.invert = false;
+      cfg.rgb_order = false;
+      cfg.dlen_16bit = false;
+      cfg.bus_shared = true;
+      _panel_instance.config(cfg);
+    }
+        // No dedicated TFT PWM backlight pin configured on this board.
+        // Keep backlight handling outside LovyanGFX to avoid LEDC init on invalid GPIO.
+    setPanel(&_panel_instance);
+        // Match Adafruit GFX cursor semantics: y coordinate is text baseline.
+        setTextDatum(textdatum_t::baseline_left);
+  }
+  #endif
+
+  #ifdef TFT_320x480_ILI9488
+  LGFX(void) {
+    {
+      auto cfg = _bus_instance.config();
+      cfg.spi_host = SPI2_HOST;
+      cfg.spi_mode = 0;
+      cfg.freq_write = 40000000;    // Slow speed ILI9488
+      cfg.freq_read  = 16000000;
+      cfg.pin_sclk = OBP_SPI_CLK;
+      cfg.pin_mosi = OBP_SPI_DIN;
+      cfg.pin_miso = -1;
+      cfg.pin_dc   = OBP_SPI_DC;
+      _bus_instance.config(cfg);
+      _panel_instance.setBus(&_bus_instance);
+    }
+    {
+      auto cfg = _panel_instance.config();
+      cfg.pin_cs  = OBP_SPI_CS;
+      cfg.pin_rst = OBP_SPI_RST;
+      cfg.pin_busy = -1;
+      cfg.panel_width  = 320;       // Native width resolution
+      cfg.panel_height = 480;       // Native hight resolution
+      cfg.offset_x     = 0;         // No panel offset: full framebuffer mapping
+      cfg.offset_y     = 0;         // No panel offset: full framebuffer mapping
+      cfg.offset_rotation = 1;      // Rotate display content clock wise 90 deg ILI9488
+      cfg.dummy_read_pixel = 8;
+      cfg.dummy_read_bits  = 1;
+      cfg.memory_width     = 320;
+      cfg.memory_height    = 480;
+      // cfg.pwm_control not available in this LovyanGFX version
+      cfg.invert = false;
+      cfg.rgb_order = false;
+      cfg.dlen_16bit = false;
+      cfg.bus_shared = true;
+      _panel_instance.config(cfg);
+    }
+        // No dedicated TFT PWM backlight pin configured on this board.
+        // Keep backlight handling outside LovyanGFX to avoid LEDC init on invalid GPIO.
+    setPanel(&_panel_instance);
+        // Match Adafruit GFX cursor semantics: y coordinate is text baseline.
+        setTextDatum(textdatum_t::baseline_left);
+  }
+  #endif
+
+  // compatibility helpers --------------------------------------------------
+    using lgfx::LGFX_Device::setFont;
+    void setFont(const lgfx::IFont* font) {
+        _currentAdfFont = nullptr;
+        lgfx::LGFX_Device::setFont(font);
+    }
+    // Adafruit GFX fonts support on TFT via LovyanGFX bridge
+    void setFont(const GFXfont *font) {
+        if (font == nullptr) {
+            _currentAdfFont = nullptr;
+            lgfx::LGFX_Device::setFont(nullptr);
+            return;
+        }
+
+        if (font->glyph == nullptr || font->bitmap == nullptr || font->last < font->first) {
+            _currentAdfFont = nullptr;
+            lgfx::LGFX_Device::setFont(nullptr);
+            return;
+        }
+
+        const uint16_t glyphCount = static_cast<uint16_t>(font->last - font->first + 1);
+        if (glyphCount == 0) {
+            lgfx::LGFX_Device::setFont(nullptr);
+            return;
+        }
+
+        if (_adfGlyphCount != glyphCount || _adfGlyphBridge == nullptr) {
+            if (_adfGlyphBridge != nullptr) {
+                free(_adfGlyphBridge);
+                _adfGlyphBridge = nullptr;
+                _adfGlyphCount = 0;
+            }
+            _adfGlyphBridge = static_cast<lgfx::GFXglyph*>(malloc(sizeof(lgfx::GFXglyph) * glyphCount));
+            if (_adfGlyphBridge == nullptr) {
+                lgfx::LGFX_Device::setFont(nullptr);
+                return;
+            }
+            _adfGlyphCount = glyphCount;
+        }
+
+        for (uint16_t index = 0; index < glyphCount; ++index) {
+            _adfGlyphBridge[index].bitmapOffset = font->glyph[index].bitmapOffset;
+            _adfGlyphBridge[index].width = font->glyph[index].width;
+            _adfGlyphBridge[index].height = font->glyph[index].height;
+            _adfGlyphBridge[index].xAdvance = font->glyph[index].xAdvance;
+            _adfGlyphBridge[index].xOffset = font->glyph[index].xOffset;
+            _adfGlyphBridge[index].yOffset = font->glyph[index].yOffset;
+        }
+
+        _adfFontBridge = lgfx::GFXfont(
+            const_cast<uint8_t*>(font->bitmap),
+            _adfGlyphBridge,
+            font->first,
+            font->last,
+            font->yAdvance
+        );
+        _currentAdfFont = font;
+        lgfx::LGFX_Device::setFont(&_adfFontBridge);
+    }
+
+    void getTextBounds(const String &txt, int16_t x, int16_t y,
+                                         int16_t *x0, int16_t *y0,
+                                         uint16_t *w, uint16_t *h) {
+        if (w == nullptr || h == nullptr) {
+            return;
+        }
+        if (_currentAdfFont == nullptr || txt.length() == 0) {
+            *w = textWidth(txt);
+            *h = fontHeight();
+            if (x0) *x0 = x;
+            if (y0) *y0 = y - static_cast<int16_t>(*h);
+            return;
+        }
+
+        const float sx = getTextSizeX();
+        const float sy = getTextSizeY();
+
+        int32_t cursorX = x;
+        int32_t cursorY = y;
+        int32_t minX = 0;
+        int32_t minY = 0;
+        int32_t maxX = 0;
+        int32_t maxY = 0;
+        bool hasPixel = false;
+
+        for (size_t i = 0; i < txt.length(); ++i) {
+            char c = txt[i];
+            if (c == '\r') continue;
+            if (c == '\n') {
+                cursorX = x;
+                cursorY += static_cast<int32_t>(_currentAdfFont->yAdvance * sy);
+                continue;
+            }
+            if (c < _currentAdfFont->first || c > _currentAdfFont->last) {
+                continue;
+            }
+
+            const GFXglyph* glyph = &_currentAdfFont->glyph[static_cast<uint16_t>(c) - _currentAdfFont->first];
+            const int32_t gw = static_cast<int32_t>(glyph->width * sx);
+            const int32_t gh = static_cast<int32_t>(glyph->height * sy);
+            const int32_t gx1 = cursorX + static_cast<int32_t>(glyph->xOffset * sx);
+            const int32_t gy1 = cursorY + static_cast<int32_t>(glyph->yOffset * sy);
+
+            if (gw > 0 && gh > 0) {
+                const int32_t gx2 = gx1 + gw - 1;
+                const int32_t gy2 = gy1 + gh - 1;
+                if (!hasPixel) {
+                    minX = gx1; minY = gy1; maxX = gx2; maxY = gy2;
+                    hasPixel = true;
+                } else {
+                    if (gx1 < minX) minX = gx1;
+                    if (gy1 < minY) minY = gy1;
+                    if (gx2 > maxX) maxX = gx2;
+                    if (gy2 > maxY) maxY = gy2;
+                }
+            }
+            cursorX += static_cast<int32_t>(glyph->xAdvance * sx);
+        }
+
+        if (hasPixel) {
+            if (x0) *x0 = static_cast<int16_t>(minX);
+            if (y0) *y0 = static_cast<int16_t>(minY);
+            *w = static_cast<uint16_t>(maxX - minX + 1);
+            *h = static_cast<uint16_t>(maxY - minY + 1);
+        } else {
+            if (x0) *x0 = x;
+            if (y0) *y0 = y;
+            *w = 0;
+            *h = 0;
+        }
+    }
+  // E-Ink interface compatibility
+  void setFullWindow() { /* no-op on TFT */ }
+
+    // Runtime panel offset control for TFT panels
+    void setPanelOffset(int16_t x, int16_t y) {
+            auto cfg = _panel_instance.config();
+            cfg.offset_x = x;
+            cfg.offset_y = y;
+            _panel_instance.config(cfg);
+    }
+
+    void getPanelOffset(int16_t &x, int16_t &y) {
+            auto cfg = _panel_instance.config();
+            x = cfg.offset_x;
+            y = cfg.offset_y;
+    }
+
+private:
+    lgfx::GFXfont _adfFontBridge { nullptr, nullptr, 0, 0, 0 };
+    lgfx::GFXglyph* _adfGlyphBridge = nullptr;
+    uint16_t _adfGlyphCount = 0;
+    const GFXfont* _currentAdfFont = nullptr;
+    #if defined(TFT_320x480_ST7796)
+    lgfx::Panel_ST7796 _panel_instance;
+    #elif defined(TFT_320x480_ILI9488)
+    lgfx::Panel_ILI9488 _panel_instance;
+    #endif
+};
+
+class LGFXCanvas : public lgfx::LGFX_Sprite {
+public:
+    explicit LGFXCanvas(lgfx::LGFX_Device* parent = nullptr) : lgfx::LGFX_Sprite(parent) {}
+
+    using lgfx::LGFX_Sprite::setFont;
+    void setFont(const GFXfont *font) {
+        if (font == nullptr) {
+            _currentAdfFont = nullptr;
+            lgfx::LGFX_Sprite::setFont(nullptr);
+            return;
+        }
+
+        if (font->glyph == nullptr || font->bitmap == nullptr || font->last < font->first) {
+            _currentAdfFont = nullptr;
+            lgfx::LGFX_Sprite::setFont(nullptr);
+            return;
+        }
+
+        const uint16_t glyphCount = static_cast<uint16_t>(font->last - font->first + 1);
+        if (glyphCount == 0) {
+            lgfx::LGFX_Sprite::setFont(nullptr);
+            return;
+        }
+
+        if (_adfGlyphCount != glyphCount || _adfGlyphBridge == nullptr) {
+            if (_adfGlyphBridge != nullptr) {
+                free(_adfGlyphBridge);
+                _adfGlyphBridge = nullptr;
+                _adfGlyphCount = 0;
+            }
+            _adfGlyphBridge = static_cast<lgfx::GFXglyph*>(malloc(sizeof(lgfx::GFXglyph) * glyphCount));
+            if (_adfGlyphBridge == nullptr) {
+                lgfx::LGFX_Sprite::setFont(nullptr);
+                return;
+            }
+            _adfGlyphCount = glyphCount;
+        }
+
+        for (uint16_t index = 0; index < glyphCount; ++index) {
+            _adfGlyphBridge[index].bitmapOffset = font->glyph[index].bitmapOffset;
+            _adfGlyphBridge[index].width = font->glyph[index].width;
+            _adfGlyphBridge[index].height = font->glyph[index].height;
+            _adfGlyphBridge[index].xAdvance = font->glyph[index].xAdvance;
+            _adfGlyphBridge[index].xOffset = font->glyph[index].xOffset;
+            _adfGlyphBridge[index].yOffset = font->glyph[index].yOffset;
+        }
+
+        _adfFontBridge = lgfx::GFXfont(
+            const_cast<uint8_t*>(font->bitmap),
+            _adfGlyphBridge,
+            font->first,
+            font->last,
+            font->yAdvance
+        );
+        _currentAdfFont = font;
+        lgfx::LGFX_Sprite::setFont(&_adfFontBridge);
+    }
+
+    void getTextBounds(const String &txt, int16_t x, int16_t y,
+                       int16_t *x0, int16_t *y0,
+                       uint16_t *w, uint16_t *h) {
+        if (w == nullptr || h == nullptr) {
+            return;
+        }
+        if (_currentAdfFont == nullptr || txt.length() == 0) {
+            *w = textWidth(txt);
+            *h = fontHeight();
+            if (x0) *x0 = x;
+            if (y0) *y0 = y - static_cast<int16_t>(*h);
+            return;
+        }
+
+        const float sx = getTextSizeX();
+        const float sy = getTextSizeY();
+
+        int32_t cursorX = x;
+        int32_t cursorY = y;
+        int32_t minX = 0;
+        int32_t minY = 0;
+        int32_t maxX = 0;
+        int32_t maxY = 0;
+        bool hasPixel = false;
+
+        for (size_t i = 0; i < txt.length(); ++i) {
+            char c = txt[i];
+            if (c == '\r') continue;
+            if (c == '\n') {
+                cursorX = x;
+                cursorY += static_cast<int32_t>(_currentAdfFont->yAdvance * sy);
+                continue;
+            }
+            if (c < _currentAdfFont->first || c > _currentAdfFont->last) {
+                continue;
+            }
+
+            const GFXglyph* glyph = &_currentAdfFont->glyph[static_cast<uint16_t>(c) - _currentAdfFont->first];
+            const int32_t gw = static_cast<int32_t>(glyph->width * sx);
+            const int32_t gh = static_cast<int32_t>(glyph->height * sy);
+            const int32_t gx1 = cursorX + static_cast<int32_t>(glyph->xOffset * sx);
+            const int32_t gy1 = cursorY + static_cast<int32_t>(glyph->yOffset * sy);
+
+            if (gw > 0 && gh > 0) {
+                const int32_t gx2 = gx1 + gw - 1;
+                const int32_t gy2 = gy1 + gh - 1;
+                if (!hasPixel) {
+                    minX = gx1; minY = gy1; maxX = gx2; maxY = gy2;
+                    hasPixel = true;
+                } else {
+                    if (gx1 < minX) minX = gx1;
+                    if (gy1 < minY) minY = gy1;
+                    if (gx2 > maxX) maxX = gx2;
+                    if (gy2 > maxY) maxY = gy2;
+                }
+            }
+            cursorX += static_cast<int32_t>(glyph->xAdvance * sx);
+        }
+
+        if (hasPixel) {
+            if (x0) *x0 = static_cast<int16_t>(minX);
+            if (y0) *y0 = static_cast<int16_t>(minY);
+            *w = static_cast<uint16_t>(maxX - minX + 1);
+            *h = static_cast<uint16_t>(maxY - minY + 1);
+        } else {
+            if (x0) *x0 = x;
+            if (y0) *y0 = y;
+            *w = 0;
+            *h = 0;
+        }
+    }
+
+    void setFullWindow() { /* no-op on TFT */ }
+
+private:
+    lgfx::GFXfont _adfFontBridge { nullptr, nullptr, 0, 0, 0 };
+    lgfx::GFXglyph* _adfGlyphBridge = nullptr;
+    uint16_t _adfGlyphCount = 0;
+    const GFXfont* _currentAdfFont = nullptr;
+};
+
+LGFXCanvas & getdisplay();
+LGFX & getpaneldisplay();
+LGFXCanvas & getscaleddisplay();
+bool initDisplayShadowBuffer();
+bool initDisplayScaleBuffer(uint16_t width, uint16_t height);
+#endif
+
 // Page display return values
 #define PAGE_OK 0          // all ok, do nothing
 #define PAGE_UPDATE 1      // page wants display to update
 #define PAGE_HIBERNATE 2   // page wants displey to hibernate
 
+#ifdef TFT_DISPLAY
+#ifndef OBP_TFT_ENABLE_SCALING
+#define OBP_TFT_ENABLE_SCALING 1
+#endif
+
+#ifndef OBP_TFT_SCALE_ANTIALIAS
+#define OBP_TFT_SCALE_ANTIALIAS 1
+#endif
+
+#if OBP_TFT_SCALE_ANTIALIAS
+inline uint16_t lerpRgb565(uint16_t c0, uint16_t c1, uint16_t w8) {
+    const uint16_t r0 = (c0 >> 11) & 0x1F;
+    const uint16_t g0 = (c0 >> 5)  & 0x3F;
+    const uint16_t b0 = c0 & 0x1F;
+
+    const uint16_t r1 = (c1 >> 11) & 0x1F;
+    const uint16_t g1 = (c1 >> 5)  & 0x3F;
+    const uint16_t b1 = c1 & 0x1F;
+
+    const uint16_t r = static_cast<uint16_t>(r0 + ((static_cast<int32_t>(r1) - r0) * w8 + 128) / 256);
+    const uint16_t g = static_cast<uint16_t>(g0 + ((static_cast<int32_t>(g1) - g0) * w8 + 128) / 256);
+    const uint16_t b = static_cast<uint16_t>(b0 + ((static_cast<int32_t>(b1) - b0) * w8 + 128) / 256);
+
+    return static_cast<uint16_t>((r << 11) | (g << 5) | b);
+}
+
+inline uint16_t sampleBilinearRgb565(LGFXCanvas& src, uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t wx, uint16_t wy) {
+    const uint16_t c00 = src.readPixel(x0, y0);
+    const uint16_t c10 = src.readPixel(x1, y0);
+    const uint16_t c01 = src.readPixel(x0, y1);
+    const uint16_t c11 = src.readPixel(x1, y1);
+
+    const uint16_t top = lerpRgb565(c00, c10, wx);
+    const uint16_t bot = lerpRgb565(c01, c11, wx);
+    return lerpRgb565(top, bot, wy);
+}
+#endif
+#endif
+
+// Draw monochrome bitmap on both E-Ink and TFT displays
+// supports various packing and bit orders; optional runtime conversion for TFT
+inline void drawMonochromeBitmap(
+    int16_t x, int16_t y,
+    const uint8_t *bmp,
+    int16_t w, int16_t h,
+    uint16_t color,
+    bool vertical=false,    // true: bytes run vertically (each byte 8 pixels down)
+    bool lsbFirst=false,    // true: least significant bit = left/top pixel
+    bool mirrorX=false)      // true: bytes run right-to-left within each row
+{
+    #ifdef TFT_DISPLAY
+    // TFT converts per‑pixel
+    int bytesPerRow = (w + 7) / 8;
+    for (int yy = 0; yy < h; yy++) {
+        for (int xx = 0; xx < w; xx++) {
+            int byteIdx;
+            int bitIdx;
+            if (vertical) {
+                // vertical packing: column-major bytes
+                int col = mirrorX ? (w - 1 - xx) : xx;
+                byteIdx = col * ((h + 7) / 8) + (yy / 8);
+                bitIdx  = yy % 8;
+            } else {
+                // horizontal packing: row-major bytes
+                int col = mirrorX ? (w - 1 - xx) : xx;
+                byteIdx = yy * bytesPerRow + (col / 8);
+                bitIdx  = col % 8;
+            }
+            uint8_t b = bmp[byteIdx];
+            bool pix;
+            if (lsbFirst) {
+                pix = b & (1 << bitIdx);
+            } else {
+                pix = b & (1 << (7 - bitIdx));
+            }
+            if (pix) {
+                getdisplay().drawPixel(x + xx, y + yy, color);
+            }
+        }
+        if ((yy & 0x0F) == 0) {
+            yield();
+        }
+    }
+    #else
+    // E‑Paper: just hand over to driver (expects MSB‑first horizontal)
+    getdisplay().drawBitmap(x, y, bmp, w, h, color);
+    #endif
+}
+
+
+// Display wrapper functions for E-Ink/TFT compatibility
+
+// generic bitmap draw that accepts 1‑bit data; TFT version
+// forwards to drawMonochromeBitmap whereas EPD uses native drawBitmap
+inline void displayDrawBitmap(int16_t x, int16_t y,
+                              const uint8_t *bmp,
+                              int16_t w, int16_t h,
+                              uint16_t color) {
+    #ifdef TFT_DISPLAY
+    drawMonochromeBitmap(x, y, bmp, w, h, color);
+    #else
+    getdisplay().drawBitmap(x, y, bmp, w, h, color);
+    #endif
+}
+
+inline void displayFirstPage() {
+    #ifdef TFT_DISPLAY
+    initDisplayShadowBuffer();
+    #else
+    getdisplay().firstPage();
+    #endif
+}
+
+inline void displayNextPage() {
+    #ifdef TFT_DISPLAY
+    if (initDisplayShadowBuffer()) {
+        LGFXCanvas &src = getdisplay();
+        LGFX &dst = getpaneldisplay();
+
+        const uint16_t srcW = GxEPD_WIDTH;
+        const uint16_t srcH = GxEPD_HEIGHT;
+        const uint16_t dstW = static_cast<uint16_t>(dst.width());
+        const uint16_t dstH = static_cast<uint16_t>(dst.height());
+
+        #if !OBP_TFT_ENABLE_SCALING
+        const uint16_t drawX = static_cast<uint16_t>((dstW > srcW) ? ((dstW - srcW) / 2U) : 0U);
+        const uint16_t drawY = static_cast<uint16_t>((dstH > srcH) ? ((dstH - srcH) / 2U) : 0U);
+        src.pushSprite(drawX, drawY);
+        #else
+
+        const uint16_t targetH = (dstH < 320U) ? dstH : 320U;
+        const uint32_t scaledW32 = (static_cast<uint32_t>(srcW) * targetH + (srcH / 2U)) / srcH;
+        const uint16_t targetW = static_cast<uint16_t>((scaledW32 < dstW) ? scaledW32 : dstW);
+
+        const uint16_t drawX = static_cast<uint16_t>((dstW - targetW) / 2U);
+        const uint16_t drawY = static_cast<uint16_t>((dstH - targetH) / 2U);
+
+        const uint16_t borderColor = src.readPixel(0, 0);
+        if (initDisplayScaleBuffer(dstW, dstH)) {
+            LGFXCanvas &scaled = getscaleddisplay();
+            scaled.fillScreen(borderColor);
+
+            for (uint16_t y = 0; y < targetH; ++y) {
+                const uint32_t syfp = (targetH > 1)
+                                        ? (static_cast<uint32_t>(y) * (srcH - 1) * 256U) / (targetH - 1)
+                                        : 0;
+                const uint16_t sy0 = static_cast<uint16_t>(syfp >> 8);
+                const uint16_t sy1 = (sy0 + 1 < srcH) ? static_cast<uint16_t>(sy0 + 1) : sy0;
+                const uint16_t wy  = static_cast<uint16_t>(syfp & 0xFFU);
+
+                for (uint16_t x = 0; x < targetW; ++x) {
+                    const uint32_t sxfp = (targetW > 1)
+                                            ? (static_cast<uint32_t>(x) * (srcW - 1) * 256U) / (targetW - 1)
+                                            : 0;
+                    const uint16_t sx0 = static_cast<uint16_t>(sxfp >> 8);
+                    const uint16_t sx1 = (sx0 + 1 < srcW) ? static_cast<uint16_t>(sx0 + 1) : sx0;
+
+                    #if OBP_TFT_SCALE_ANTIALIAS
+                    const uint16_t wx = static_cast<uint16_t>(sxfp & 0xFFU);
+                    const uint16_t color = sampleBilinearRgb565(src, sx0, sy0, sx1, sy1, wx, wy);
+                    #else
+                    const uint16_t color = src.readPixel(sx0, sy0);
+                    #endif
+
+                    scaled.drawPixel(drawX + x, drawY + y, color);
+                }
+                if ((y & 0x0F) == 0) {
+                    yield();
+                }
+            }
+
+            scaled.pushSprite(0, 0);
+        } else {
+            src.pushSprite(drawX, drawY);
+        }
+        #endif
+    }
+    #else
+    getdisplay().nextPage();
+    #endif
+}
+
+inline void displaySetPartialWindow(uint16_t x, uint16_t y, uint16_t w, uint16_t h) {
+    #ifdef TFT_DISPLAY
+    // TFT LCD doesn't use partial windows
+    (void)x; (void)y; (void)w; (void)h;
+    #else
+    getdisplay().setPartialWindow(x, y, w, h);
+    #endif
+}
+
+inline void displaySetFullWindow() {
+    #ifdef TFT_DISPLAY
+    // TFT LCD doesn't need setFullWindow()
+    #else
+    getdisplay().setFullWindow();
+    #endif
+}
+
+// replacement for getTextBounds that works with both EPD and TFT
+inline void displayGetTextBounds(const String &txt, int16_t x, int16_t y,
+                                 int16_t *x0, int16_t *y0,
+                                 uint16_t *w, uint16_t *h) {
+#ifdef TFT_DISPLAY
+    getdisplay().getTextBounds(txt, x, y, x0, y0, w, h);
+#else
+    getdisplay().getTextBounds(txt, x, y, x0, y0, w, h);
+#endif
+}
+
 void fillPoly4(const std::vector<Point>& p4, uint16_t color);
 void drawPoly(const std::vector<Point>& points, uint16_t color);
 
@@ -128,6 +752,10 @@ void solarGraphic(uint x, uint y, int pcolor, int bcolor);                  // S
 void generatorGraphic(uint x, uint y, int pcolor, int bcolor);              // Generator graphic
 void startLedTask(GwApi *api);
 
+// Display rudder position as horizontal bargraph with configurable +/- range (degrees)
+// 'rangeDeg' is unsigned and will be clamped to [10,45]
+void displayRudderPosition(int rudderPosition, uint8_t rangeDeg, uint16_t cx, uint16_t cy, uint16_t fg, uint16_t bg);
+
 void doImageRequest(GwApi *api, int *pageno, const PageStruct pages[MAX_PAGE_NUMBER], AsyncWebServerRequest *request);
 
 // Icons

lib/obp60task/OBP60Formatter.cpp

@@ -835,7 +835,7 @@ FormattedData formatValue(GwApi::BoatValue *value, CommonData &commondata, bool
         result.cvalue = dplace;
     }
     //########################################################
-    else if (value->getFormat() == "formatXdr:A:D"){
+    else if ((value->getFormat() == "formatXdr:A:D") || ((value->getFormat() == "formatXdr:A:rd"))){
         double angle = 0;
         if (usesimudata == false) {
             angle = value->value;

lib/obp60task/OBP60Hardware.h

@@ -1,7 +1,7 @@
     // General hardware definitions
     // CAN and RS485 bus pin definitions see obp60task.h
 
-#if defined HARDWARE_V20 || HARDWARE_V21
+#if defined BOARD_OBP60S3 || defined BOARD_OBP70S3
     // Direction pin for RS485 NMEA0183
     #define OBP_DIRECTION_PIN 18
     // I2C
@@ -34,13 +34,17 @@
     #define PCF8574_I2C_ADDR1 0x20  // First digital out module
     // FRAM (e.g. MB85RC256V)
     #define FRAM_I2C_ADDR 0x50
-    // SPI (E-Ink display, Extern Bus)
+    // SPI (E-paper display, TFT display Extern Bus)
     #define OBP_SPI_CS 39
     #define OBP_SPI_DC 40
     #define OBP_SPI_RST 41
     #define OBP_SPI_BUSY 42
     #define OBP_SPI_CLK 38
     #define OBP_SPI_DIN 48
+    #define OBP_TFT_OFFSET_X 10   // ST7796, ILI9488 operating x-offset for centered 400x300 content
+    #define OBP_TFT_OFFSET_Y -20  // ST7796, ILI9488 operating y-offset for centered 400x300 content
+    #define TFT_BLACK 0x0109      // Replacement color for black on TFT (RGB565)
+    #define TFT_WHITE 0xFFFF      // Replacement color for white on TFT (RGB565)
     #define SHOW_TIME 6000        // Show time in [ms] for logo and WiFi QR code
     #define FULL_REFRESH_TIME 600 // Refresh cycle time in [s][600...3600] for full display update (very important healcy function)
     #define GxEPD_WIDTH 400       // Display width

lib/obp60task/OBP60Keypad.h

@@ -58,7 +58,7 @@ void initKeys(CommonData &commonData) {
     commonData.keydata[5].h = height;
 }
 
-  #if defined HARDWARE_V20 || HARDWARE_V21
+  #ifdef BOARD_OBP60S3
   // Keypad functions for original OBP60 hardware
   int readKeypad(GwLog* logger, uint thSensitivity, bool use_syspage) {
     

lib/obp60task/OBP60QRWiFi.h

@@ -39,7 +39,7 @@ void qrWiFi(String ssid, String passwd, uint16_t fgcolor, uint16_t bgcolor){
   getdisplay().setTextColor(fgcolor);
   getdisplay().setCursor(140, 285);
   getdisplay().print("WiFi");
-  getdisplay().nextPage();                 // Full Refresh
+  displayNextPage();                 // Full Refresh
 }
 
 #endif

lib/obp60task/OBPDataOperations.cpp

@@ -1,5 +1,4 @@
 #include "OBPDataOperations.h"
-//#include "BoatDataCalibration.h" // Functions lib for data instance calibration
 
 // --- Class CalibrationData ---------------
 CalibrationData::CalibrationData(GwLog* log)
@@ -155,8 +154,7 @@ bool CalibrationData::calibrateInstance(GwApi::BoatValue* boatDataValue)
 
     if (format == "formatWind") { // instance is of type angle
         dataValue = (dataValue * slope) + offset;
-        // dataValue = WindUtils::toPI(dataValue);
+        dataValue = WindUtils::to2PI(dataValue); // wind angle data is stored in [0..2PI] format
-        dataValue = WindUtils::to2PI(dataValue); // we should call <toPI> for format of [-180..180], but pages cannot display negative values properly yet
 
     } else if (format == "formatCourse") { // instance is of type direction
         dataValue = (dataValue * slope) + offset;
@@ -169,7 +167,6 @@ bool CalibrationData::calibrateInstance(GwApi::BoatValue* boatDataValue)
         dataValue = (dataValue * slope) + offset;
     }
 
-
     boatDataValue->value = dataValue; // update boat data value with calibrated value
     calibrationMap[instance].value = dataValue; // store the calibrated value in the list
     calibrationMap[instance].isCalibrated = true;
@@ -247,23 +244,15 @@ void HstryBuf::add(double value)
 
 void HstryBuf::handle(bool useSimuData, CommonData& common)
 {
-    // GwApi::BoatValue* tmpBVal;
     std::unique_ptr<GwApi::BoatValue> tmpBVal; // Temp variable to get formatted and converted data value from OBP60Formatter
 
-    // create temporary boat value for calibration purposes and retrieval of simulation value
-    // tmpBVal = new GwApi::BoatValue(boatDataName.c_str());
-    tmpBVal = std::unique_ptr<GwApi::BoatValue>(new GwApi::BoatValue(boatDataName));
-    tmpBVal->setFormat(boatValue->getFormat());
-    tmpBVal->value = boatValue->value;
-    tmpBVal->valid = boatValue->valid;
-
     if (boatValue->valid) {
-        // Calibrate boat value before adding it to history buffer
-        //calibrationData.calibrateInstance(tmpBVal.get(), logger);
-        //add(tmpBVal->value);
         add(boatValue->value);
-
     } else if (useSimuData) { // add simulated value to history buffer
+        tmpBVal = std::unique_ptr<GwApi::BoatValue>(new GwApi::BoatValue(boatDataName)); // create temporary boat value for retrieval of simulation value
+        tmpBVal->setFormat(boatValue->getFormat());
+        tmpBVal->value = boatValue->value;
+        tmpBVal->valid = boatValue->valid;
         double simSIValue = formatValue(tmpBVal.get(), common).value; // simulated value is generated at <formatValue>; here: retreive SI value
         add(simSIValue);
     } else {
@@ -276,20 +265,7 @@ void HstryBuf::handle(bool useSimuData, CommonData& common)
 HstryBuffers::HstryBuffers(int size, BoatValueList* boatValues, GwLog* log)
     : size(size)
     , boatValueList(boatValues)
-    , logger(log)
+    , logger(log) { };
-{
-
-    // collect boat values for true wind calculation
-    // should all have been already created at true wind object initialization
-    // potentially to be moved to history buffer handling
-    awaBVal = boatValueList->findValueOrCreate("AWA");
-    hdtBVal = boatValueList->findValueOrCreate("HDT");
-    hdmBVal = boatValueList->findValueOrCreate("HDM");
-    varBVal = boatValueList->findValueOrCreate("VAR");
-    cogBVal = boatValueList->findValueOrCreate("COG");
-    sogBVal = boatValueList->findValueOrCreate("SOG");
-    awdBVal = boatValueList->findValueOrCreate("AWD");
-}
 
 // Create history buffer for boat data type
 void HstryBuffers::addBuffer(const String& name)
@@ -301,8 +277,6 @@ void HstryBuffers::addBuffer(const String& name)
         return;
     }
 
-    hstryBuffers[name] = std::unique_ptr<HstryBuf>(new HstryBuf(name, size, boatValueList, logger));
-
     // Initialize metadata for buffer
     String valueFormat = bufferParams[name].format; // Data format of boat data type
     // String valueFormat = boatValueList->findValueOrCreate(name)->getFormat().c_str(); // Unfortunately, format is not yet available during system initialization
@@ -311,6 +285,7 @@ void HstryBuffers::addBuffer(const String& name)
     double bufferMinVal = bufferParams[name].bufferMinVal; // Min value for this history buffer
     double bufferMaxVal = bufferParams[name].bufferMaxVal; // Max value for this history buffer
 
+    hstryBuffers[name] = std::unique_ptr<HstryBuf>(new HstryBuf(name, size, boatValueList, logger));
     hstryBuffers[name]->init(valueFormat, hstryUpdFreq, mltplr, bufferMinVal, bufferMaxVal);
     LOG_DEBUG(GwLog::DEBUG, "HstryBuffers: new buffer added: name: %s, format: %s, multiplier: %d, min value: %.2f, max value: %.2f", name, valueFormat, mltplr, bufferMinVal, bufferMaxVal);
 }
@@ -329,8 +304,9 @@ RingBuffer<uint16_t>* HstryBuffers::getBuffer(const String& name)
     auto it = hstryBuffers.find(name);
     if (it != hstryBuffers.end()) {
         return &it->second->hstryBuf;
+    } else {
+        return nullptr;
     }
-    return nullptr;
 }
 // --- End Class HstryBuffers ---------------
 
@@ -396,56 +372,75 @@ void WindUtils::addPolar(const double* phi1, const double* r1,
     toPol(&x1, &y1, phi, r);
 }
 
-void WindUtils::calcTwdSA(const double* AWA, const double* AWS,
+void WindUtils::calcTwdSA(const double* AWA, const double* AWS, const double* AWD, const double* CTW, const double* STW, const double* HDT,
-    const double* CTW, const double* STW, const double* HDT,
+    double* TWA, double* TWS, double* TWD)
-    double* TWD, double* TWS, double* TWA, double* AWD)
 {
-    *AWD = *AWA + *HDT;
-    *AWD = to2PI(*AWD);
     double stw = -*STW;
     addPolar(AWD, AWS, CTW, &stw, TWD, TWS);
 
-    // Normalize TWD to [0..360°] (2PI) and TWA to [-180..180] (PI)
+    // Normalize to [0..2PI]
     *TWD = to2PI(*TWD);
-    *TWA = toPI(*TWD - *HDT);
+    *TWA = to2PI(*TWD - *HDT); // for internal storage we normalize wind angle to [0..2PI], as well
 }
 
-double WindUtils::calcHDT(const double* hdmVal, const double* varVal, const double* cogVal, const double* sogVal)
+// calculate HDT from either HDM + VAR, HDM only, or COG
+bool WindUtils::calcHDT(const double* hdmVal, const double* varVal, const double* cogVal, const double* sogVal, double* hdtVal)
 {
-    double hdt;
-    double minSogVal = 0.1; // SOG below this value (m/s) is assumed to be  data noise from GPS sensor
-
-    if (*hdmVal != DBL_MAX) {
-        hdt = *hdmVal + (*varVal != DBL_MAX ? *varVal : 0.0); // Use corrected HDM if HDT is not available (or just HDM if VAR is not available)
-        hdt = to2PI(hdt);
-    } else if (*cogVal != DBL_MAX && *sogVal >= minSogVal) {
-        hdt = *cogVal; // Use COG as fallback if HDT and HDM are not available, and SOG is not data noise
-    } else {
-        hdt = DBL_MAX; // Cannot calculate HDT without valid HDM or HDM+VAR or COG
-    }
-
-    return hdt;
-}
-
-bool WindUtils::calcWinds(const double* awaVal, const double* awsVal,
-    const double* cogVal, const double* stwVal, const double* sogVal, const double* hdtVal,
-    const double* hdmVal, const double* varVal, double* twdVal, double* twsVal, double* twaVal, double* awdVal)
-{
-    double stw, hdt, ctw;
-    double twd, tws, twa, awd;
     double minSogVal = 0.1; // SOG below this value (m/s) is assumed to be  data noise from GPS sensor
 
     if (*hdtVal != DBL_MAX) {
-        hdt = *hdtVal; // Use HDT if available
+        // HDT already available-> nothing to do
+        return true;
+    }
+
+    if (*hdmVal != DBL_MAX) {
+        *hdtVal = *hdmVal + (*varVal != DBL_MAX ? *varVal : 0.0); // Use corrected HDM if HDT is not available (or just HDM if VAR is not available)
+        *hdtVal = to2PI(*hdtVal);
+    } else if (*cogVal != DBL_MAX && *sogVal >= minSogVal) {
+        *hdtVal = *cogVal; // Use COG as fallback if HDT and HDM are not available, and SOG is not data noise
     } else {
-        hdt = calcHDT(hdmVal, varVal, cogVal, sogVal);
+        *hdtVal = DBL_MAX; // Cannot calculate HDT without valid HDM or HDM+VAR or COG
+        return false;
+    }
+    // LOG_DEBUG(GwLog::DEBUG, "WindUtils:calcHDT: HDT: %.1f, HDM %.1f, VAR %.1f, COG %.1f, SOG %.1f", *hdtVal * RAD_TO_DEG, *hdmVal * RAD_TO_DEG, *varVal * RAD_TO_DEG,
+    //      *cogVal * RAD_TO_DEG, *sogVal * 3.6 / 1.852);
+
+    return true;
+}
+
+// calculate wind direction (either TWD or AWD) from wind angle (TWA or AWA) and HDT
+bool WindUtils::calcWD(const double* waVal, const double* hdtVal, double* wdVal)
+{
+    if (*waVal != DBL_MAX && *hdtVal != DBL_MAX) {
+        *wdVal = *waVal + *hdtVal;
+        *wdVal = to2PI(*wdVal);
+    } else {
+        *wdVal = DBL_MAX; // Cannot calculate wind direction WD without valid wind angle WA and HDT
+        return false;
+    }
+
+    return true;
+}
+
+// calculate full set of true winds (TWA, TWS, TWD) apparent winds and more data
+bool WindUtils::calcTrueWinds(const double* awaVal, const double* awsVal, const double* awd,
+    const double* cogVal, const double* stwVal, const double* sogVal, const double* hdtVal,
+    double* twaVal, double* twsVal, double* twdVal)
+{
+    double stw, ctw;
+    double twd, tws, twa;
+    double minSogVal = 0.1; // SOG below this value (m/s) is assumed to be  data noise from GPS sensor
+
+    if ((*awaVal == DBL_MAX) || (*awsVal == DBL_MAX)) {
+        // Cannot calculate true winds at all without valid AWA, AWS
+        return false;
     }
 
     if (*cogVal != DBL_MAX && *sogVal >= minSogVal) { // if SOG is data noise, we don't trust COG
 
         ctw = *cogVal; // Use COG for CTW if available
     } else {
-        ctw = hdt; // 2nd approximation for CTW; hdt must exist if we reach this part of the code
+        ctw = *hdtVal; // 2nd approximation for CTW; HDT must exist if we reach this part of code
     }
 
     if (*stwVal != DBL_MAX) {
@@ -456,28 +451,21 @@ bool WindUtils::calcWinds(const double* awaVal, const double* awsVal,
         // If STW and SOG are not available, we cannot calculate true wind
         return false;
     }
-    // LOG_DEBUG(GwLog::DEBUG, "WindUtils:calcWinds: HDT: %.1f, CTW %.1f, STW %.1f", hdt, ctw, stw);
+    // LOG_DEBUG(GwLog::DEBUG, "WindUtils:calcTrueWinds: HDT: %.1f, CTW %.1f, STW %.1f", *hdtVal * RAD_TO_DEG, ctw * RAD_TO_DEG, stw * 3.6 / 1.852);
 
-    if ((*awaVal == DBL_MAX) || (*awsVal == DBL_MAX)) {
+    calcTwdSA(awaVal, awsVal, awd, &ctw, &stw, hdtVal, &twa, &tws, &twd);
-        // Cannot calculate true wind without valid AWA, AWS; other checks are done earlier
+    *twaVal = twa;
-        return false;
+    *twsVal = tws;
-    } else {
+    *twdVal = twd;
-        calcTwdSA(awaVal, awsVal, &ctw, &stw, &hdt, &twd, &tws, &twa, &awd);
-        *twdVal = twd;
-        *twsVal = tws;
-        *twaVal = twa;
-        *awdVal = awd;
 
-        return true;
+    return true;
-    }
 }
 
 // Calculate true wind data and add to obp60task boat data list
-bool WindUtils::addWinds()
+bool WindUtils::handleWinds(bool calcWinds)
 {
-    double twd, tws, twa, awd, hdt;
+    double twd, tws, twa, awd;
     bool twCalculated = false;
-    bool awdCalculated = false;
 
     double awaVal = awaBVal->valid ? awaBVal->value : DBL_MAX;
     double awsVal = awsBVal->valid ? awsBVal->value : DBL_MAX;
@@ -487,48 +475,61 @@ bool WindUtils::addWinds()
     double hdtVal = hdtBVal->valid ? hdtBVal->value : DBL_MAX;
     double hdmVal = hdmBVal->valid ? hdmBVal->value : DBL_MAX;
     double varVal = varBVal->valid ? varBVal->value : DBL_MAX;
-    //LOG_DEBUG(GwLog::DEBUG, "WindUtils:addWinds: AWA %.1f, AWS %.1f, COG %.1f, STW %.1f, SOG %.2f, HDT %.1f, HDM %.1f, VAR %.1f", awaBVal->value * RAD_TO_DEG, awsBVal->value * 3.6 / 1.852,
+    double twaVal = twaBVal->valid ? twaBVal->value : DBL_MAX;
-    //     cogBVal->value * RAD_TO_DEG, stwBVal->value * 3.6 / 1.852, sogBVal->value * 3.6 / 1.852, hdtBVal->value * RAD_TO_DEG, hdmBVal->value * RAD_TO_DEG, varBVal->value * RAD_TO_DEG);
+    double twsVal = twsBVal->valid ? twsBVal->value : DBL_MAX;
+    // LOG_DEBUG(GwLog::DEBUG, "WindUtils:handleWinds: AWA %.1f, AWS %.1f, AWD %.1f, COG %.1f, STW %.1f, SOG %.2f, HDT %.1f, HDM %.1f, VAR %.1f", awaVal * RAD_TO_DEG, awsVal * 3.6 / 1.852,
+    //     awd * RAD_TO_DEG, cogVal * RAD_TO_DEG, stwVal * 3.6 / 1.852, sogVal * 3.6 / 1.852, hdtVal * RAD_TO_DEG, hdmVal * RAD_TO_DEG, varVal * RAD_TO_DEG);
 
-    // Check if TWD can be calculated from TWA and HDT/HDM
+    if (calcHDT(&hdmVal, &varVal, &cogVal, &sogVal, &hdtVal)) {
-    if (twaBVal->valid) {
+        hdtBVal->value = hdtVal;
-        if (!twdBVal->valid) {
+        hdtBVal->valid = true;
-            if (hdtVal != DBL_MAX) {
+    } else {
-                hdt = hdtVal; // Use HDT if available
+        // determination of HDT was not possible due to missing prerequisite data
-            } else {
+        hdtBVal->valid = false;
-                hdt = calcHDT(&hdmVal, &varVal, &cogVal, &sogVal);
+        return false;
-            }
+    }
-            twd = twaBVal->value + hdt;
+
-            twd = to2PI(twd);
+    // calculate AWD if not existing and if possible
+    if (!awdBVal->valid) {
+        if (calcWD(&awaVal, &hdtVal, &awd)) {
+            awdBVal->value = awd;
+            awdBVal->valid = true;
+        } else {
+            awdBVal->valid = false;
+            return false;
+        }
+    }
+
+    // calculate TWD if not existing and if possible
+    if (!twdBVal->valid) {
+        // calculate TWD if it does not exist yet and TWA is available
+        if (calcWD(&twaVal, &hdtVal, &twd)) {
             twdBVal->value = twd;
             twdBVal->valid = true;
+        } else {
+            twdBVal->valid = false;
         }
+    }
 
-    } else {
+    if (calcWinds && (!twaBVal->valid || !twsBVal->valid || !twdBVal->valid)) {
-        // Calculate true winds and AWD; if true winds exist, use at least AWD calculation
+        // calculate true winds if user setting and at least one of three true wind values does not exist
-        twCalculated = calcWinds(&awaVal, &awsVal, &cogVal, &stwVal, &sogVal, &hdtVal, &hdmVal, &varVal, &twd, &tws, &twa, &awd);
+        twCalculated = calcTrueWinds(&awaVal, &awsVal, &awd, &cogVal, &stwVal, &sogVal, &hdtVal, &twa, &tws, &twd);
-
         if (twCalculated) { // Replace values only, if successfully calculated and not already available
-            if (!twdBVal->valid) {
+            if (!twaBVal->valid) {
-                twdBVal->value = twd;
+                twaBVal->value = twa;
-                twdBVal->valid = true;
+                twaBVal->valid = true;
             }
             if (!twsBVal->valid) {
                 twsBVal->value = tws;
                 twsBVal->valid = true;
             }
-            if (!twaBVal->valid) {
+            if (!twdBVal->valid) {
-                //twaBVal->value = twa;
+                twdBVal->value = twd;
-                twaBVal->value = to2PI(twa); // convert to [0..360], because pages cannot display negative values properly yet
+                twdBVal->valid = true;
-                twaBVal->valid = true;
-            }
-            if (!awdBVal->valid) {
-                awdBVal->value = awd;
-                awdBVal->valid = true;
             }
         }
     }
-    // LOG_DEBUG(GwLog::DEBUG, "WindUtils:addWinds: twCalculated %d, TWD %.1f, TWA %.1f, TWS %.2f kn, AWD: %.1f", twCalculated, twdBVal->value * RAD_TO_DEG,
+    // LOG_DEBUG(GwLog::DEBUG, "WindUtils:handleWinds: twCalculated %d, TWD %.1f, TWA %.1f, TWS %.2f kn, AWD: %.1f", twCalculated, twdBVal->value * RAD_TO_DEG,
     //     twaBVal->value * RAD_TO_DEG, twsBVal->value * 3.6 / 1.852, awdBVal->value * RAD_TO_DEG);
 
     return twCalculated;

lib/obp60task/OBPDataOperations.h

@@ -19,7 +19,7 @@ private:
     } tCalibrationData;
 
     std::unordered_map<std::string, tCalibrationData> calibrationMap; // list of calibration data instances
-    std::unordered_map<std::string, double> lastValue; // array for last smoothed values of boat data values
+    std::unordered_map<std::string, double> lastValue; // array for last smoothed value of boat data values
     GwLog* logger;
 
     static constexpr int8_t MAX_CALIBRATION_DATA = 4; // maximum number of calibration data instances
@@ -32,6 +32,7 @@ public:
     bool smoothInstance(GwApi::BoatValue* boatDataValue); // Smooth single boat data value
 };
 
+// Class for a single history buffer of boat values
 class HstryBuf {
 private:
     RingBuffer<uint16_t> hstryBuf; // Circular buffer to store history values
@@ -50,13 +51,13 @@ public:
     void handle(bool useSimuData, CommonData& common);
 };
 
+// Manage list of history buffers for supported boat data; used by boat data charts
 class HstryBuffers {
 private:
     std::map<String, std::unique_ptr<HstryBuf>> hstryBuffers;
     int size; // size of all history buffers
     BoatValueList* boatValueList;
     GwLog* logger;
-    GwApi::BoatValue *awaBVal, *hdtBVal, *hdmBVal, *varBVal, *cogBVal, *sogBVal, *awdBVal; // boat values for true wind calculation
 
     struct HistoryParams {
         int hstryUpdFreq; // update frequency of history buffer (documentation only)
@@ -97,7 +98,8 @@ public:
 class WindUtils {
 private:
     GwApi::BoatValue *twaBVal, *twsBVal, *twdBVal;
-    GwApi::BoatValue *awaBVal, *awsBVal, *awdBVal, *cogBVal, *stwBVal, *sogBVal, *hdtBVal, *hdmBVal, *varBVal;
+    GwApi::BoatValue *awaBVal, *awsBVal, *awdBVal;
+    GwApi::BoatValue *cogBVal, *stwBVal, *sogBVal, *hdtBVal, *hdmBVal, *varBVal;
     static constexpr double DBL_MAX = std::numeric_limits<double>::max();
     GwLog* logger;
 
@@ -128,12 +130,12 @@ public:
     void addPolar(const double* phi1, const double* r1,
         const double* phi2, const double* r2,
         double* phi, double* r);
-    void calcTwdSA(const double* AWA, const double* AWS,
+    void calcTwdSA(const double* AWA, const double* AWS, const double* AWD, const double* CTW, const double* STW, const double* HDT,
-        const double* CTW, const double* STW, const double* HDT,
+        double* TWA, double* TWS, double* TWD);
-        double* TWD, double* TWS, double* TWA, double* AWD);
+    bool calcHDT(const double* hdmVal, const double* varVal, const double* cogVal, const double* sogVal, double* hdtVal);
-    static double calcHDT(const double* hdmVal, const double* varVal, const double* cogVal, const double* sogVal);
+    bool calcWD(const double* waVal, const double* hdtVal, double* wdVal);
-    bool calcWinds(const double* awaVal, const double* awsVal,
+    bool calcTrueWinds(const double* awaVal, const double* awsVal, const double* awd,
         const double* cogVal, const double* stwVal, const double* sogVal, const double* hdtVal,
-        const double* hdmVal, const double* varVal, double* twdVal, double* twsVal, double* twaVal, double* awdVal);
+        double* twdVal, double* twsVal, double* twaVal);
-    bool addWinds();
+    bool handleWinds(bool calcWinds);
 };

lib/obp60task/OBPSensorTask.cpp

@@ -66,8 +66,8 @@ void sensorTask(void *param){
     const int avgsize = 300;
     constexpr int arrayBatV{avgsize};
     constexpr int arrayBatC{avgsize};
-    movingAvg batV(arrayBatV);
+    movingAvg<int> batV(arrayBatV);
-    movingAvg batC(arrayBatC);
+    movingAvg<int> batC(arrayBatC);
     batV.begin();
     batC.begin();
 
@@ -371,7 +371,7 @@ void sensorTask(void *param){
     GwApi::BoatValue *hdop=new GwApi::BoatValue(GwBoatData::_HDOP);
     GwApi::BoatValue *valueList[]={gpsdays, gpsseconds, hdop};
 
-    // Internal RTC with NTP init
+    // Internal iRTC with NTP init
     ESP32Time rtc(0);
     if (api->getConfig()->getString(api->getConfig()->timeSource) == "iRTC") {
         GwApi::Status status;
@@ -432,17 +432,17 @@ void sensorTask(void *param){
 
         iRTC  RTC  GPS N2K
           0    0    0  (1)
-          0    0   (1) (X)
+          0    0   (1)  X 
-          0   (1)   0  (X)
+          0   (1)   0   X 
-          0    1 <-(1) (X)
+          0    1 <-(1)  X 
-         (1)   0    0  (X)
+         (1)   0    0   X 
-          1    0   (1) (X)
+          1    0   (1)  X 
-          1 ->(1)   0  (X)
+          1 ->(1)   0   X 
-          1    1 <-(1) (X)
+          1    1 <-(1)  X 
 
         */
 
-        // If RTC DS1388 ready, then copy iRTC and GPS data to RTC all 1min
+        // If RTC DS1388 ready, then copy iRTC and GPS data to RTC all 1 min
         if(millis() > starttime11 + 1*60*1000){
             starttime11 = millis();
             // Set RTC chip via iRTC (NTP)
@@ -524,7 +524,7 @@ void sensorTask(void *param){
                     // N2K sysTime is double in n2klib
                     double sysTime = (dt.hour() * 3600) + (dt.minute() * 60) + dt.second();
                     if(!isnan(daysAt1970) && !isnan(sysTime)){
-                        //api->getLogger()->logDebug(GwLog::LOG,"RTC time: %04d/%02d/%02d %02d:%02d:%02d",sensors.rtcTime.tm_year+1900,sensors.rtcTime.tm_mon, sensors.rtcTime.tm_mday, sensors.rtcTime.tm_hour, sensors.rtcTime.tm_min, sensors.rtcTime.tm_sec);
+                        //api->getLogger()->logDebug(GwLog::LOG,"RTC time: %04d/%02d/%02d %02d:%02d:%02d",sensors.rtcTime.tm_year+1900,sensors.rtcTime.tm_mon+1, sensors.rtcTime.tm_mday, sensors.rtcTime.tm_hour, sensors.rtcTime.tm_min, sensors.rtcTime.tm_sec);
                         //api->getLogger()->logDebug(GwLog::LOG,"Send PGN126992: %10d %10d",daysAt1970, (uint16_t)sysTime);
                         SetN2kPGN126992(N2kMsg,0,daysAt1970,sysTime,N2ktimes_LocalCrystalClock);
                         api->sendN2kMessage(N2kMsg);
@@ -533,25 +533,26 @@ void sensorTask(void *param){
             }
             // Send date and time from software RTC (iRTC)
             if (iRTC_ready == true && RTC_ready == false && GPS_ready == false) {
-                // Use internal RTC feature
+                sensors.rtcTime = rtc.getTimeStruct();
-                sensors.rtcTime = rtc.getTimeStruct(); // Save software RTC values in SensorData
+
-                // TODO implement daysAt1970 and sysTime as methods of DateTime
                 const short daysOfYear[12] = {0,31,59,90,120,151,181,212,243,273,304,334};
-                uint16_t switchYear = ((sensors.rtcTime.tm_year-1)-1968)/4 - ((sensors.rtcTime.tm_year-1)-1900)/100 + ((sensors.rtcTime.tm_year-1)-1600)/400;
+                int year  = sensors.rtcTime.tm_year + 1900;
-                long daysAt1970 = (sensors.rtcTime.tm_year-1970)*365 + switchYear + daysOfYear[sensors.rtcTime.tm_mon-1] + sensors.rtcTime.tm_mday-1;
+                int month = sensors.rtcTime.tm_mon;
-                // If switch year then add one day
+                int day   = sensors.rtcTime.tm_mday;
-                if ((sensors.rtcTime.tm_mon > 2) && (sensors.rtcTime.tm_year % 4 == 0  && (sensors.rtcTime.tm_year % 100 != 0 || sensors.rtcTime.tm_year % 400 == 0))) {
+                uint16_t switchYear = ((year - 1) - 1968) / 4 - ((year - 1) - 1900) / 100 + ((year - 1) - 1600) / 400;
+                long daysAt1970 = (year - 1970) * 365L + switchYear + daysOfYear[month] + day - 1;
+
+                // Leap day add if date is after Feb (i.e. month >= March)
+                if (month >= 2 && (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0))) {
                     daysAt1970 += 1;
                 }
-                // N2K sysTime is double in n2klib
+                double sysTime = sensors.rtcTime.tm_hour * 3600.0 + sensors.rtcTime.tm_min  * 60.0 + sensors.rtcTime.tm_sec;
-                double sysTime = (sensors.rtcTime.tm_hour * 3600) + (sensors.rtcTime.tm_min * 60) + sensors.rtcTime.tm_sec;
+                //api->getLogger()->logDebug(GwLog::LOG, "iRTC time: %04d/%02d/%02d %02d:%02d:%02d", year, month + 1, day, sensors.rtcTime.tm_hour, sensors.rtcTime.tm_min, sensors.rtcTime.tm_sec);
-                if(!isnan(daysAt1970) && !isnan(sysTime)){
+                //api->getLogger()->logDebug(GwLog::LOG,"Send PGN126992: %10d %10d",daysAt1970, (uint16_t)sysTime);
-                    //api->getLogger()->logDebug(GwLog::LOG,"RTC time: %04d/%02d/%02d %02d:%02d:%02d",sensors.rtcTime.tm_year+1900,sensors.rtcTime.tm_mon, sensors.rtcTime.tm_mday, sensors.rtcTime.tm_hour, sensors.rtcTime.tm_min, sensors.rtcTime.tm_sec);
+                SetN2kPGN126992(N2kMsg, 0, daysAt1970, sysTime, N2ktimes_LocalCrystalClock);
-                    //api->getLogger()->logDebug(GwLog::LOG,"Send PGN126992: %10d %10d",daysAt1970, (uint16_t)sysTime);
+                api->sendN2kMessage(N2kMsg);
-                    SetN2kPGN126992(N2kMsg,0,daysAt1970,sysTime,N2ktimes_LocalCrystalClock);
-                    api->sendN2kMessage(N2kMsg);
-                }
             }
+
         }
 
         // Send 1Wire data for all temperature sensors to N2K all 2s

lib/obp60task/OBPcharts.cpp

@@ -6,9 +6,9 @@
 std::map<String, ChartProps> Chart::dfltChrtDta = {
     { "formatWind", { 60.0 * DEG_TO_RAD, 10.0 * DEG_TO_RAD } }, // default course range 60 degrees
     { "formatCourse", { 60.0 * DEG_TO_RAD, 10.0 * DEG_TO_RAD } }, // default course range 60 degrees
-    { "formatKnots", { 7.71, 2.56 } }, // default speed range in m/s
+    { "formatKnots", { 2.57, 2.57 } }, // default speed range in m/s
-    { "formatDepth", { 15.0, 5.0 } }, // default depth range in m
+    { "formatDepth", { 10.0, 5.0 } }, // default depth range in m
-    { "kelvinToC", { 30.0, 5.0 } } // default temp range in °C/K
+    { "kelvinToC", { 20.0, 5.0 } } // default temp range in °C/K
 };
 
 // --- Class Chart ---------------
@@ -28,14 +28,25 @@ Chart::Chart(RingBuffer<uint16_t>& dataBuf, double dfltRng, CommonData& common,
     fgColor = commonData->fgcolor;
     bgColor = commonData->bgcolor;
 
-    dWidth = getdisplay().width();
+    // display dimensions (avoid calling width()/height() on incomplete LGFX type)
-    dHeight = getdisplay().height();
+    #ifdef TFT_DISPLAY
+        dWidth = 480;
+        dHeight = 320;
+    #else
+        dWidth = getdisplay().width();
+        dHeight = getdisplay().height();
+    #endif
 
     dataBuf.getMetaData(dbName, dbFormat);
     dbMIN_VAL = dataBuf.getMinVal();
     dbMAX_VAL = dataBuf.getMaxVal();
     bufSize = dataBuf.getCapacity();
 
+    smoothCharts = common.config->getBool(common.config->smoothCharts);
+    if (smoothCharts) {
+        chrtAvg.begin();
+    }
+
     // Initialize chart data format; shorter version of standard format indicator
     if (dbFormat == "formatCourse" || dbFormat == "formatWind" || dbFormat == "formatRot") {
         chrtDataFmt = WIND; // Chart is showing data of course / wind <degree> format
@@ -331,6 +342,23 @@ void Chart::drawChartLines(const char direction, const int8_t chrtIntv, const do
     double chrtVal; // Current data value
     Pos point, prevPoint; // current and previous chart point
 
+    if (smoothCharts) {
+        // prime moving average filter to ensure the first plotted point is already averaged
+
+        chrtAvg.reset();
+
+        // Feed the filter the 10 values preceding bufStart
+        for (int p = 10; p > 0; p--) {
+            // Calculate index with wrapping: (start - offset + size) % size
+            int primeIdx = (bufStart - (p * chrtIntv));
+            double primeVal = dataBuf.get(primeIdx);
+            
+            if (primeVal != dbMAX_VAL) {
+                chrtAvg.reading(primeVal);
+            }
+        }
+    }
+
     for (int i = 0; i < (numBufVals / chrtIntv); i++) {
 
         chrtVal = dataBuf.get(bufStart + (i * chrtIntv)); // show the latest wind values in buffer; keep 1st value constant in a rolling buffer
@@ -339,6 +367,11 @@ void Chart::drawChartLines(const char direction, const int8_t chrtIntv, const do
             chrtPrevVal = dbMAX_VAL;
         } else {
 
+            if (smoothCharts) {
+                // if chart lines shall be smoothed, apply moving average filter of the last 10 values
+                chrtVal = chrtAvg.reading(chrtVal);
+            }
+
             point = setCurrentChartPoint(i, direction, chrtVal, chrtScale);
 
             // if (i >= (numBufVals / chrtIntv) - 5) // log chart data of 1 line (adjust for test purposes)
@@ -393,7 +426,7 @@ void Chart::drawChartLines(const char direction, const int8_t chrtIntv, const do
 
             if (chrtDataFmt == WIND) { // degree of course or wind
                 recalcRngMid = true;
-                LOG_DEBUG(GwLog::DEBUG, "PageWindPlot: chart end: timAxis: %d, i: %d, bufStart: %d, numBufVals: %d, recalcRngCntr: %d", timAxis, i, bufStart, numBufVals, recalcRngMid);
+                // LOG_DEBUG(GwLog::DEBUG, "PageWindPlot: chart end: timAxis: %d, i: %d, bufStart: %d, numBufVals: %d, recalcRngCntr: %d", timAxis, i, bufStart, numBufVals, recalcRngMid);
             }
             break;
         }
@@ -434,46 +467,48 @@ Pos Chart::setCurrentChartPoint(const int i, const char direction, const double
 // chart time axis label + lines
 void Chart::drawChrtTimeAxis(const char chrtDir, const int8_t chrtSz, const int8_t chrtIntv)
 {
-    float axSlots, intv, i;
+    int axSlots, intv, i, timeRng;
     char sTime[6];
-    int timeRng = chrtIntv * 4; // chart time interval: [1] 4 min., [2] 8 min., [3] 12 min., [4] 16 min., [8] 32 min.
+    int tOffset;
 
     getdisplay().setFont(&Ubuntu_Bold8pt8b);
     getdisplay().setTextColor(fgColor);
 
-    axSlots = 5; // number of axis labels
+    intv = 60; // print axis label each 60 pixels = seconds
-    intv = timAxis / (axSlots - 1); // minutes per chart axis interval (interval is 1 less than axSlots)
+    axSlots = timAxis / intv; // number of axis labels; value will be truncated to full number
-    i = timeRng; // Chart axis label start at -32, -16, -12, ... minutes
 
     if (chrtDir == HORIZONTAL) {
         getdisplay().fillRect(0, cRoot.y, dWidth, 2, fgColor);
 
-        for (float j = 0; j < timAxis - 1; j += intv) { // fill time axis with values but keep area free on right hand side for value label
+        i = axSlots * chrtIntv * -1; // current minute label
+        // LOG_DEBUG(GwLog::DEBUG, "Chart::drawChrtTimeAxis: intv: %d, axSlots: %d, timAxis: %d, chrtIntv: %d", intv, axSlots, timAxis, chrtIntv);
+        for (int j = intv; j < timAxis - 1; j += intv) { // fill time axis with values but keep area free on right hand side for value label
 
             // draw text with appropriate offset
-            int tOffset = j == 0 ? 13 : -4;
+            tOffset = j == 0 ? 13 : -4;
-            snprintf(sTime, sizeof(sTime), "-%.0f", i);
+            snprintf(sTime, sizeof(sTime), "%d", i);
             drawTextCenter(cRoot.x + j + tOffset, cRoot.y - 8, sTime);
             getdisplay().drawLine(cRoot.x + j, cRoot.y, cRoot.x + j, cRoot.y + 5, fgColor); // draw short vertical time mark
 
-            i -= chrtIntv;
+            i += chrtIntv;
         }
 
     } else { // vertical chart
 
+        i = chrtIntv * -1; // current minute label
         for (float j = intv; j < timAxis - 1; j += intv) { // don't print time label at upper and lower end of time axis
 
-            i -= chrtIntv; // we start not at top chart position
+            snprintf(sTime, sizeof(sTime), "%d", i);
-            snprintf(sTime, sizeof(sTime), "-%.0f", i);
             getdisplay().drawLine(cRoot.x, cRoot.y + j, cRoot.x + valAxis, cRoot.y + j, fgColor); // Grid line
 
             if (chrtSz == FULL_SIZE) { // full size chart
                 getdisplay().fillRect(0, cRoot.y + j - 9, 32, 15, bgColor); // clear small area to remove potential chart lines
                 getdisplay().setCursor((4 - strlen(sTime)) * 7, cRoot.y + j + 3); // time value; print left screen; value right-formated
-                getdisplay().printf("%s", sTime); // Range value
+                getdisplay().printf("%s", sTime); // time value
             } else if (chrtSz == HALF_SIZE_RIGHT) { // half size chart; right side
                 drawTextCenter(dWidth / 2, cRoot.y + j, sTime); // time value; print mid screen
             }
+            i -= chrtIntv;
         }
     }
 }
@@ -491,11 +526,11 @@ void Chart::drawChrtValAxis(const char chrtDir, const int8_t chrtSz, bool prntNa
 
         if (chrtSz == FULL_SIZE) {
 
+            // print buffer data name on left hand side of time axis (max. size 5 characters)
             font = &Ubuntu_Bold12pt8b;
-
-            // print buffer data name on right hand side of time axis (max. size 5 characters)
             getdisplay().setFont(font);
-            drawTextRalign(cRoot.x + timAxis, cRoot.y - 3, dbName.substring(0, 5));
+            getdisplay().fillRect(cRoot.x + timAxis - 57, cRoot.y + 2, 58, 20, bgColor); // clear small area to remove potential chart lines
+            drawTextRalign(cRoot.x + timAxis, cRoot.y + 19, dbName.substring(0, 5));
 
             if (chrtDataFmt == WIND) {
                 prntHorizChartThreeValueAxisLabel(font);
@@ -509,11 +544,11 @@ void Chart::drawChrtValAxis(const char chrtDir, const int8_t chrtSz, bool prntNa
         } else { // half size chart -> just print edge values + middle chart line
 
             font = &Ubuntu_Bold10pt8b;
-
             if (prntName) {
                 // print buffer data name on right hand side of time axis (max. size 5 characters)
                 getdisplay().setFont(font);
-                drawTextRalign(cRoot.x + timAxis, cRoot.y - 3, dbName.substring(0, 5));
+                getdisplay().fillRect(cRoot.x + timAxis - 57, cRoot.y + 2, 58, 20, bgColor); // clear small area to remove potential chart lines
+                drawTextRalign(cRoot.x + timAxis, cRoot.y + 16, dbName.substring(0, 5));
             }
 
             prntHorizChartThreeValueAxisLabel(font);

lib/obp60task/OBPcharts.h

@@ -2,6 +2,7 @@
 #pragma once
 #include "Pagedata.h"
 #include "OBP60Extensions.h"
+#include "movingAvg.h"
 
 struct Pos {
     int x;
@@ -44,12 +45,11 @@ protected:
     static constexpr bool NO_SIMUDATA = true; // switch off simulation feature of <formatValue> function
 
     RingBuffer<uint16_t>& dataBuf; // Buffer to display
-    //char chrtDir; // Chart timeline direction: 'H' = horizontal, 'V' = vertical
-    //int8_t chrtSz; // Chart size: [0] = full size, [1] = half size left/top, [2] half size right/bottom
     double dfltRng; // Default range of chart, e.g. 30 = [0..30]
     uint16_t fgColor; // color code for any screen writing
     uint16_t bgColor; // color code for screen background
     bool useSimuData; // flag to indicate if simulation data is active
+    bool smoothCharts; // flag to indicate if charts shall be printed with smoothed gradient
     String tempFormat; // user defined format for temperature
     double zeroValue; // "0" SI value for temperature
 
@@ -84,6 +84,7 @@ protected:
     bool bufDataValid = false; // Flag to indicate if buffer data is valid
     int oldChrtIntv = 0; // remember recent user selection of data interval
 
+    movingAvg<double> chrtAvg{7}; // Store average of the last 7 chart values if chart gradient shall be smoothed
     double chrtPrevVal; // Last data value in chart area
     int x, y; // x and y coordinates for drawing
     int prevX, prevY; // Last x and y coordinates for drawing

lib/obp60task/PageAnchor.cpp

@@ -1,771 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-#if defined BOARD_OBP60S3 || defined BOARD_OBP40S3
-
-/*
-  This page is in experimental stage so be warned!
-  North is up.
-  Anchor page with background map from mapservice
-
-  Boatdata used
-    DBS - Water depth
-    HDT - Boat heading, true
-    AWS - Wind strength; Boat not moving so we assume AWS=TWS and AWD=TWD
-    AWD - Wind direction
-    LAT/LON - Boat position, current
-    HDOP - Position error, horizontal
-
-   Raise function in device OBP40 has to be done inside config mode
-   because of limited number of buttons.
-
-  TODO 
-    gzip for data transfer,
-       miniz.c from ROM?
-       manually inflating with tinflate from ROM
-    Save position in FRAM
-    Alarm: gps fix lost
-    switch unit feet/meter
-    force map update if new position is different from old position by 
-    a certain level (e.g. 10m)
-    windlass integration
-    chain counter
-
-    Map service options / URL parameters
-      - mandatory
-          lat: latitude
-          lon: longitude
-          width: image width in px (400)
-          height: image height in px (300)
-      - optional
-          zoom: zoom level, default 15
-          mrot: map rotation angle in degrees
-          mtype: map type, default="Open Street Map"
-          dtype: dithering type, default="Atkinson"
-          cutout: image cutout type 0=none
-          alpha: alpha blending for cutout
-          tab: tab size, 0=none
-          border: border line zize in px, default 2
-          symbol: synmol number, default=2 triangle
-          srot: symbol rotation in degrees
-          ssize: symbol size in px, default=15
-          grid: show map grid
-
-*/
-
-#include <WiFi.h>
-#include <HTTPClient.h>
-#include "Pagedata.h"
-#include "OBP60Extensions.h"
-#include "ConfigMenu.h"
-// #include "miniz.h" // devices without PSRAM use <rom/miniz.h>
-
-// extern "C" {
-  #include "rom/miniz.h"
-// }
-
-#define anchor_width 16
-#define anchor_height 16
-static unsigned char anchor_bits[] PROGMEM = {
-   0x80, 0x01, 0x40, 0x02, 0x40, 0x02, 0x80, 0x01, 0xf0, 0x0f, 0x80, 0x01,
-   0x80, 0x01, 0x88, 0x11, 0x8c, 0x31, 0x8e, 0x71, 0x84, 0x21, 0x86, 0x61,
-   0x86, 0x61, 0xfc, 0x3f, 0xf8, 0x1f, 0x80, 0x01 };
-
-class PageAnchor : public Page
-{
-private:
-    char mode = 'N'; // (N)ormal, (C)onfig
-    int8_t editmode = -1; // marker for menu/edit/set function
-    ConfigMenu *menu;
-
-    //uint8_t *mapbuf = new uint8_t[10000]; // 8450 Byte without header
-    //int mapbuf_size = 10000;
-    //uint8_t *mapbuf = (uint8_t*) heap_caps_malloc(mapbuf_size, MALLOC_CAP_SPIRAM);
-    GFXcanvas1 *canvas;
-    const uint16_t map_width = 264;
-    const uint16_t map_height = 260;
-    bool map_valid = false;
-    char map_service = 'R'; // (O)BP Service, (L)ocal Service, (R)emote Service
-    double map_lat = 0; // current center of valid map
-    double map_lon = 0;
-    String server_name; // server with map service
-    uint16_t server_port = 80;
-    String tile_path;
-
-    String lengthformat;
-
-    double scale = 50; // Radius of display circle in meter, depends on lat
-    uint8_t zoom = 15; // map zoom level
-
-    bool alarm = false;
-    bool alarm_enabled = false;
-    uint8_t alarm_range;
-
-    uint8_t chain_length;
-    uint8_t chain = 0;
-
-    bool anchor_set = false;
-    double anchor_lat;
-    double anchor_lon;
-    double anchor_depth;
-    int anchor_ts; // time stamp anchor dropped
-
-    GwApi::BoatValue *bv_dbs; // depth below surface
-    GwApi::BoatValue *bv_hdt; // true heading
-    GwApi::BoatValue *bv_aws; // apparent wind speed
-    GwApi::BoatValue *bv_awd; // apparent wind direction
-    GwApi::BoatValue *bv_lat; // latitude, current
-    GwApi::BoatValue *bv_lon; // longitude, current
-    GwApi::BoatValue *bv_hdop; // horizontal position error
-
-    bool simulation = false;
-    int last_mapsize = 0;
-    String errmsg = "";
-    int loops;
-    int readbytes = 0;
-
-    void displayModeNormal(PageData &pageData) {
-
-        // get currrent boatvalues
-        bv_dbs = pageData.values[0]; // DBS
-        String sval_dbs = formatValue(bv_dbs, *commonData).svalue;
-        String sunit_dbs = formatValue(bv_dbs, *commonData).unit; 
-        bv_hdt = pageData.values[1]; // HDT
-        String sval_hdt = formatValue(bv_hdt, *commonData).svalue;
-        bv_aws = pageData.values[2]; // AWS
-        String sval_aws = formatValue(bv_aws, *commonData).svalue;
-        String sunit_aws = formatValue(bv_aws, *commonData).unit; 
-        bv_awd = pageData.values[3]; // AWD
-        String sval_awd = formatValue(bv_awd, *commonData).svalue;
-        bv_lat = pageData.values[4]; // LAT
-        String sval_lat = formatValue(bv_lat, *commonData).svalue;
-        bv_lon = pageData.values[5]; // LON
-        String sval_lon = formatValue(bv_lon, *commonData).svalue;
-        bv_hdop = pageData.values[6]; // HDOP
-        String sval_hdop = formatValue(bv_hdop, *commonData).svalue;
-        String sunit_hdop = formatValue(bv_hdop, *commonData).unit; 
-
-        commonData->logger->logDebug(GwLog::DEBUG, "Drawing at PageAnchor; DBS=%f, HDT=%f, AWS=%f", bv_dbs->value, bv_hdt->value, bv_aws->value);
-
-        // Draw canvas with background map
-        // rhumb(map_lat, map_lon, bv_lat->value, bv_lon->value)
-        int posdiff = 0;
-        if (map_valid) {
-            if (bv_lat->valid and bv_lon->valid) {
-                // calculate movement since last map refresh
-                posdiff = rhumb(map_lat, map_lon, bv_lat->value, bv_lon->value);
-                if (posdiff > 25) {
-                    map_lat = bv_lat->value;
-                    map_lon = bv_lon->value;
-                    map_valid = getBackgroundMap(map_lat, map_lon, zoom);
-                    if (map_valid) {
-                        // prepare visible space for anchor-symbol or boat
-                        canvas->fillCircle(132, 130, 12, commonData->fgcolor);
-                    }
-                }
-            }
-            getdisplay().drawBitmap(68, 20, canvas->getBuffer(), map_width, map_height, commonData->fgcolor);
-        }
-
-        Point c = {200, 150}; // center = anchor position
-        uint16_t r = 125;
-
-        // Circle as map border
-        getdisplay().drawCircle(c.x, c.y, r, commonData->fgcolor);
-        getdisplay().drawCircle(c.x, c.y, r + 1, commonData->fgcolor);
-
-        Point b = {200, 180}; // boat position while dropping anchor
-
-        const std::vector<Point> pts_boat = { // polygon lines
-            {b.x - 5, b.y},
-            {b.x - 5, b.y - 10},
-            {b.x, b.y - 16},
-            {b.x + 5, b.y - 10},
-            {b.x + 5, b.y}
-        };
-        //rotatePoints then draw lines
-        // TODO rotate boat according to current heading
-        if (bv_hdt->valid) {
-            if (map_valid) {
-                Point b1 = rotatePoint(c, {b.x, b.y - 8}, bv_hdt->value * RAD_TO_DEG);
-                getdisplay().fillCircle(b1.x, b1.y, 10, commonData->bgcolor);
-            }
-            drawPoly(rotatePoints(c, pts_boat, bv_hdt->value * RAD_TO_DEG), commonData->fgcolor);
-        } else {
-            // no heading available: draw north oriented
-            if (map_valid) {
-                getdisplay().fillCircle(b.x, b.y - 8, 10, commonData->bgcolor);
-            }
-            drawPoly(pts_boat, commonData->fgcolor);
-        }
-
-        // Draw wind arrow
-        const std::vector<Point> pts_wind = {
-            {c.x, c.y - r + 25},
-            {c.x - 12, c.y - r - 4},
-            {c.x, c.y - r + 6},
-            {c.x + 12, c.y - r - 4}
-        };
-        if (bv_awd->valid) {
-            fillPoly4(rotatePoints(c, pts_wind, bv_awd->value), commonData->fgcolor);
-        }
-
-        // Title and corner value headings
-        getdisplay().setTextColor(commonData->fgcolor);
-        getdisplay().setFont(&Ubuntu_Bold10pt8b);
-        // Left
-        getdisplay().setCursor(8, 36);
-        getdisplay().print("Anchor");
-        getdisplay().setCursor(8, 210);
-        getdisplay().print("Depth");
-        // Right
-        drawTextRalign(392, 80, "Chain");
-        drawTextRalign(392, 210, "Wind");
-
-        // Units
-        getdisplay().setCursor(8, 272);
-        getdisplay().print(sunit_dbs);
-        drawTextRalign(392, 272, sunit_aws);
-        // drawTextRalign(392, 100, lengthformat); // chain unit not implemented
-
-        // Corner values
-        getdisplay().setFont(&Ubuntu_Bold8pt8b);
-        getdisplay().setCursor(8, 54);
-        getdisplay().print(anchor_set ? "Dropped" : "Ready"); // Anchor state
-        getdisplay().setCursor(8, 72);
-        getdisplay().print("Alarm: "); // Alarm state
-        getdisplay().print(alarm_enabled ? "on" : "off");
-
-        getdisplay().setCursor(8, 120);
-        getdisplay().print("Zoom");
-        getdisplay().setCursor(8, 136);
-        getdisplay().print(zoom);
-
-        getdisplay().setCursor(8, 160);
-        getdisplay().print("diff");
-        getdisplay().setCursor(8, 176);
-        if (map_valid and bv_lat->valid and bv_lon->valid) {
-            getdisplay().print(String(posdiff));
-        } else {
-            getdisplay().print("n/a");
-        }
-
-        // Chain out TODO lengthformat ft/m
-        drawTextRalign(392, 96, String(chain) + " m");
-        drawTextRalign(392, 96+16, "of " + String(chain_length) + " m");
-
-        getdisplay().setFont(&DSEG7Classic_BoldItalic16pt7b);
-
-        // Depth
-        getdisplay().setCursor(8, 250);
-        getdisplay().print(sval_dbs);
-
-        // Wind
-        getdisplay().setCursor(320, 250);
-        getdisplay().print(sval_aws);
-
-        // Position of boat in center of map
-        getdisplay().setFont(&IBM8x8px);
-        drawTextRalign(392, 34, sval_lat);
-        drawTextRalign(392, 44, sval_lon);
-        // quality
-        String hdop = "HDOP: ";
-        if (bv_hdop->valid) {
-            hdop += String(round(bv_hdop->value));
-        } else {
-            hdop += " n/a";
-        }
-        drawTextRalign(392, 54, hdop);
-
-        // zoom scale
-        getdisplay().drawLine(c.x + 10, c.y, c.x + r - 4, c.y, commonData->fgcolor);
-        // arrow left
-        getdisplay().drawLine(c.x + 10, c.y, c.x + 16, c.y - 4, commonData->fgcolor);
-        getdisplay().drawLine(c.x + 10, c.y, c.x + 16, c.y + 4, commonData->fgcolor);
-        // arrow right
-        getdisplay().drawLine(c.x + r - 4, c.y, c.x + r - 10, c.y - 4, commonData->fgcolor);
-        getdisplay().drawLine(c.x + r - 4, c.y, c.x + r - 10, c.y + 4, commonData->fgcolor);
-        getdisplay().setFont(&Ubuntu_Bold8pt8b);
-        drawTextCenter(c.x + r / 2, c.y + 8, String(scale, 0) + "m");
-
-        // draw anchor symbol (as bitmap)
-        getdisplay().drawXBitmap(c.x - anchor_width / 2, c.y - anchor_height / 2,
-            anchor_bits, anchor_width, anchor_height, commonData->fgcolor);
-
-    }
-
-    void displayModeConfig(PageData &pageData) {
-
-        getdisplay().setTextColor(commonData->fgcolor);
-        getdisplay().setFont(&Ubuntu_Bold12pt8b);
-        getdisplay().setCursor(8, 48);
-        getdisplay().print("Anchor configuration");
-
-        getdisplay().setFont(&Ubuntu_Bold8pt8b);
-
-        getdisplay().setCursor(8, 260);
-        getdisplay().print("Press BACK to leave config");
-
-/*        getdisplay().setCursor(8, 68);
-        getdisplay().printf("Server: %s", server_name.c_str());
-        getdisplay().setCursor(8, 88);
-        getdisplay().printf("Port: %d", server_port);
-        getdisplay().setCursor(8, 108);
-        getdisplay().printf("Tilepath: %s", tile_path.c_str());
-        getdisplay().setCursor(8, 128);
-        getdisplay().printf("Last mapsize: %d", last_mapsize);
-        getdisplay().setCursor(8, 148);
-        getdisplay().printf("Last error: %s", errmsg);
-        getdisplay().setCursor(8, 168);
-        getdisplay().printf("Loops: %d, Readbytes: %d", loops, readbytes);
-        */
-
-        GwApi::BoatValue *bv_lat = pageData.values[4]; // LAT
-        GwApi::BoatValue *bv_lon = pageData.values[5]; // LON
-        if (!bv_lat->valid or !bv_lon->valid) {
-            getdisplay().setCursor(8, 228);
-            getdisplay().printf("No valid position: background map disabled");
-        }
-
-        // Display menu
-        getdisplay().setFont(&Ubuntu_Bold8pt8b);
-        for (int i = 0 ; i < menu->getItemCount(); i++) {
-            ConfigMenuItem *itm = menu->getItemByIndex(i);
-            if (!itm) {
-               commonData->logger->logDebug(GwLog::ERROR, "Menu item not found: %d", i);
-            } else {
-                Rect r = menu->getItemRect(i);
-                bool inverted = (i == menu->getActiveIndex());
-                drawTextBoxed(r, itm->getLabel(), commonData->fgcolor, commonData->bgcolor, inverted, false);
-                if (inverted and editmode > 0) {
-                    // triangle as edit marker
-                    getdisplay().fillTriangle(r.x + r.w + 20, r.y, r.x + r.w + 30, r.y + r.h / 2, r.x + r.w + 20, r.y + r.h,  commonData->fgcolor);
-                }
-                getdisplay().setCursor(r.x + r.w + 40, r.y + r.h - 4);
-                if (itm->getType() == "int") {
-                    getdisplay().print(itm->getValue());
-                    getdisplay().print(itm->getUnit());
-                } else {
-                     getdisplay().print(itm->getValue() == 0 ? "No" : "Yes");
-                }
-            }
-        }
-
-    }
-
-public:
-    PageAnchor(CommonData &common) 
-    {
-        commonData = &common;
-        common.logger->logDebug(GwLog::LOG,"Instantiate PageAnchor");
-
-        String mapsource = common.config->getString(common.config->mapsource);
-        if (mapsource == "Local Service") {
-            map_service = 'L';
-            server_name = common.config->getString(common.config->ipAddress);
-            server_port = common.config->getInt(common.config->localPort);
-            tile_path = "";
-        } else if (mapsource == "Remote Service") {
-            map_service = 'R';
-            server_name = common.config->getString(common.config->mapServer);
-            tile_path = common.config->getString(common.config->mapTilePath);
-        } else { // OBP Service or undefined
-            map_service = 'O';
-            server_name = "norbert-walter.dnshome.de";
-            tile_path = "";
-        }
-        zoom = common.config->getInt(common.config->zoomlevel);
-
-        lengthformat = common.config->getString(common.config->lengthFormat);
-        chain_length = common.config->getInt(common.config->chainLength);
-
-        if (simulation) {
-            map_lat = 53.56938345759218;
-            map_lon = 9.679658234303275;
-        }
-
-        canvas = new GFXcanvas1(264, 260); // Byte aligned, no padding!
-
-        // Initialize config menu
-        menu = new ConfigMenu("Options", 40, 80);
-        menu->setItemDimension(150, 20);
-        ConfigMenuItem *newitem;
-        newitem = menu->addItem("chain", "Chain out", "int", 0, "m");
-        newitem->setRange(0, 200, {1, 2, 5, 10});
-        newitem = menu->addItem("alarm", "Alarm", "bool", 0, "");
-        newitem = menu->addItem("alarm", "Alarm range", "int", 50, "m");
-        newitem->setRange(0, 200, {1, 2, 5, 10});
-        newitem = menu->addItem("raise", "Raise Anchor", "bool", 0, "");
-        newitem = menu->addItem("zoom", "Zoom", "int", 15, "");
-        newitem->setRange(14, 17, {1});
-        menu->setItemActive("chain");
-
-    }
-
-    void setupKeys(){
-        Page::setupKeys();
-        commonData->keydata[0].label = "CFG";
-#ifdef BOARD_OBP40S3
-        commonData->keydata[1].label = "DROP";
-#endif
-#ifdef BOARD_OBP60S3
-        commonData->keydata[4].label = "DROP";
-#endif
-    }
-
-    // TODO OBP40 / OBP60 different handling
-    int handleKey(int key) {
-        commonData->logger->logDebug(GwLog::LOG, "Page Anchor handle key %d", key);
-        if (key == 1) { // Switch between normal and config mode
-            if (mode == 'N') {
-                mode = 'C';
-#ifdef BOARD_OBP40S3
-                commonData->keydata[0].label = "BACK";
-                commonData->keydata[1].label = "EDIT";
-#endif
-            } else {
-                mode = 'N';
-#ifdef BOARD_OBP40S3
-                commonData->keydata[0].label = "CFG";
-                commonData->keydata[1].label = anchor_set ? "RAISE": "DROP";
-#endif
-#ifdef BOARD_OBP60S3
-                commonData->keydata[4].label = anchor_set ? "RAISE": "DROP";
-#endif
-            }
-            return 0;
-        }
-        if (key == 2) {
-            if (mode == 'N') {
-                anchor_set = !anchor_set;
-                commonData->keydata[1].label = anchor_set ? "ALARM": "DROP";
-                if (anchor_set) {
-                    anchor_lat = bv_lat->value;
-                    anchor_lon =  bv_lon->value;
-                    anchor_depth = bv_dbs->value;
-                    // TODO set timestamp
-                    // anchor_ts =
-                }
-                return 0;
-            } else if (mode == 'C') {
-                // Change edit mode
-                if (editmode > 0) {
-                    editmode = 0;
-                    commonData->keydata[1].label = "EDIT";
-                } else {
-                    editmode = 1;
-                    commonData->keydata[1].label = "OK";
-                }
-            }
-        }
-        if (key == 9) {
-            // OBP40 Down
-            if (mode == 'C') {
-                if (editmode > 0) {
-                    // decrease current menu item
-                     menu->getActiveItem()->decValue();
-                } else {
-                    // move to next menu item
-                     menu->goNext();
-                }
-                return 0;
-            }
-        }
-        if (key == 10) {
-            // OBP40 Up
-            if (mode == 'C') {
-                if (editmode > 0) {
-                    // increase current menu item
-                     ConfigMenuItem *itm = menu->getActiveItem();                    
-                     commonData->logger->logDebug(GwLog::LOG, "step = %d", itm->getStep());
-                     itm->incValue();
-                } else {
-                    // move to previous menu item
-                     menu->goPrev();
-                }
-                return 0;
-            }
-        }
-        // Code for keylock
-        if (key == 11) {
-            commonData->keylock = !commonData->keylock;
-            return 0;
-        }
-        return key;
-    }
-
-    int rhumb(double lat1, double lon1, double lat2, double lon2) {
-        // calc distance in m between two geo points
-        static const double degToRad = M_PI / 180.0;
-        lat1 = degToRad * lat1;
-        lon1 = degToRad * lon1;
-        lat2 = degToRad * lat2;
-        lon2 = degToRad * lon2;
-        double dlon = lon2 - lon1;
-        double dlat = lat2 - lat1;
-        double mlat = (lat1 + lat2) / 2;
-        return (int) (6371000 * sqrt(pow(dlat, 2) + pow(cos(mlat) * dlon, 2)));
-    }
-
-    bool getBackgroundMap(double lat, double lon, uint8_t zoom) {
-        // HTTP-Request for map
-        // TODO über pagedata -> status abfragen?
-        if (WiFi.status() != WL_CONNECTED) {
-            return false;
-        }
-        bool valid = false;
-        HTTPClient http;
-        const char* headerKeys[] = { "Content-Encoding", "Content-Length" };
-        http.collectHeaders(headerKeys, 2);
-        String url = "http://" + server_name + "/" + tile_path;
-        String parameter = "?lat=" + String(lat, 6) + "&lon=" + String(lon, 6)+ "&zoom=" + String(zoom)
-                         + "&width=" + String(map_width) + "&height=" + String(map_height);
-        commonData->logger->logDebug(GwLog::LOG, "HTTP query: %s", String(url + parameter).c_str());
-        http.begin(url + parameter);
-        http.addHeader("Accept-Encoding", "deflate");
-        int httpCode = http.GET();
-        if (httpCode > 0) {
-            commonData->logger->logDebug(GwLog::LOG, "HTTP GET result code: %d", httpCode);
-            if (httpCode == HTTP_CODE_OK) {
-                WiFiClient* stream = http.getStreamPtr();
-                int size = http.getSize();
-                String encoding = http.header("Content-Encoding");
-                commonData->logger->logDebug(GwLog::LOG, "HTTP size: %d, encoding: '%s'", size, encoding);
-                bool is_gzip = encoding.equalsIgnoreCase("deflate");
-
-                uint8_t header[14]; // max: P4<LF>wwww wwww<LF>
-                int header_size = 0;
-                bool header_read = false;
-                int n = 0;
-                int ix = 0;
-
-                uint8_t* buf = canvas->getBuffer();
-
-                if (is_gzip) {
-                    /* gzip compressed data
-                     * has to be decompressed into a buffer big enough 
-                     * to hold the whole data.
-                     * so the PBM header is included
-                     * search a method to use that as canvas without
-                     * additional copy 
-                     */
-                    commonData->logger->logDebug(GwLog::LOG, "Map received in gzip encoding");
-
-                    #define HEADER_MAX 24
-                    #define HTTP_CHUNK 512
-                    uint8_t in_buf[HTTP_CHUNK];
-                    uint8_t header_buf[HEADER_MAX];
-                    tinfl_decompressor decomp;
-                    tinfl_init(&decomp);
-                    size_t bitmap_written = 0;
-                    size_t header_written = 0;
-                    bool header_done = false;
-                    int row_bytes = 0;
-                    size_t expected_bitmap = 0;
-
-                    while (stream->connected() || stream->available()) {
-                        int bytes_read = stream->read(in_buf, HTTP_CHUNK);
-                        if (bytes_read <= 0) break;
-commonData->logger->logDebug(GwLog::LOG, "stream: bytes_read=%d", bytes_read);
-                        size_t in_ofs = 0; // offset
-                        while (in_ofs < (size_t)bytes_read) {
-                            size_t in_size = bytes_read - in_ofs;
-                            size_t out_size;
-                            uint8_t *out_ptr;
-                            uint8_t *out_ptr_next;
-                            if (!header_done) {
-                                if (header_written >= HEADER_MAX) {
-                                    commonData->logger->logDebug(GwLog::LOG, "PBM header too large");
-                                    return false;
-                                }
-                                out_ptr = header_buf + header_written;
-                                out_size = HEADER_MAX - header_written;
-                            } else {
-                                out_ptr = buf + bitmap_written;
-                                out_size = expected_bitmap - bitmap_written;
-                            }
-commonData->logger->logDebug(GwLog::LOG, "in_size=%d, out_size=%d", in_size, out_size);
- // TODO correct loop !!!
- // tinfl_status tinfl_decompress(
- // tinfl_decompressor *r,
- // const mz_uint8 *pIn_buf_next,
- // size_t *pIn_buf_size,
- // mz_uint8 *pOut_buf_start
- // mz_uint8 *pOut_buf_next,
- // size_t *pOut_buf_size,
- // const mz_uint32 decomp_flags)
-                            tinfl_status status = tinfl_decompress(
-                                &decomp,
-                                in_buf + in_ofs, // start address in input buffer
-                                &in_size,        // number of bytes to process
-                                out_ptr,         // start of output buffer
-                                out_ptr,         // next write position in output buffer
-                                &out_size,       // free size in output buffer
-                                // TINFL_FLAG_PARSE_ZLIB_HEADER |
-                                TINFL_FLAG_HAS_MORE_INPUT |
-                                TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF
-                            );
-                            if (status < 0) {
-                                commonData->logger->logDebug(GwLog::LOG, "Decompression error (%d)", status);
-                                return false;
-                            }
-                            in_ofs += in_size;
-                            commonData->logger->logDebug(GwLog::LOG, "in_size=%d, in_ofs=%d", in_size, in_ofs);
-
-                            if (!header_done) {
-                                commonData->logger->logDebug(GwLog::LOG, "Decoding header");
-                                header_written += out_size;
-
-                                // Detect header end: two '\n'
-                                char *first_nl = strchr((char*)header_buf, '\n');
-                                if (!first_nl) continue;
-
-                                char *second_nl = strchr(first_nl + 1, '\n');
-                                if (!second_nl) continue;
-
-                                // Null-terminate header for sscanf
-                                header_buf[header_written < HEADER_MAX ? header_written : HEADER_MAX - 1] = 0;
-
-                                // Check magic
-                                if (strncmp((char*)header_buf, "P4", 2) != 0) {
-                                    commonData->logger->logDebug(GwLog::LOG, "Invalid PBM magic");
-                                    return false;
-                                }
-
-                                // Parse width and height strictly
-                                int header_width = 0, header_height = 0;
-                                if (sscanf((char*)header_buf, "P4\n%d %d", &header_width, &header_height) != 2) {
-                                    commonData->logger->logDebug(GwLog::LOG, "Failed to parse PBM dimensions");
-                                    return false;
-                                }
-
-                                if (header_width != map_width || header_height != map_height) {
-                                    commonData->logger->logDebug(GwLog::LOG, "PBM size mismatch: header %dx%d, requested %dx%d\n",
-                                        header_width, header_height, map_width, map_height);
-                                    return false;
-                                }
-                                commonData->logger->logDebug(GwLog::LOG, "Header: %dx%d", header_width, header_height);
-
-                                // Compute row bytes and expected bitmap size
-                                row_bytes = (header_width + 7) / 8;
-                                commonData->logger->logDebug(GwLog::LOG, "row_bytes=%d", row_bytes);
-                                expected_bitmap = (size_t)row_bytes * header_height;
-                                commonData->logger->logDebug(GwLog::LOG, "expected_bitmap=%d", expected_bitmap);
-
-                                // Copy any extra decompressed bitmap after header
-                                size_t header_size = (second_nl + 1) - (char*)header_buf;
-                                commonData->logger->logDebug(GwLog::LOG, "header_size=%d", header_size);
-                                size_t extra_bitmap = header_written - header_size;
-                                commonData->logger->logDebug(GwLog::LOG, "extra bitmap=%d", extra_bitmap);
-
-                                header_done = true;
-
-                                if (extra_bitmap > 0) {
-                                    memcpy(buf, header_buf + header_size, extra_bitmap);
-                                    bitmap_written = extra_bitmap;
-                                }
-                            } else {
-                                bitmap_written += out_size;
-                                if (bitmap_written >= expected_bitmap) {
-                                    commonData->logger->logDebug(GwLog::LOG, "Image fully received");
-                                }
-                            }
-                            commonData->logger->logDebug(GwLog::LOG, "bitmap_written=%d", bitmap_written);
-                        }
-                    }
-                } else {
-                    // uncompressed data
-                    commonData->logger->logDebug(GwLog::LOG, "Map received uncompressed");
-                    while (stream->available()) {
-                        uint8_t b = stream->read();
-                        n += 1;
-                        if ((! header_read) and (n < 13) ) {
-                            header[n-1] = b;
-                            if ((n > 3) and (b == 0x0a)) {
-                                header_read = true;
-                                header_size = n;
-                                header[n] = 0;
-                            }
-                        } else {
-                            // write image data to canvas buffer
-                            buf[ix++] = b;
-                        }
-                    }
-                    if (n == size) {
-                        valid = true;
-                    }
-                }
-                commonData->logger->logDebug(GwLog::LOG, "HTTP: final bytesRead=%d, header-size=%d", n, header_size);
-            } else {
-                commonData->logger->logDebug(GwLog::LOG, "HTTP result #%d", httpCode);
-            }
-        } else {
-            commonData->logger->logDebug(GwLog::ERROR, "HTTP error #%d", httpCode);
-        }
-        http.end();
-        return valid;
-    }
-
-    void displayNew(PageData &pageData){
-
-        GwApi::BoatValue *bv_lat = pageData.values[4]; // LAT
-        GwApi::BoatValue *bv_lon = pageData.values[5]; // LON
-
-        // check if valid data available
-        if (!bv_lat->valid or !bv_lon->valid) {
-            map_valid = false;
-            return;
-        }
-
-        errmsg = "";
-
-        map_lat = bv_lat->value; // save for later comparison
-        map_lon = bv_lon->value;
-        map_valid = getBackgroundMap(map_lat, map_lon, zoom);
-
-        if (map_valid) {
-            // prepare visible space for anchor-symbol or boat
-            canvas->fillCircle(132, 130, 10, commonData->fgcolor);
-        }
-    };
-
-    void display_side_keys() {
-        // An rechter Seite neben dem Rad inc, dec, set etc ?
-    }
-
-    int displayPage(PageData &pageData) {
-
-        // Logging boat values
-        commonData->logger->logDebug(GwLog::LOG, "Drawing at PageAnchor; Mode=%c", mode);
-
-        // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
-
-       if (mode == 'N') {
-           displayModeNormal(pageData);
-       } else if (mode == 'C') {
-           displayModeConfig(pageData);
-       }
-
-        return PAGE_UPDATE;
-    };
-};
-
-static Page *createPage(CommonData &common){
-    return new PageAnchor(common);
-}
-
-/**
- * with the code below we make this page known to the PageTask
- * we give it a type (name) that can be selected in the config
- * we define which function is to be called
- * and we provide the number of user parameters we expect
- * this will be number of BoatValue pointers in pageData.values
- */
-PageDescription registerPageAnchor(
-    "Anchor",   // Page name
-    createPage, // Action
-    0,          // Number of bus values depends on selection in Web configuration
-    {"DBS", "HDT", "AWS", "AWD", "LAT", "LON", "HDOP"}, // Names of bus values undepends on selection in Web configuration (refer GwBoatData.h)
-    true        // Show display header on/off
-);
-
-#endif

lib/obp60task/PageAutopilot.cpp

@@ -5,8 +5,9 @@
 
 // These constants have to match the declaration below in :
 //  PageDescription registerPageAutopilot(
-//  {"HDM","HDT", "COG", "STW", "SOG", "DBT","XTE", "DTW", "BTW"}, // Bus values we need in the page
+//  {"HDM","HDT", "COG", "STW", "SOG", "DBT","XTE", "DTW", "BTW", "RPOS", "ROT"}, // Bus values we need in the page
-const int HowManyValues = 9;
+
+const int HowManyValues = 11;
 
 const int AverageValues = 4;
 
@@ -19,10 +20,13 @@ const int ShowDBT = 5;
 const int ShowXTE = 6;
 const int ShowDTW = 7;
 const int ShowBTW = 8;
+const int ShowRPOS = 9;
+const int ShowROT = 10;
 
 const int Compass_X0 = 200;         // X center point of compass band
-const int Compass_Y0 = 220;         // Y position of compass lines
+const int Compass_Y0 = 90;          // Y position of compass lines
-const int Compass_LineLength = 22;  // Length of compass lines
+//const int Compass_LineLength = 22;  // Length of compass lines
+const int Compass_LineLength = 15;  // Length of compass lines
 const float Compass_LineDelta = 8.0;// Compass band: 1deg = 5 Pixels, 10deg = 50 Pixels 
 
 class PageAutopilot : public Page
@@ -38,8 +42,11 @@ class PageAutopilot : public Page
 
     virtual void setupKeys(){
         Page::setupKeys();
-        commonData->keydata[0].label = "CMP";
+        commonData->keydata[0].label = "-10";
-        commonData->keydata[1].label = "SRC";
+        commonData->keydata[1].label = "-1";
+        commonData->keydata[2].label = "Auto";
+        commonData->keydata[3].label = "+1";
+        commonData->keydata[4].label = "+10";
    }
     
     virtual int handleKey(int key){
@@ -69,8 +76,8 @@ class PageAutopilot : public Page
         GwLog *logger = commonData->logger;
     
         // Old values for hold function
-        static String OldDataText[HowManyValues] = {"", "", "","", "", "","", "", ""};
+        static String OldDataText[HowManyValues] = {"", "", "", "", "", "","", "", "", "", ""};
-        static String OldDataUnits[HowManyValues] = {"", "", "","", "", "","", "", ""};
+        static String OldDataUnits[HowManyValues] = {"", "", "", "", "", "","", "", "", "", ""};
 
         // Get config data
         String lengthformat = config->getString(config->lengthFormat);
@@ -107,14 +114,12 @@ class PageAutopilot : public Page
             setFlashLED(false); 
         }
         
-        if (bvalue == NULL) return PAGE_OK; // WTF why this statement?
-        
         //***********************************************************
 
         // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
         getdisplay().setTextColor(commonData->fgcolor);
-
+/*
         // Horizontal line 2 pix top & bottom
         // Print data on top half
         getdisplay().fillRect(0, 130, 400, 2, commonData->fgcolor); 
@@ -138,7 +143,7 @@ class PageAutopilot : public Page
             OldDataText[WhichDataDisplay] = DataText[WhichDataDisplay];         // Save the old value
             OldDataUnits[WhichDataDisplay] = DataUnits[WhichDataDisplay];       // Save the old unit
         }
-
+*/
         // Now draw compass band                
         // Get the data
         double TheAngle = DataValue[WhichDataCompass];
@@ -152,13 +157,13 @@ class PageAutopilot : public Page
         buffer[0]=0;              
 
         getdisplay().setFont(&Ubuntu_Bold16pt8b);
-        getdisplay().setCursor(10, Compass_Y0-60);
+        getdisplay().setCursor(10, Compass_Y0-40);
         getdisplay().print(DataName[WhichDataCompass]);                         // Page name
      
-     
         // Draw compass base line and pointer
         getdisplay().fillRect(0, Compass_Y0, 400, 3, commonData->fgcolor);            
-        getdisplay().fillTriangle(Compass_X0,Compass_Y0-40,Compass_X0-10,Compass_Y0-80,Compass_X0+10,Compass_Y0-80,commonData->fgcolor);
+        //getdisplay().fillTriangle(Compass_X0,Compass_Y0-40,Compass_X0-10,Compass_Y0-80,Compass_X0+10,Compass_Y0-80,commonData->fgcolor);
+        getdisplay().fillTriangle(Compass_X0,Compass_Y0-30,Compass_X0-10,Compass_Y0-60,Compass_X0+10,Compass_Y0-60,commonData->fgcolor);
         // Draw trendlines
         for ( int i = 1; i < abs(TheTrend) / 2; i++){
             int x1;
@@ -238,6 +243,8 @@ class PageAutopilot : public Page
         // if ( x_test > 390)
         //     x_test = 320;
 
+        displayRudderPosition(DataValue[ShowSOG], 20, 200, 160, commonData->fgcolor, commonData->bgcolor);
+
         return PAGE_UPDATE;
     };
 
@@ -256,7 +263,7 @@ PageDescription registerPageAutopilot(
     "Autopilot",    // Page name
     createPage,     // Action
     0,              // Number of bus values depends on selection in Web configuration
-    {"HDM","HDT", "COG", "STW", "SOG", "DBT","XTE", "DTW", "BTW"}, // Bus values we need in the page
+    {"HDM","HDT", "COG", "STW", "SOG", "DBT","XTE", "DTW", "BTW", "RPOS", "ROT"}, // Bus values we need in the page
    true            // Show display header on/off
 );
 

lib/obp60task/PageBME280.cpp

@@ -105,7 +105,7 @@ class PageBME280 : public Page
         //***********************************************************
 
         // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
 
         getdisplay().setTextColor(commonData->fgcolor);
 

lib/obp60task/PageBattery.cpp

@@ -158,7 +158,7 @@ class PageBattery : public Page
         //***********************************************************
 
         // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
 
         // Show average settings
         getdisplay().setTextColor(commonData->fgcolor);

lib/obp60task/PageBattery2.cpp

@@ -2,7 +2,6 @@
 
 #include "Pagedata.h"
 #include "OBP60Extensions.h"
-#include "movingAvg.h"              // Lib for moving average building
 
 class PageBattery2 : public Page
 {
@@ -184,7 +183,7 @@ public:
         //***********************************************************
 
         // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
 
         getdisplay().setTextColor(commonData->fgcolor);
 

lib/obp60task/PageClock.cpp

@@ -375,7 +375,7 @@ public:
         //***********************************************************
 
         // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
 
         getdisplay().setTextColor(commonData->fgcolor);
 
@@ -442,8 +442,8 @@ public:
             uint16_t wDigit, hDigit;
             uint16_t wColon, hColon;
 
-            getdisplay().getTextBounds("00", 0, 0, &x0, &y0, &wDigit, &hDigit);
+displayGetTextBounds("00", 0, 0, &x0, &y0, &wDigit, &hDigit);
-            getdisplay().getTextBounds(":", 0, 0, &x0, &y0, &wColon, &hColon);
+displayGetTextBounds(":", 0, 0, &x0, &y0, &wColon, &hColon);
 
             uint16_t totalWidth = 3 * wDigit + 2 * wColon;
 
@@ -453,7 +453,7 @@ public:
             // Draw time string centered
             int16_t x1b, y1b;
             uint16_t wb, hb;
-            getdisplay().getTextBounds(timeStr, 0, 0, &x1b, &y1b, &wb, &hb);
+            displayGetTextBounds(timeStr, 0, 0, &x1b, &y1b, &wb, &hb);
             int16_t textX = (static_cast<int16_t>(getdisplay().width()) - static_cast<int16_t>(wb)) / 2;
             int16_t textY = centerY + hb / 2;
 
@@ -520,7 +520,7 @@ public:
 
             int16_t x1b, y1b;
             uint16_t wb, hb;
-            getdisplay().getTextBounds(timeStr, 0, 0, &x1b, &y1b, &wb, &hb);
+            displayGetTextBounds(timeStr, 0, 0, &x1b, &y1b, &wb, &hb);
 
             int16_t x = (static_cast<int16_t>(getdisplay().width()) - static_cast<int16_t>(wb)) / 2;
             int16_t y = 150 + hb / 2;
@@ -665,7 +665,7 @@ public:
                 // Print text centered on position x, y
                 int16_t x1c, y1c;     // Return values of getTextBounds
                 uint16_t wc, hc;      // Return values of getTextBounds
-                getdisplay().getTextBounds(ii, int(x), int(y), &x1c, &y1c, &wc, &hc); // Calc width of new string
+                displayGetTextBounds(ii, int(x), int(y), &x1c, &y1c, &wc, &hc); // Calc width of new string
                 getdisplay().setCursor(x - wc / 2, y + hc / 2);
                 if (i % 90 == 0) {
                     getdisplay().setFont(&Ubuntu_Bold12pt8b);

lib/obp60task/PageCompass.cpp

@@ -109,7 +109,7 @@ class PageCompass : public Page
         //***********************************************************
 
         // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
         getdisplay().setTextColor(commonData->fgcolor);
 
         // Horizontal line 2 pix top & bottom

lib/obp60task/PageDST810.cpp

@@ -91,7 +91,7 @@ public:
         //***********************************************************
 
         // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
 
         getdisplay().setTextColor(commonData->fgcolor);
 

lib/obp60task/PageDigitalOut.cpp

@@ -106,7 +106,7 @@ bool button5 = false;
         //***********************************************************
 
         // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
         getdisplay().setTextColor(commonData->fgcolor);
         getdisplay().setFont(&Ubuntu_Bold12pt8b);
         // Write text

lib/obp60task/PageFluid.cpp

@@ -138,7 +138,7 @@ class PageFluid : public Page
         //***********************************************************
 
         // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height());
+        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height());
 
         getdisplay().setTextColor(commonData->fgcolor);
 

lib/obp60task/PageFourValues.cpp

@@ -91,7 +91,7 @@ class PageFourValues : public Page
         //***********************************************************
 
         // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
 
         getdisplay().setTextColor(commonData->fgcolor);
 

lib/obp60task/PageFourValues2.cpp

@@ -91,7 +91,7 @@ class PageFourValues2 : public Page
         //***********************************************************
 
         // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
 
         getdisplay().setTextColor(commonData->fgcolor);
 

lib/obp60task/PageGenerator.cpp

@@ -2,7 +2,6 @@
 
 #include "Pagedata.h"
 #include "OBP60Extensions.h"
-#include "movingAvg.h"              // Lib for moving average building
 
 class PageGenerator : public Page
 {
@@ -83,7 +82,7 @@ public:
         //***********************************************************
 
         // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
 
         getdisplay().setTextColor(commonData->fgcolor);
 

lib/obp60task/PageKeelPosition.cpp

@@ -68,7 +68,7 @@ public:
         //***********************************************************
 
         // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
 
 //*******************************************************************************************
         
@@ -105,7 +105,7 @@ public:
             // Print text centered on position x, y
             int16_t x1, y1;     // Return values of getTextBounds
             uint16_t w, h;      // Return values of getTextBounds
-            getdisplay().getTextBounds(ii, int(x), int(y), &x1, &y1, &w, &h); // Calc width of new string
+            displayGetTextBounds(ii, int(x), int(y), &x1, &y1, &w, &h); // Calc width of new string
             getdisplay().setCursor(x-w/2, y+h/2);
             if(i % 30 == 0){
                 getdisplay().setFont(&Ubuntu_Bold8pt8b);

lib/obp60task/PageNavigation.cpp

@@ -4,6 +4,7 @@
 #include "OBP60Extensions.h"
 #include "NetworkClient.h"      // Network connection
 #include "ImageDecoder.h"       // Image decoder for navigation map
+#include <mbedtls/base64.h>
 
 #include "Logo_OBP_400x300_sw.h"
 
@@ -12,6 +13,54 @@
 NetworkClient net(JSON_BUFFER); // Define network client
 ImageDecoder decoder;           // Define image decoder        
 
+#ifdef TFT_DISPLAY
+// Set to true to render a generated RGB565 color-bar test image.
+static constexpr bool kShowRgb565StripeTestImage = false;
+
+static void drawRgb565Image(int16_t x, int16_t y, const uint16_t *img, int16_t w, int16_t h) {
+    if (img == nullptr || w <= 0 || h <= 0) {
+        return;
+    }
+    for (int16_t yy = 0; yy < h; ++yy) {
+        const uint16_t *row = img + ((size_t)yy * (size_t)w);
+        for (int16_t xx = 0; xx < w; ++xx) {
+            getdisplay().drawPixel(x + xx, y + yy, row[xx]);
+        }
+        if ((yy & 0x0F) == 0) {
+            yield();
+        }
+    }
+}
+
+static void createRgb565StripeImage(uint16_t *img, int16_t w, int16_t h) {
+    if (img == nullptr || w <= 0 || h <= 0) {
+        return;
+    }
+    static const uint16_t stripes[] = {
+        0xF800, // red
+        0xFD20, // orange
+        0xFFE0, // yellow
+        0x07E0, // green
+        0x07FF, // cyan
+        0x001F, // blue
+        0xF81F, // magenta
+        0xFFFF  // white
+    };
+    const int stripeCount = (int)(sizeof(stripes) / sizeof(stripes[0]));
+
+    for (int16_t y = 0; y < h; ++y) {
+        uint16_t *row = img + ((size_t)y * (size_t)w);
+        for (int16_t x = 0; x < w; ++x) {
+            int idx = ((int)x * stripeCount) / (int)w;
+            if (idx >= stripeCount) {
+                idx = stripeCount - 1;
+            }
+            row[x] = stripes[idx];
+        }
+    }
+}
+#endif
+
 class PageNavigation : public Page
 {
 // Values for buttons
@@ -24,13 +73,19 @@ bool showValues = false; // Show values HDT, SOG, DBT in navigation map
     int imageBackupWidth = 0;
     int imageBackupHeight = 0;
     size_t imageBackupSize = 0;
+    size_t imageBackupCapacity = 0;
     bool hasImageBackup = false;
+    bool imageBackupIsRgb565 = false;
 
     public:
     PageNavigation(CommonData &common){
         commonData = &common;
         common.logger->logDebug(GwLog::LOG,"Instantiate PageNavigation");
-        imageBackupData = (uint8_t*)heap_caps_malloc((GxEPD_WIDTH * GxEPD_HEIGHT), MALLOC_CAP_SPIRAM);
+        imageBackupCapacity = (size_t)GxEPD_WIDTH * (size_t)GxEPD_HEIGHT;
+        #ifdef TFT_DISPLAY
+        imageBackupCapacity *= 2U;
+        #endif
+        imageBackupData = (uint8_t*)heap_caps_malloc(imageBackupCapacity, MALLOC_CAP_SPIRAM);
     }
 
     // Set botton labels
@@ -295,6 +350,18 @@ bool showValues = false; // Show values HDT, SOG, DBT in navigation map
             mType = 9;
             dType = 1;
         }
+        else if(mapType == "C-Map"){
+            mType = 103486987;
+            dType = 1;
+        }
+        else if(mapType == "Garmin Fish"){
+            mType = 113486987;
+            dType = 1;
+        }
+        else if(mapType == "Garmin Nav"){
+            mType = 123486987;
+            dType = 1;
+        }
         else{
             mType = 1;
             dType = 1;
@@ -347,22 +414,33 @@ bool showValues = false; // Show values HDT, SOG, DBT in navigation map
         // URL to OBP Maps Converter
         // For more details see: https://github.com/norbert-walter/maps-converter
         String url = String("http://") + server + ":" + port +  // OBP Server
-                    String("/get_image_json?") +               // Service: Output B&W picture as JSON (Base64 + gzip)
+                    String("/get_image_json?") +                // Service: Output B&W picture as JSON (Base64 + gzip)
-                    "zoom=" + zoom +   // Default zoom level: 15
+                    #ifdef TFT_DISPLAY
+                    "oformat=3" +       // Image output format in JSON: 3=RGB565 format
+                    #else
+                    "oformat=4" +       // Image output format in JSON: 4=b/w 1-Bit format
+                    #endif                 
+                    "&zoom=" + zoom +    // Default zoom level: 15
                     "&lat=" + String(latitude, 6) +   // Latitude
                     "&lon=" + String(longitude, 6) +  // Longitude
                     "&mrot=" + mapRot + // Rotation angle navigation map in degree
                     "&mtype=" + mType + // Default Map: Open Street Map
-                    "&dtype=" + dType + // Dithering type: Atkinson dithering
+                    #ifdef TFT_DISPLAY
-                    "&width=400" +     // With navigation map
+                    "&itype=1" +        // Image type: 1=Color
-                    "&height=250" +    // Height navigation map
+                    #else
-                    "&cutout=0" +      // No picture cutouts
+                    "&itype=4" +        // Image type: 4=b/w with dithering
-                    "&tab=0" +         // No tab size
+                    #endif              
-                    "&border=2" +      // Border line size: 2 pixel
+                    "&dtype=" + dType + // Dithering type: Atkinson dithering (only activ when itype=4 otherwise inactive)                   
-                    "&symbol=2" +      // Symbol: Triangle
+                    "&width=400" +      // With navigation map
+                    "&height=250" +     // Height navigation map
+                    "&cutout=0" +       // No picture cutouts (tab, border and alpha are unused when cutout=0)
+                    "&tab=0" +          // No tab size (only available when sqare cutouts selected coutout=3...7)
+                    "&border=2" +       // Border line size: 2 pixel (only available when sqare cutouts selected)
+                    "&alpha=80" +       // Alpha for tabs: 80% visible (only available when sqare cutouts selected)
+                    "&symbol=2" +       // Symbol: Triangle
                     "&srot=" + symbolRot + // Symbol rotation angle
-                    "&ssize=15" +      // Symbole size: 15 pixel
+                    "&ssize=15" +       // Symbole size: 15 pixel (center pointer)
-                    "&grid=" + mapGrid // Show grid: On
+                    "&grid=" + mapGrid  // Show grid: On
                     ;         
         
         // Draw page
@@ -371,19 +449,45 @@ bool showValues = false; // Show values HDT, SOG, DBT in navigation map
         // ############### Draw Navigation Map ################
         
         // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
         getdisplay().setTextColor(commonData->fgcolor);
 
+        // NEW: simple exponential backoff for 1 Hz polling (prevents connection-refused storms)
+        static uint32_t nextAllowedMs = 0;
+        static uint8_t  failCount = 0;
+
+        uint32_t now = millis();
+
+        // NEW: if we are in backoff window, skip network call and use backup immediately
+        bool allowFetch = ((int32_t)(now - nextAllowedMs) >= 0);
+        
         // If a network connection to URL then load the navigation map
-        if (net.fetchAndDecompressJson(url)) {
+        if (allowFetch && net.fetchAndDecompressJson(url)) {
 
-            auto& json = net.json();                // Extract JSON content
+            // NEW: reset backoff on success
-            int numPix = json["number_pixels"] | 0; // Read number of pixels
+            failCount = 0;
-            imgWidth = json["width"] | 0;           // Read width of image
+            nextAllowedMs = now + 1000; // keep 1 Hz on success
-            imgHeight = json["height"] | 0;         // Read height og image
 
-            const char* b64src = json["picture_base64"].as<const char*>();  // Read picture as Base64 content
+            int numPix = net.numberPixels(); // Read number of pixels
-            size_t b64len = strlen(b64src);                                 // Calculate length of Base64 content
+            imgWidth = net.imageWidth();     // Read width of image
+            imgHeight = net.imageHeight();   // Read height of image
+            size_t requiredBytesMono = 0;
+            size_t requiredBytesRgb565 = 0;
+            if (imgWidth > 0 && imgHeight > 0){
+                requiredBytesMono = (size_t)((imgWidth + 7) / 8) * (size_t)imgHeight;
+                requiredBytesRgb565 = (size_t)imgWidth * (size_t)imgHeight * 2U;
+            }
+            if (requiredBytesMono == 0){
+                LOG_DEBUG(GwLog::ERROR,"Error PageNavigation: invalid image geometry w=%d h=%d",imgWidth,imgHeight);
+                return PAGE_UPDATE;
+            }
+
+            const char* b64src = net.pictureBase64();  // Read picture as Base64 content
+            if (b64src == nullptr){
+                LOG_DEBUG(GwLog::ERROR,"Error PageNavigation: picture_base64 missing");
+                return PAGE_UPDATE;
+            }
+            size_t b64len = net.pictureBase64Len(); // Calculate length of Base64 content
             // Copy Base64 content in PSRAM
             char* b64 = (char*) heap_caps_malloc(b64len + 1, MALLOC_CAP_SPIRAM);    // Allcate PSRAM for Base64 content
             if (!b64) {
@@ -393,32 +497,81 @@ bool showValues = false; // Show values HDT, SOG, DBT in navigation map
             memcpy(b64, b64src, b64len + 1);    // Copy Base64 content in PSRAM
 
             // Set image buffer in PSRAM
-            //size_t imgSize = getdisplay().width() * getdisplay().height();
+            size_t imgSize = (numPix > 0) ? (size_t)numPix : requiredBytesMono;    // Calculate image size
-            size_t imgSize = numPix;    // Calculate image size
+            if (imgSize < requiredBytesMono){
+                imgSize = requiredBytesMono;
+            }
+            #ifdef TFT_DISPLAY
+            if (imgSize < requiredBytesRgb565){
+                imgSize = requiredBytesRgb565;
+            }
+            #endif
             uint8_t* imageData = (uint8_t*) heap_caps_malloc(imgSize, MALLOC_CAP_SPIRAM);           // Allocate PSRAM for image
             if (!imageData) {
-                LOG_DEBUG(GwLog::ERROR,"Error PageNavigation: PPSRAM alloc image buffer failed");
+                LOG_DEBUG(GwLog::ERROR,"Error PageNavigation: PSRAM alloc image buffer failed");
                 free(b64);
                 return PAGE_UPDATE;
             }
 
             // Decode Base64 content to image
             size_t decodedSize = 0;
-            decoder.decodeBase64(b64, imageData, imgSize, decodedSize);
+            bool decodeOk = decoder.decodeBase64(b64, b64len, imageData, imgSize, decodedSize);
+            if (!decodeOk || decodedSize < requiredBytesMono){
+                int base64Ret = mbedtls_base64_decode(
+                    nullptr,
+                    0,
+                    &decodedSize,
+                    (const unsigned char*)b64,
+                    b64len
+                );
+                LOG_DEBUG(GwLog::ERROR,
+                    "Error PageNavigation: decode failed (ok=%d, decoded=%u, required=%u, b64ret=%d)",
+                    decodeOk ? 1 : 0,
+                    (unsigned int)decodedSize,
+                    (unsigned int)requiredBytesMono,
+                    base64Ret
+                );
+                free(b64);
+                free(imageData);
+                return PAGE_UPDATE;
+            }
 
-            // Copy actual navigation man to ackup map
+            bool imageIsRgb565 = false;
+            #ifdef TFT_DISPLAY
+            imageIsRgb565 = (decodedSize >= requiredBytesRgb565);
+            #endif
+
+            #ifdef TFT_DISPLAY
+            if (kShowRgb565StripeTestImage) {
+                createRgb565StripeImage(reinterpret_cast<uint16_t*>(imageData), imgWidth, imgHeight);
+                decodedSize = requiredBytesRgb565;
+                imageIsRgb565 = true;
+            }
+            #endif
+
+            // Copy actual navigation map to backup map
             imageBackupWidth  = imgWidth;
             imageBackupHeight = imgHeight;
             imageBackupSize   = imgSize;
-            if (decodedSize > 0) {
+            if (decodedSize > 0 && imageBackupData != nullptr) {
-                memcpy(imageBackupData, imageData, decodedSize);
+                size_t copySize = (decodedSize > imageBackupCapacity) ? imageBackupCapacity : decodedSize;
-                imageBackupSize = decodedSize;
+                memcpy(imageBackupData, imageData, copySize);
+                imageBackupSize = copySize;
             }
-            hasImageBackup = true;
+            imageBackupIsRgb565 = imageIsRgb565;
+            hasImageBackup = (imageBackupData != nullptr);
             lostCounter = 0;
 
             // Show image (navigation map)
-            getdisplay().drawBitmap(0, 25, imageData, imgWidth, imgHeight, commonData->fgcolor);
+            #ifdef TFT_DISPLAY
+            if (imageIsRgb565) {
+                drawRgb565Image(0, 25, reinterpret_cast<const uint16_t*>(imageData), imgWidth, imgHeight);
+            } else {
+                displayDrawBitmap(0, 25, imageData, imgWidth, imgHeight, commonData->fgcolor);
+            }
+            #else
+            displayDrawBitmap(0, 25, imageData, imgWidth, imgHeight, commonData->fgcolor);
+            #endif
 
             // Clean PSRAM
             free(b64);
@@ -426,12 +579,33 @@ bool showValues = false; // Show values HDT, SOG, DBT in navigation map
         }
         // If no network connection then use backup navigation map
         else{
-            // Show backup image (backup navigation map)
+
-            if (hasImageBackup) {
+            // NEW: update backoff only if we actually attempted a fetch (not when skipping due to backoff)
-                getdisplay().drawBitmap(0, 25, imageBackupData, imageBackupWidth, imageBackupHeight, commonData->fgcolor);
+            if (allowFetch) {
+                // NEW: exponential backoff: 1s,2s,4s,8s,16s,30s (capped)
+                if (failCount < 6) failCount++;
+                uint32_t backoffMs = 1000u << failCount;
+                if (backoffMs > 30000u) backoffMs = 30000u;
+                nextAllowedMs = now + backoffMs;
+            } else {
+                // NEW: we are currently backing off; do not increase failCount further
+                // nextAllowedMs stays unchanged
             }
 
-            // Show info: Connection lost when 5 page refreshes has a connection lost to the map server
+            // Show backup image (backup navigation map)
+            if (hasImageBackup) {
+                #ifdef TFT_DISPLAY
+                if (imageBackupIsRgb565) {
+                    drawRgb565Image(0, 25, reinterpret_cast<const uint16_t*>(imageBackupData), imageBackupWidth, imageBackupHeight);
+                } else {
+                    displayDrawBitmap(0, 25, imageBackupData, imageBackupWidth, imageBackupHeight, commonData->fgcolor);
+                }
+                #else
+                displayDrawBitmap(0, 25, imageBackupData, imageBackupWidth, imageBackupHeight, commonData->fgcolor);
+                #endif
+            }    
+
+            // Show connection lost info when 5 page refreshes has a connection lost to the map server
             // Short connection losts are uncritical
             if(lostCounter >= 5){
                 getdisplay().setFont(&Ubuntu_Bold12pt8b);
@@ -444,7 +618,6 @@ bool showValues = false; // Show values HDT, SOG, DBT in navigation map
             lostCounter++; // Increment lost counter
         }
 
-
         // ############### Draw Values ################
         getdisplay().setFont(&Ubuntu_Bold12pt8b);
 

lib/obp60task/PageOneValue.cpp

@@ -209,8 +209,6 @@ public:
                     dataIntv = 3;
                 } else if (dataIntv == 3) {
                     dataIntv = 4;
-                } else if (dataIntv == 4) {
-                    dataIntv = 8;
                 } else {
                     dataIntv = 1;
                 }
@@ -276,7 +274,7 @@ public:
         // Draw page
         //***********************************************************
 
-        getdisplay().setPartialWindow(0, 0, width, height); // Set partial update
+        displaySetPartialWindow(0, 0, width, height); // Set partial update
 
         if (pageMode == VALUE || dataHstryBuf == nullptr) {
             // show only data value; ignore other pageMode options if no chart supported boat data history buffer is available

lib/obp60task/PageRollPitch.cpp

@@ -116,7 +116,7 @@ public:
         //***********************************************************
 
         // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
 
         getdisplay().setTextColor(commonData->fgcolor);
 
@@ -194,7 +194,7 @@ public:
                 // Print text centered on position x, y
                 int16_t x1, y1;     // Return values of getTextBounds
                 uint16_t w, h;      // Return values of getTextBounds
-                getdisplay().getTextBounds(ii, int(x), int(y), &x1, &y1, &w, &h); // Calc width of new string
+                displayGetTextBounds(ii, int(x), int(y), &x1, &y1, &w, &h); // Calc width of new string
                 getdisplay().setCursor(x-w/2, y+h/2);
                 if(i % 20 == 0){
                     getdisplay().setFont(&Ubuntu_Bold8pt8b);

lib/obp60task/PageRudderPosition.cpp

@@ -72,7 +72,7 @@ public:
         //***********************************************************
 
         // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
 
 //*******************************************************************************************
         
@@ -110,7 +110,7 @@ public:
             // Print text centered on position x, y
             int16_t x1, y1;     // Return values of getTextBounds
             uint16_t w, h;      // Return values of getTextBounds
-            getdisplay().getTextBounds(ii, int(x), int(y), &x1, &y1, &w, &h); // Calc width of new string
+            displayGetTextBounds(ii, int(x), int(y), &x1, &y1, &w, &h); // Calc width of new string
             getdisplay().setCursor(x-w/2, y+h/2);
             if(i % 30 == 0){
                 getdisplay().setFont(&Ubuntu_Bold8pt8b);

lib/obp60task/PageSixValues.cpp

@@ -75,7 +75,7 @@ class PageSixValues : public Page
             //***********************************************************
     
             // Set display in partial refresh mode
-            getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+            displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
             getdisplay().setTextColor(commonData->fgcolor);
 
             for (int i = 0; i < ( HowManyValues / 2 ); i++){

lib/obp60task/PageSkyView.cpp

@@ -73,7 +73,7 @@ public:
         //***********************************************************
 
         // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
 
         // current position
         getdisplay().setFont(&Ubuntu_Bold8pt8b);
@@ -105,19 +105,19 @@ public:
         uint16_t w, h;
         getdisplay().setFont(&Ubuntu_Bold12pt8b);
 
-		getdisplay().getTextBounds("N", 0, 150, &x1, &y1, &w, &h);
+		displayGetTextBounds("N", 0, 150, &x1, &y1, &w, &h);
         getdisplay().setCursor(c.x - w / 2, c.y - r + h + 3);
         getdisplay().print("N");
 
-		getdisplay().getTextBounds("S", 0, 150, &x1, &y1, &w, &h);
+		displayGetTextBounds("S", 0, 150, &x1, &y1, &w, &h);
         getdisplay().setCursor(c.x - w / 2, c.y + r - 3);
         getdisplay().print("S");
 
-		getdisplay().getTextBounds("E", 0, 150, &x1, &y1, &w, &h);
+		displayGetTextBounds("E", 0, 150, &x1, &y1, &w, &h);
         getdisplay().setCursor(c.x + r - w - 3, c.y + h / 2);
         getdisplay().print("E");
         
-		getdisplay().getTextBounds("W", 0, 150, &x1, &y1, &w, &h);
+		displayGetTextBounds("W", 0, 150, &x1, &y1, &w, &h);
         getdisplay().setCursor(c.x - r + 3 , c.y + h / 2);
         getdisplay().print("W");
 

lib/obp60task/PageSolar.cpp

@@ -2,7 +2,6 @@
 
 #include "Pagedata.h"
 #include "OBP60Extensions.h"
-#include "movingAvg.h"              // Lib for moving average building
 
 class PageSolar : public Page
 {
@@ -82,7 +81,7 @@ public:
         //***********************************************************
 
         // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
 
         getdisplay().setTextColor(commonData->fgcolor);
 

lib/obp60task/PageSystem.cpp

@@ -15,6 +15,7 @@
 #include "images/logo64.xbm"
 #include <esp32/clk.h>
 #include "qrcode.h"
+#include <vector>
 
 #ifdef BOARD_OBP40S3
 #include "dirent.h"
@@ -37,9 +38,11 @@ private:
     String buzzer_mode;
     uint8_t buzzer_power;
     String cpuspeed;
+    String powermode;
     String rtc_module;
     String gps_module;
     String env_module;
+    String flashLED;
 
     String batt_sensor;
     String solar_sensor;
@@ -48,15 +51,445 @@ private:
     double homelat;
     double homelon;
 
-    char mode = 'N'; // (N)ormal, (S)ettings, (D)evice list, (C)ard
+    char mode = 'N'; // (N)ormal, (S)ettings, (C)onfiguration, (D)evice list, c(A)rd
+
+#ifdef PATCH_N2K
+    struct device {
+        uint64_t NAME;
+        uint8_t id;
+        char hex_name[17];
+        uint16_t manuf_code;
+        const char *model;
+    };
+    std::vector<device> devicelist;
+#endif
+
+    void incMode() {
+        if (mode == 'N') {        // Normal
+            mode = 'S';
+        } else if (mode == 'S') { // Settings
+            mode = 'C';
+        } else if (mode == 'C') { // Config
+            mode = 'D';
+        } else if (mode == 'D') { // Device list
+            if (use_sdcard) {
+                mode = 'A';       // SD-Card
+            } else {
+                mode = 'N';
+            }
+        } else {
+            mode = 'N';
+        }
+    }
+
+    void decMode() {
+        if (mode == 'N') {
+            if (use_sdcard) {
+                mode = 'A';       // SD-Card
+            } else {
+                mode = 'D';       // Device list
+            }
+        } else if (mode == 'S') { // Settings
+            mode = 'N';
+        } else if (mode == 'C') { // Config
+            mode = 'S';
+        } else if (mode == 'D') { // Device list
+            mode = 'C';
+        } else {
+            mode = 'D';
+        }
+    }
+
+    void displayModeNormal() {
+        // Default system page view
+
+        uint16_t y0 = 155;
+
+        getdisplay().setFont(&Ubuntu_Bold12pt8b);
+        getdisplay().setCursor(8, 48);
+        getdisplay().print("System Information");
+
+        getdisplay().drawXBitmap(320, 25, logo64_bits, logo64_width, logo64_height, commonData->fgcolor);
+
+        getdisplay().setFont(&Ubuntu_Bold8pt8b);
+
+        char ssid[13];
+        snprintf(ssid, 13, "%04X%08X", (uint16_t)(chipid >> 32), (uint32_t)chipid);
+        displayBarcode(String(ssid), 320, 200, 2);
+        getdisplay().setCursor(8, 70);
+        getdisplay().print(String("MCUDEVICE-") + String(ssid));
+
+        getdisplay().setCursor(8, 95);
+        getdisplay().print("Firmware version: ");
+        getdisplay().setCursor(150, 95);
+        getdisplay().print(VERSINFO);
+
+        getdisplay().setCursor(8, 113);
+        getdisplay().print("Board version: ");
+        getdisplay().setCursor(150, 113);
+        getdisplay().print(BOARDINFO);
+        getdisplay().print(String(" HW ") + String(PCBINFO));
+
+        getdisplay().setCursor(8, 131);
+        getdisplay().print("Display version: ");
+        getdisplay().setCursor(150, 131);
+        getdisplay().print(DISPLAYINFO);
+        getdisplay().print("; GxEPD2 v");
+        getdisplay().print(GXEPD2INFO);
+
+        getdisplay().setCursor(8, 265);
+#ifdef BOARD_OBP60S3
+        getdisplay().print("Press STBY to enter deep sleep mode");
+#endif
+#ifdef BOARD_OBP40S3
+        getdisplay().print("Press wheel to enter deep sleep mode");
+#endif
+
+        // Flash memory size
+        uint32_t flash_size = ESP.getFlashChipSize();
+        getdisplay().setCursor(8, y0);
+        getdisplay().print("FLASH:");
+        getdisplay().setCursor(90, y0);
+        getdisplay().print(String(flash_size / 1024) + String(" kB"));
+
+        // PSRAM memory size
+        uint32_t psram_size = ESP.getPsramSize();
+        getdisplay().setCursor(8, y0 + 16);
+        getdisplay().print("PSRAM:");
+        getdisplay().setCursor(90, y0 + 16);
+        getdisplay().print(String(psram_size / 1024) + String(" kB"));
+
+        // FRAM available / status
+        getdisplay().setCursor(8, y0 + 32);
+        getdisplay().print("FRAM:");
+        getdisplay().setCursor(90, y0 + 32);
+        getdisplay().print(hasFRAM ? "available" : "not found");
+
+#ifdef BOARD_OBP40S3
+        // SD-Card
+        getdisplay().setCursor(8, y0 + 48);
+        getdisplay().print("SD-Card:");
+        getdisplay().setCursor(90, y0 + 48);
+        if (hasSDCard) {
+            uint64_t cardsize = ((uint64_t) sdcard->csd.capacity) * sdcard->csd.sector_size / (1024 * 1024);
+            getdisplay().printf("%llu MB", cardsize);
+        } else {
+            getdisplay().print("off");
+        }
+#endif
+
+        // Uptime
+        int64_t uptime = esp_timer_get_time() / 1000000;
+        String uptime_unit;
+        if (uptime < 120) {
+            uptime_unit = " seconds";
+        } else {
+            if (uptime < 2 * 3600) {
+                uptime /= 60;
+                uptime_unit = " minutes";
+            } else if (uptime < 2 * 3600 * 24) {
+                uptime /= 3600;
+                uptime_unit = " hours";
+            } else {
+                uptime /= 86400;
+                uptime_unit = " days";
+            }
+        }
+        getdisplay().setCursor(8, y0 + 80);
+        getdisplay().print("Uptime:");
+        getdisplay().setCursor(90, y0 + 80);
+        getdisplay().print(uptime);
+        getdisplay().print(uptime_unit);
+
+        // CPU speed config / active
+        getdisplay().setCursor(202, y0);
+        getdisplay().print("CPU speed:");
+        getdisplay().setCursor(300, y0);
+        getdisplay().print(cpuspeed);
+        getdisplay().print(" / ");
+        int cpu_freq = esp_clk_cpu_freq() / 1000000;
+        getdisplay().print(String(cpu_freq));
+
+        // total RAM free
+        int Heap_free = esp_get_free_heap_size();
+        getdisplay().setCursor(202, y0 + 16);
+        getdisplay().print("Total free:");
+        getdisplay().setCursor(300, y0 + 16);
+        getdisplay().print(String(Heap_free));
+
+        // RAM free for task
+        int RAM_free = uxTaskGetStackHighWaterMark(NULL);
+        getdisplay().setCursor(202, y0 + 32);
+        getdisplay().print("Task free:");
+        getdisplay().setCursor(300, y0 + 32);
+        getdisplay().print(String(RAM_free));
+
+    }
+
+    void displayModeConfig() {
+        // Configuration interface
+
+        uint16_t x0 = 16;
+        uint16_t y0 = 80;
+        uint16_t dy = 20;
+
+        getdisplay().setFont(&Ubuntu_Bold12pt8b);
+        getdisplay().setCursor(8, 48);
+        getdisplay().print("System configuration");
+
+		getdisplay().setFont(&Ubuntu_Bold8pt8b);
+
+        getdisplay().setCursor(x0, y0);
+        getdisplay().print("CPU speed: 80 | 160 | 240");
+        getdisplay().setCursor(x0, y0 + 1 * dy);
+        getdisplay().print("Power mode: Max | 5V | Min");
+        getdisplay().setCursor(x0, y0 + 2 * dy);
+        getdisplay().print("Accesspoint: On | Off");
+
+        // TODO Change NVRAM-preferences settings here
+        getdisplay().setCursor(x0, y0 + 4 * dy);
+        getdisplay().print("Simulation: On | Off");
+
+    }
+
+    void displayModeSettings() {
+        // View some of the current settings
+
+        const uint16_t x0 = 8;
+        const uint16_t y0 = 72;
+
+        getdisplay().setFont(&Ubuntu_Bold12pt8b);
+        getdisplay().setCursor(x0, 48);
+        getdisplay().print("System settings");
+
+        getdisplay().setFont(&Ubuntu_Bold8pt8b);
+
+        // left column
+        getdisplay().setCursor(x0, y0);
+        getdisplay().print("Simulation:");
+        getdisplay().setCursor(120, y0);
+        getdisplay().print(simulation ? "on" : "off");
+
+        getdisplay().setCursor(x0, y0 + 16);
+        getdisplay().print("Environment:");
+        getdisplay().setCursor(120, y0 + 16);
+        getdisplay().print(env_module);
+
+        getdisplay().setCursor(x0, y0 + 32);
+        getdisplay().print("Buzzer:");
+        getdisplay().setCursor(120, y0 + 32);
+        getdisplay().print(buzzer_mode);
+
+        getdisplay().setCursor(x0, y0 + 64);
+        getdisplay().print("GPS:");
+        getdisplay().setCursor(120, y0 + 64);
+        getdisplay().print(gps_module);
+
+        getdisplay().setCursor(x0, y0 + 80);
+        getdisplay().print("RTC:");
+        getdisplay().setCursor(120, y0 + 80);
+        getdisplay().print(rtc_module);
+
+        getdisplay().setCursor(x0, y0 + 96);
+        getdisplay().print("Wifi:");
+        getdisplay().setCursor(120, y0 + 96);
+        getdisplay().print(commonData->status.wifiApOn ? "on" : "off");
+
+        // Home location
+        getdisplay().setCursor(x0, y0 + 128);
+        getdisplay().print("Home Lat.:");
+        getdisplay().setCursor(120, y0 + 128);
+        getdisplay().print(formatLatitude(homelat));
+        getdisplay().setCursor(x0, y0 + 144);
+        getdisplay().print("Home Lon.:");
+        getdisplay().setCursor(120, y0 + 144);
+        getdisplay().print(formatLongitude(homelon));
+
+        // Power
+        getdisplay().setCursor(x0, y0 + 176);
+        getdisplay().print("Power mode:");
+        getdisplay().setCursor(120, y0 + 176);
+        getdisplay().print(powermode);
+
+        // right column
+        getdisplay().setCursor(202, y0);
+        getdisplay().print("Batt. sensor:");
+        getdisplay().setCursor(320, y0);
+        getdisplay().print(batt_sensor);
+
+        // Solar sensor
+        getdisplay().setCursor(202, y0 + 16);
+        getdisplay().print("Solar sensor:");
+        getdisplay().setCursor(320, y0 + 16);
+        getdisplay().print(solar_sensor);
+
+        // Generator sensor
+        getdisplay().setCursor(202, y0 + 32);
+        getdisplay().print("Gen. sensor:");
+        getdisplay().setCursor(320, y0 + 32);
+        getdisplay().print(gen_sensor);
+
+        // TODO
+        // Gyro sensor (rotation)
+        getdisplay().setCursor(202, y0 + 48);
+        getdisplay().print("Rot. sensor:");
+        getdisplay().setCursor(320, y0 + 48);
+        getdisplay().print(rot_sensor);
+
+        // Temp.-sensor
+        // Power Mode
+
+#ifdef BOARD_OBP60S3
+        // Backlight infos
+        getdisplay().setCursor(202, y0 + 64);
+        getdisplay().print("Backlight:");
+        getdisplay().setCursor(320, y0 + 64);
+        getdisplay().printf("%d%%", commonData->backlight.brightness);
+        // TODO test function with OBP60 device
+        getdisplay().setCursor(202, y0 + 80);
+        getdisplay().print("Bl color:");
+        getdisplay().setCursor(320, y0 + 80);
+        getdisplay().print(commonData->backlight.color.toName());
+        getdisplay().setCursor(202, y0 + 96);
+        getdisplay().print("Bl mode:");
+        getdisplay().setCursor(320, y0 + 96);
+        getdisplay().print(commonData->backlight.mode);
+        // TODO Buzzer mode and power
+#endif
+	}
+
+    void displayModeSDCard() {
+
+        // SD Card info
+        uint16_t x0 = 20;
+        uint16_t y0 = 72;
+
+        getdisplay().setFont(&Ubuntu_Bold12pt8b);
+        getdisplay().setCursor(8, 48);
+        getdisplay().print("SD Card info");
+
+        getdisplay().setFont(&Ubuntu_Bold8pt8b);
+        getdisplay().setCursor(x0, y0);
+#ifdef BOARD_OBP60S3
+        // This mode should not be callable by devices without card hardware
+        // In case of accidential reaching this, display a friendly message
+        getdisplay().print("This mode is not indended to be reached!\n");
+        getdisplay().print("There's nothing to see here. Move on.");
+#endif
+#ifdef BOARD_OBP40S3
+        getdisplay().print("Work in progress...");
+
+        /* TODO
+           this code should go somewhere else. only for testing purposes here
+           identify card as OBP-Card:
+             magic.dat
+             version.dat
+             readme.txt
+             IMAGES/
+             CHARTS/
+             LOGS/
+             DATA/
+            hint: file access with fopen, fgets, fread, fclose
+        */
+
+        // Simple test for magic file in root
+        getdisplay().setCursor(x0, y0 + 32);
+        String file_magic = MOUNT_POINT "/magic.dat";
+        commonData->logger->logDebug(GwLog::LOG, "Test magicfile: %s", file_magic.c_str());
+        struct stat st;
+        if (stat(file_magic.c_str(), &st) == 0) {
+            getdisplay().printf("File %s exists", file_magic.c_str());
+        } else {
+            getdisplay().printf("File %s not found", file_magic.c_str());
+        }
+
+        // Root directory check
+        DIR* dir = opendir(MOUNT_POINT);
+        int dy = 0;
+        if (dir != NULL) {
+            commonData->logger->logDebug(GwLog::LOG, "Root directory: %s", MOUNT_POINT);
+            struct dirent* entry;
+            while (((entry = readdir(dir)) != NULL) and (dy < 140)) {
+                getdisplay().setCursor(x0, y0 + 64 + dy);
+                getdisplay().print(entry->d_name);
+                // type 1 is file, type 2 is dir
+                if (entry->d_type == 2) {
+                    getdisplay().print("/");
+                }
+                dy += 20;
+                commonData->logger->logDebug(GwLog::DEBUG, "    %s type %d", entry->d_name, entry->d_type);
+            }
+            closedir(dir);
+        } else {
+            commonData->logger->logDebug(GwLog::LOG, "Failed to open root directory");
+        }
+
+#endif
+    }
+
+    void displayModeDevicelist() {
+        // NMEA2000 device list
+        getdisplay().setFont(&Ubuntu_Bold12pt8b);
+        getdisplay().setCursor(8, 48);
+        getdisplay().print("NMEA2000 device list");
+
+        getdisplay().setFont(&Ubuntu_Bold8pt8b);
+        getdisplay().setCursor(20, 70);
+        getdisplay().print("RxD: ");
+        getdisplay().print(String(commonData->status.n2kRx));
+        getdisplay().setCursor(120, 70);
+        getdisplay().print("TxD: ");
+        getdisplay().print(String(commonData->status.n2kTx));
+
+#ifdef PATCH_N2K
+        uint16_t x0 = 20;
+        uint16_t y0 = 100;
+
+        getdisplay().setFont(&Ubuntu_Bold10pt8b);
+        getdisplay().setCursor(x0, y0);
+        getdisplay().print("ID");
+        getdisplay().setCursor(x0 + 50, y0);
+        getdisplay().print("Model");
+        getdisplay().setCursor(x0 + 250, y0);
+        getdisplay().print("Manuf.");
+        getdisplay().drawLine(18, y0 + 4, 360 , y0 + 4 , commonData->fgcolor);
+
+        getdisplay().setFont(&Ubuntu_Bold8pt8b);
+        y0 = 120;
+        uint8_t n_dev = 0;
+        for (const device& item : devicelist) {
+            if (n_dev > 8) {
+                break;
+            }
+            getdisplay().setCursor(x0, y0 + n_dev * 20);
+            getdisplay().print(item.id);
+            getdisplay().setCursor(x0 + 50, y0 + n_dev * 20);
+            getdisplay().print(item.model);
+            getdisplay().setCursor(x0 + 250, y0 + n_dev * 20);
+            getdisplay().print(item.manuf_code);
+            n_dev++;
+        }
+        getdisplay().setCursor(x0, y0 + (n_dev + 1) * 20);
+        if (n_dev == 0) {
+            getdisplay().printf("no devices found on bus");
+
+        } else {
+            getdisplay().drawLine(18, y0 + n_dev * 20, 360 , y0 + n_dev * 20, commonData->fgcolor);
+            getdisplay().printf("%d devices of %d in total", n_dev, devicelist.size());
+        }
+#else
+        getdisplay().setCursor(20, 100);
+        getdisplay().print("NMEA2000 not exposed to obp60 task");
+#endif
+    }
 
 public:
     PageSystem(CommonData &common){
         commonData = &common;
-        common.logger->logDebug(GwLog::LOG,"Instantiate PageSystem");
+        commonData->logger->logDebug(GwLog::LOG,"Instantiate PageSystem");
         if (hasFRAM) {
             mode = fram.read(FRAM_SYSTEM_MODE);
-            common.logger->logDebug(GwLog::DEBUG, "Loaded mode '%c' from FRAM", mode);
+            commonData->logger->logDebug(GwLog::DEBUG, "Loaded mode '%c' from FRAM", mode);
         }
         chipid = ESP.getEfuseMac();
         simulation = common.config->getBool(common.config->useSimuData);
@@ -67,6 +500,7 @@ public:
         buzzer_mode.toLowerCase();
         buzzer_power = common.config->getInt(common.config->buzzerPower);
         cpuspeed = common.config->getString(common.config->cpuSpeed);
+        powermode = common.config->getString(common.config->powerMode);
         env_module = common.config->getString(common.config->useEnvSensor);
         rtc_module = common.config->getString(common.config->useRTC);
         gps_module = common.config->getString(common.config->useGPS);
@@ -76,6 +510,7 @@ public:
         rot_sensor = common.config->getString(common.config->useRotSensor);
         homelat = common.config->getString(common.config->homeLAT).toDouble();
         homelon = common.config->getString(common.config->homeLON).toDouble();
+        flashLED = common.config->getString(common.config->flashLED);
     }
 
     void setupKeys() {
@@ -92,19 +527,7 @@ public:
         // Switch display mode
         commonData->logger->logDebug(GwLog::LOG, "System keyboard handler");
         if (key == 2) {
-            if (mode == 'N') {
+            incMode();
-                mode = 'S';
-            } else if (mode == 'S') {
-                mode = 'D';
-            } else if (mode == 'D') {
-                if (hasSDCard) {
-                    mode = 'C';
-                } else {
-                    mode = 'N';
-                }
-            } else {
-                mode = 'N';
-            }
             if (hasFRAM) fram.write(FRAM_SYSTEM_MODE, mode);
             return 0;
         }
@@ -129,8 +552,13 @@ public:
         }
 #endif
 #ifdef BOARD_OBP40S3
-        // grab cursor keys to disable page navigation
+        // use cursor keys for local mode navigation
-        if (key == 9 or key == 10) {
+        if (key == 9) {
+            incMode();
+            return 0;
+        }
+        if (key == 10) {
+            decMode();
             return 0;
         }
         // standby / deep sleep
@@ -168,309 +596,68 @@ public:
         }
     }
 
-    int displayPage(PageData &pageData){
+    void displayNew(PageData &pageData) {
-        GwConfigHandler *config = commonData->config;
+#ifdef BOARD_OBP60S3
-        GwLog *logger = commonData->logger;
+        // Clear optical warning
-
+        if (flashLED == "Limit Violation") {
-        // Get config data
-        String flashLED = config->getString(config->flashLED);
-
-        // Optical warning by limit violation (unused)
-        if(String(flashLED) == "Limit Violation"){
             setBlinkingLED(false);
             setFlashLED(false);
         }
+#endif
 
-        // Logging boat values
+#ifdef PATCH_N2K
-        logger->logDebug(GwLog::LOG, "Drawing at PageSystem, Mode=%c", mode);
+        // load current device list
+        tN2kDeviceList *pDevList = pageData.api->getN2kDeviceList();
+        // TODO check if changed
+        if (pDevList->ReadResetIsListUpdated()) {
+            // only reload if changed
+            devicelist.clear();
+            for (uint8_t i = 0; i <= 252; i++) {
+                const tNMEA2000::tDevice *d = pDevList->FindDeviceBySource(i);
+                if (d == nullptr) {
+                    continue;
+                }
+                device dev;
+                dev.id = i;
+                dev.NAME = d->GetName();
+                snprintf(dev.hex_name, sizeof(dev.hex_name), "%08X%08X", (uint32_t)(dev.NAME >> 32), (uint32_t)(dev.NAME & 0xFFFFFFFF));
+                dev.manuf_code = d->GetManufacturerCode();
+                dev.model = d->GetModelID();
+                devicelist.push_back(dev);
+            }
+        }
+#endif
+    };
 
-        // Draw page
+    int displayPage(PageData &pageData){
-        //***********************************************************
 
-        uint16_t x0 = 8;  // left column
+        // Logging page information
-        uint16_t y0 = 48; // data table starts here
+        commonData->logger->logDebug(GwLog::LOG, "Drawing at PageSystem, Mode=%c", mode);
 
         // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
 
-        if (mode == 'N') {
+        // call current system page
-
+        switch (mode) {
-            getdisplay().setFont(&Ubuntu_Bold12pt8b);
+            case 'N':
-            getdisplay().setCursor(8, 48);
+                displayModeNormal();
-            getdisplay().print("System Information");
+                break;
-
+            case 'S':
-            getdisplay().drawXBitmap(320, 25, logo64_bits, logo64_width, logo64_height, commonData->fgcolor);
+                displayModeSettings();
-
+                break;
-            getdisplay().setFont(&Ubuntu_Bold8pt8b);
+            case 'C':
-            y0 = 155;
+                displayModeConfig();
-
+                break;
-            char ssid[13];
+            case 'A':
-            snprintf(ssid, 13, "%04X%08X", (uint16_t)(chipid >> 32), (uint32_t)chipid);
+                displayModeSDCard();
-            displayBarcode(String(ssid), 320, 200, 2);
+                break;
-            getdisplay().setCursor(8, 70);
+            case 'D':
-            getdisplay().print(String("MCUDEVICE-") + String(ssid));
+                displayModeDevicelist();
-
+                break;
-            getdisplay().setCursor(8, 95);
-            getdisplay().print("Firmware version: ");
-            getdisplay().setCursor(150, 95);
-            getdisplay().print(VERSINFO);
-
-            getdisplay().setCursor(8, 113);
-            getdisplay().print("Board version: ");
-            getdisplay().setCursor(150, 113);
-            getdisplay().print(BOARDINFO);
-            getdisplay().print(String(" HW ") + String(PCBINFO));
-
-            getdisplay().setCursor(8, 131);
-            getdisplay().print("Display version: ");
-            getdisplay().setCursor(150, 131);
-            getdisplay().print(DISPLAYINFO);
-            getdisplay().print("; GxEPD2 v");
-            getdisplay().print(GXEPD2INFO);
-
-            getdisplay().setCursor(8, 265);
-#ifdef BOARD_OBP60S3
-            getdisplay().print("Press STBY to enter deep sleep mode");
-#endif
-#ifdef BOARD_OBP40S3
-            getdisplay().print("Press wheel to enter deep sleep mode");
-#endif
-
-            // Flash memory size
-            uint32_t flash_size = ESP.getFlashChipSize();
-            getdisplay().setCursor(8, y0);
-            getdisplay().print("FLASH:");
-            getdisplay().setCursor(90, y0);
-            getdisplay().print(String(flash_size / 1024) + String(" kB"));
-
-            // PSRAM memory size
-            uint32_t psram_size = ESP.getPsramSize();
-            getdisplay().setCursor(8, y0 + 16);
-            getdisplay().print("PSRAM:");
-            getdisplay().setCursor(90, y0 + 16);
-            getdisplay().print(String(psram_size / 1024) + String(" kB"));
-
-            // FRAM available / status
-            getdisplay().setCursor(8, y0 + 32);
-            getdisplay().print("FRAM:");
-            getdisplay().setCursor(90, y0 + 32);
-            getdisplay().print(hasFRAM ? "available" : "not found");
-
-#ifdef BOARD_OBP40S3
-            // SD-Card
-            getdisplay().setCursor(8, y0 + 48);
-            getdisplay().print("SD-Card:");
-            getdisplay().setCursor(90, y0 + 48);
-            if (hasSDCard) {
-                uint64_t cardsize = ((uint64_t) sdcard->csd.capacity) * sdcard->csd.sector_size / (1024 * 1024);
-                getdisplay().printf("%llu MB", cardsize);
-            } else {
-                getdisplay().print("off");
-            }
-#endif
-
-            // Uptime
-            int64_t uptime = esp_timer_get_time() / 1000000;
-            String uptime_unit;
-            if (uptime < 120) {
-                uptime_unit = " seconds";
-            } else {
-                if (uptime < 2 * 3600) {
-                    uptime /= 60;
-                    uptime_unit = " minutes";
-                } else if (uptime < 2 * 3600 * 24) {
-                    uptime /= 3600;
-                    uptime_unit = " hours";
-                } else {
-                    uptime /= 86400;
-                    uptime_unit = " days";
-                }
-            }
-            getdisplay().setCursor(8, y0 + 80);
-            getdisplay().print("Uptime:");
-            getdisplay().setCursor(90, y0 + 80);
-            getdisplay().print(uptime);
-            getdisplay().print(uptime_unit);
-
-            // CPU speed config / active
-            getdisplay().setCursor(202, y0);
-            getdisplay().print("CPU speed:");
-            getdisplay().setCursor(300, y0);
-            getdisplay().print(cpuspeed);
-            getdisplay().print(" / ");
-            int cpu_freq = esp_clk_cpu_freq() / 1000000;
-            getdisplay().print(String(cpu_freq));
-
-            // total RAM free
-            int Heap_free = esp_get_free_heap_size();
-            getdisplay().setCursor(202, y0 + 16);
-            getdisplay().print("Total free:");
-            getdisplay().setCursor(300, y0 + 16);
-            getdisplay().print(String(Heap_free));
-
-            // RAM free for task
-            int RAM_free = uxTaskGetStackHighWaterMark(NULL);
-            getdisplay().setCursor(202, y0 + 32);
-            getdisplay().print("Task free:");
-            getdisplay().setCursor(300, y0 + 32);
-            getdisplay().print(String(RAM_free));
-
-        } else if (mode == 'S') {
-            // Settings
-            
-            getdisplay().setFont(&Ubuntu_Bold12pt8b);
-            getdisplay().setCursor(x0, 48);
-            getdisplay().print("System settings");
-
-            getdisplay().setFont(&Ubuntu_Bold8pt8b);
-            x0 = 8;
-            y0 = 72;
-
-            // left column
-            getdisplay().setCursor(x0, y0);
-            getdisplay().print("Simulation:");
-            getdisplay().setCursor(120, y0);
-            getdisplay().print(simulation ? "on" : "off");
-
-            getdisplay().setCursor(x0, y0 + 16);
-            getdisplay().print("Environment:");
-            getdisplay().setCursor(120, y0 + 16);
-            getdisplay().print(env_module);
-
-            getdisplay().setCursor(x0, y0 + 32);
-            getdisplay().print("Buzzer:");
-            getdisplay().setCursor(120, y0 + 32);
-            getdisplay().print(buzzer_mode);
-
-            getdisplay().setCursor(x0, y0 + 64);
-            getdisplay().print("GPS:");
-            getdisplay().setCursor(120, y0 + 64);
-            getdisplay().print(gps_module);
-
-            getdisplay().setCursor(x0, y0 + 80);
-            getdisplay().print("RTC:");
-            getdisplay().setCursor(120, y0 + 80);
-            getdisplay().print(rtc_module);
-
-            getdisplay().setCursor(x0, y0 + 96);
-            getdisplay().print("Wifi:");
-            getdisplay().setCursor(120, y0 + 96);
-            getdisplay().print(commonData->status.wifiApOn ? "on" : "off");
-
-            // Home location
-            getdisplay().setCursor(x0, y0 + 128);
-            getdisplay().print("Home Lat.:");
-            getdisplay().setCursor(120, y0 + 128);
-            getdisplay().print(formatLatitude(homelat));
-            getdisplay().setCursor(x0, y0 + 144);
-            getdisplay().print("Home Lon.:");
-            getdisplay().setCursor(120, y0 + 144);
-            getdisplay().print(formatLongitude(homelon));
-
-            // right column
-            getdisplay().setCursor(202, y0);
-            getdisplay().print("Batt. sensor:");
-            getdisplay().setCursor(320, y0);
-            getdisplay().print(batt_sensor);
-
-            // Solar sensor
-            getdisplay().setCursor(202, y0 + 16);
-            getdisplay().print("Solar sensor:");
-            getdisplay().setCursor(320, y0 + 16);
-            getdisplay().print(solar_sensor);
-
-            // Generator sensor
-            getdisplay().setCursor(202, y0 + 32);
-            getdisplay().print("Gen. sensor:");
-            getdisplay().setCursor(320, y0 + 32);
-            getdisplay().print(gen_sensor);
-
-            // Gyro sensor
-
-        } else if (mode == 'C') {
-            // Card info
-            getdisplay().setFont(&Ubuntu_Bold12pt8b);
-            getdisplay().setCursor(8, 48);
-            getdisplay().print("SD Card info");
-
-            getdisplay().setFont(&Ubuntu_Bold8pt8b);
-
-            x0 = 20;
-            y0 = 72;
-            getdisplay().setCursor(x0, y0);
-#ifdef BOARD_OBP60S3
-            // This mode should not be callable by devices without card hardware
-            // In case of accidential reaching this, display a friendly message
-            getdisplay().print("This mode is not indended to be reached!\n");
-            getdisplay().print("There's nothing to see here. Move on.");
-#endif
-#ifdef BOARD_OBP40S3
-            getdisplay().print("Work in progress...");
-
-            /* TODO
-               this code should go somewhere else. only for testing purposes here
-               identify card as OBP-Card:
-                 magic.dat
-                 version.dat
-                 readme.txt
-                 IMAGES/
-                 CHARTS/
-                 LOGS/
-                 DATA/
-                hint: file access with fopen, fgets, fread, fclose
-            */
-
-            // Simple test for magic file in root
-            getdisplay().setCursor(x0, y0 + 32);
-            String file_magic = MOUNT_POINT "/magic.dat";
-            logger->logDebug(GwLog::LOG, "Test magicfile: %s", file_magic.c_str());
-            struct stat st;
-            if (stat(file_magic.c_str(), &st) == 0) {
-                getdisplay().printf("File %s exists", file_magic.c_str());
-            } else {
-                getdisplay().printf("File %s not found", file_magic.c_str());
-            }
-
-            // Root directory check
-            DIR* dir = opendir(MOUNT_POINT);
-            int dy = 0;
-            if (dir != NULL) {
-                logger->logDebug(GwLog::LOG, "Root directory: %s", MOUNT_POINT);
-                struct dirent* entry;
-                while (((entry = readdir(dir)) != NULL) and (dy < 140)) {
-                    getdisplay().setCursor(x0, y0 + 64 + dy);
-                    getdisplay().print(entry->d_name);
-                    // type 1 is file, type 2 is dir
-                    if (entry->d_type == 2) {
-                        getdisplay().print("/");
-                    }
-                    dy += 20;
-                    logger->logDebug(GwLog::DEBUG, "    %s type %d", entry->d_name, entry->d_type);
-                }
-                closedir(dir);
-            } else {
-                logger->logDebug(GwLog::LOG, "Failed to open root directory");
-            }
-
-#endif
-
-        } else {
-            // NMEA2000 device list
-            getdisplay().setFont(&Ubuntu_Bold12pt8b);
-            getdisplay().setCursor(8, 48);
-            getdisplay().print("NMEA2000 device list");
-
-            getdisplay().setFont(&Ubuntu_Bold8pt8b);
-            getdisplay().setCursor(20, 80);
-            getdisplay().print("RxD: ");
-            getdisplay().print(String(commonData->status.n2kRx));
-            getdisplay().setCursor(20, 100);
-            getdisplay().print("TxD: ");
-            getdisplay().print(String(commonData->status.n2kTx));
         }
 
         // Update display
-        getdisplay().nextPage();    // Partial update (fast)
+        displayNextPage();    // Partial update (fast)
         return PAGE_OK;
     };
 };

lib/obp60task/PageThreeValues.cpp

@@ -80,7 +80,7 @@ class PageThreeValues : public Page
         //***********************************************************
 
         /// Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
 
         // ############### Value 1 ################
 

lib/obp60task/PageTwoValues.cpp

@@ -211,8 +211,6 @@ public:
                     dataIntv = 3;
                 } else if (dataIntv == 3) {
                     dataIntv = 4;
-                } else if (dataIntv == 4) {
-                    dataIntv = 8;
                 } else {
                     dataIntv = 1;
                 }
@@ -283,7 +281,7 @@ public:
         // Draw page
         //***********************************************************
 
-        getdisplay().setPartialWindow(0, 0, width, height); // Set partial update
+        displaySetPartialWindow(0, 0, width, height); // Set partial update
 
         if (pageMode == VALUES || (dataHstryBuf[0] == nullptr && dataHstryBuf[1] == nullptr)) {
             // show only data value; ignore other pageMode options if no chart supported boat data history buffer is available

lib/obp60task/PageVoltage.cpp

@@ -2,7 +2,6 @@
 
 #include "Pagedata.h"
 #include "OBP60Extensions.h"
-#include "movingAvg.h"              // Lib for moving average building
 
 class PageVoltage : public Page
 {
@@ -193,7 +192,7 @@ public:
         //***********************************************************
 
         // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
 
         if (mode == 'D') {
             // Display mode digital

lib/obp60task/PageWhite.cpp

@@ -63,7 +63,7 @@ public:
         if (mode == 'W') {
             getdisplay().setFullWindow();
         } else {
-            getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+            displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
         }
 
         if (mode == 'L') {

lib/obp60task/PageWind.cpp

@@ -358,7 +358,7 @@ public:
         //***********************************************************
 
         // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
 
         getdisplay().setTextColor(commonData->fgcolor);
 

lib/obp60task/PageWindPlot.cpp

@@ -37,7 +37,7 @@ private:
     bool oldShowTruW = false; // remember recent user selection of wind data type
 
     int8_t dataIntv = 1; // Update interval for wind history chart:
-                         // (1)|(2)|(3)|(4)|(8) x 240 seconds for 4, 8, 12, 16, 32 min. history chart
+                         // (1)|(2)|(3)|(4)|(8) seconds for up to 32 min. history chart
     bool useSimuData;
     // bool holdValues;
     String flashLED;
@@ -221,7 +221,7 @@ public:
         //***********************************************************
 
         // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, width, height); // Set partial update
+        displaySetPartialWindow(0, 0, width, height); // Set partial update
         getdisplay().setTextColor(commonData->fgcolor);
 
         if (chrtMode == DIRECTION) {
@@ -231,6 +231,9 @@ public:
 
         } else if (chrtMode == SPEED) {
             if (wsChart) {
+                if (dataIntv == 8) {
+                    dataIntv = 1; // horizontal charts show max. 4 x 7 min. only; no factor 8 multiplier
+                }
                 wsChart->showChrt(HORIZONTAL, FULL_SIZE, dataIntv, PRNT_NAME, PRNT_VALUE, *wsBVal);
             }
 

lib/obp60task/PageWindRose.cpp

@@ -140,7 +140,7 @@ public:
         //***********************************************************
 
         // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
 
         getdisplay().setTextColor(commonData->fgcolor);
 
@@ -260,7 +260,7 @@ public:
             // Print text centered on position x, y
             int16_t x1, y1;     // Return values of getTextBounds
             uint16_t w, h;      // Return values of getTextBounds
-            getdisplay().getTextBounds(ii, int(x), int(y), &x1, &y1, &w, &h); // Calc width of new string
+            displayGetTextBounds(ii, int(x), int(y), &x1, &y1, &w, &h); // Calc width of new string
             getdisplay().setCursor(x-w/2, y+h/2);
             if(i % 30 == 0){
                 getdisplay().setFont(&Ubuntu_Bold8pt8b);

lib/obp60task/PageWindRoseFlex.cpp

@@ -200,7 +200,7 @@ public:
         //***********************************************************
 
         // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
 
         getdisplay().setTextColor(commonData->fgcolor);
 
@@ -314,7 +314,7 @@ public:
             // Print text centered on position x, y
             int16_t x1, y1;     // Return values of getTextBounds
             uint16_t w, h;      // Return values of getTextBounds
-            getdisplay().getTextBounds(ii, int(x), int(y), &x1, &y1, &w, &h); // Calc width of new string
+            displayGetTextBounds(ii, int(x), int(y), &x1, &y1, &w, &h); // Calc width of new string
             getdisplay().setCursor(x-w/2, y+h/2);
             if(i % 30 == 0){
                 getdisplay().setFont(&Ubuntu_Bold8pt8b);

lib/obp60task/PageXTETrack.cpp

@@ -89,7 +89,7 @@ class PageXTETrack : public Page
         //***********************************************************
 
         // Set display in partial refresh mode
-        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
 
         getdisplay().setTextColor(commonData->fgcolor);
 
@@ -112,25 +112,25 @@ class PageXTETrack : public Page
 
         GwApi::BoatValue *bv_xte = pageData.values[0]; // XTE
         String sval_xte = formatValue(bv_xte, *commonData).svalue;
-        getdisplay().getTextBounds(sval_xte, 0, 0, &x, &y, &w, &h);
+        displayGetTextBounds(sval_xte, 0, 0, &x, &y, &w, &h);
         getdisplay().setCursor(160-w, 170);
         getdisplay().print(sval_xte);
 
         GwApi::BoatValue *bv_cog = pageData.values[1]; // COG
         String sval_cog = formatValue(bv_cog, *commonData).svalue;
-        getdisplay().getTextBounds(sval_cog, 0, 0, &x, &y, &w, &h);
+        displayGetTextBounds(sval_cog, 0, 0, &x, &y, &w, &h);
         getdisplay().setCursor(360-w, 170);
         getdisplay().print(sval_cog);
 
         GwApi::BoatValue *bv_dtw = pageData.values[2]; // DTW
         String sval_dtw = formatValue(bv_dtw, *commonData).svalue;
-        getdisplay().getTextBounds(sval_dtw, 0, 0, &x, &y, &w, &h);
+        displayGetTextBounds(sval_dtw, 0, 0, &x, &y, &w, &h);
         getdisplay().setCursor(160-w, 257);
         getdisplay().print(sval_dtw);
 
         GwApi::BoatValue *bv_btw = pageData.values[3]; // BTW
         String sval_btw = formatValue(bv_btw, *commonData).svalue;
-        getdisplay().getTextBounds(sval_btw, 0, 0, &x, &y, &w, &h);
+        displayGetTextBounds(sval_btw, 0, 0, &x, &y, &w, &h);
         getdisplay().setCursor(360-w, 257);
         getdisplay().print(sval_btw);
 
@@ -149,7 +149,7 @@ class PageXTETrack : public Page
         }
 
         getdisplay().setFont(&Ubuntu_Bold10pt8b);
-        getdisplay().getTextBounds(sval_wpname, 0, 150, &x, &y, &w, &h);
+        displayGetTextBounds(sval_wpname, 0, 150, &x, &y, &w, &h);
         // TODO if text don't fix use smaller font size.
         // if smallest size does not fit use 2 lines
         // last resort: clip with ellipsis

lib/obp60task/Pagedata.h

@@ -110,7 +110,6 @@ typedef struct{
     AlarmData alarm;
     GwApi::BoatValue *time = nullptr;
     GwApi::BoatValue *date = nullptr;
-    float tz = 0.0; // timezone from config
     uint16_t fgcolor;
     uint16_t bgcolor;
     bool keylock = false;
@@ -127,7 +126,7 @@ class Page{
     virtual void displayNew(PageData &pageData){}
     virtual void leavePage(PageData &pageData){}
     virtual void setupKeys() {
-#ifdef HARDWARE_V21
+#ifdef BOARD_OBP60S3
         commonData->keydata[0].label = "";
         commonData->keydata[1].label = "";
         commonData->keydata[2].label = "#LEFT";

lib/obp60task/code_size.ps1

@@ -0,0 +1,16 @@
+param(
+    [string]$dir = "."
+)
+
+$total = 0
+
+Get-ChildItem -Path $dir -Recurse -File | Where-Object {
+    $_.Extension -in ".c", ".cpp", ".h"
+} | ForEach-Object {
+    $lines = [System.Linq.Enumerable]::Count([System.IO.File]::ReadLines($_.FullName))
+    Write-Output "$($_.FullName) : $lines"
+    $total += $lines
+}
+
+Write-Output "-----------------------------"
+Write-Output "Over all files: $total"

lib/obp60task/config_obp40.json

@@ -75,20 +75,6 @@
             "obp40": "true"
         }
     },
-    {
-        "name": "chainLength",
-        "label": "Anchor Chain Length [m]",
-        "type": "number",
-        "default": "0",
-        "check": "checkMinMax",
-        "min": 0,
-        "max": 255,
-        "description": "The length of the anchor chain [0...255m]",
-        "category": "OBP40 Settings",
-        "capabilities": {
-            "obp40": "true"
-        }
-    },
     {
         "name": "fuelTank",
         "label": "Fuel Tank [l]",
@@ -244,6 +230,17 @@
             "obp40": "true"
         }
     },
+    {
+        "name": "smoothCharts",
+        "label": "Smooth chart lines",
+        "type": "boolean",
+        "default": "false",
+        "description": "Print chart lines with a smoothed gradient",
+        "category": "OBP40 Settings",
+        "capabilities": {
+            "obp40": "true"
+        }
+    },
     {
         "name": "lengthFormat",
         "label": "Length Format",
@@ -692,7 +689,7 @@
         "type": "string",
         "default": "text1",
         "description": "Button name",
-        "category": "OBP40 IO-Modul1",
+        "category": "OBP40 IO-Module1",
         "capabilities": {
             "obp40":"true"
         }
@@ -703,7 +700,7 @@
         "type": "string",
         "default": "text2",
         "description": "Button name",
-        "category": "OBP40 IO-Modul1",
+        "category": "OBP40 IO-Module1",
         "capabilities": {
             "obp40":"true"
         }
@@ -714,7 +711,7 @@
         "type": "string",
         "default": "text3",
         "description": "Button name",
-        "category": "OBP40 IO-Modul1",
+        "category": "OBP40 IO-Module1",
         "capabilities": {
             "obp40":"true"
         }
@@ -725,7 +722,7 @@
         "type": "string",
         "default": "text4",
         "description": "Button name",
-        "category": "OBP40 IO-Modul1",
+        "category": "OBP40 IO-Module1",
         "capabilities": {
             "obp40":"true"
         }
@@ -736,7 +733,7 @@
         "type": "string",
         "default": "text5",
         "description": "Button name",
-        "category": "OBP40 IO-Modul1",
+        "category": "OBP40 IO-Module1",
         "capabilities": {
             "obp40":"true"
         }
@@ -1081,8 +1078,7 @@
         "description": "Type of map source, cloud service or local service",
         "list": [
             "OBP Service",
-            "Local Service",
+            "Local Service"
-            "Remote Service"
         ],
         "category": "OBP40 Navigation",
         "capabilities": {
@@ -1119,34 +1115,6 @@
             { "mapsource": ["Local Service"] }
         ]
     },
-    {
-        "name": "mapServer",
-        "label": "map server",
-        "type": "string",
-        "default": "",
-        "description": "Server for converting map tiles. Use only one hostname or IP address",
-        "category": "OBP40 Navigation",
-        "capabilities": {
-            "obp40": "true"
-        },
-        "condition": [
-            { "mapsource": ["Remote Service"] }
-        ]
-    },
-    {
-        "name": "mapTilePath",
-        "label": "map tile path",
-        "type": "string",
-        "default": "map.php",
-        "description": "Path to converter access e.g. index.php or map.php",
-        "category": "OBP40 Navigation",
-        "capabilities": {
-            "obp40": "true"
-        },
-        "condition": [
-            { "mapsource": ["Remote Service"] }
-        ]
-    },
     {
         "name": "maptype",
         "label": "Map Type",
@@ -1288,8 +1256,8 @@
         "name": "timeSource",
         "label": "Status Time Source",
         "type": "list",
-        "default": "GPS",
+        "default": "iRTC",
-        "description": "Data source for date and time display in status line [RTC|iRTC|GPS]",
+        "description": "Data source for date and time display in status line [iRTC|RTC|GPS]",
         "list": [
             {"l":"Internal real time clock (iRTC)","v":"iRTC"},
             {"l":"External real time clock (RTC)","v":"RTC"},
@@ -1552,6 +1520,7 @@
             "obp40": "true"
         }
     },
+
     {
         "name": "page1type",
         "label": "Type",
@@ -1559,7 +1528,7 @@
         "default": "Voltage",
         "description": "Type of page for page 1",
         "list": [
-            "Anchor",
+            "Autopilot",
             "BME280",
             "Battery",
             "Battery2",
@@ -1890,7 +1859,7 @@
         "default": "WindRose",
         "description": "Type of page for page 2",
         "list": [
-            "Anchor",
+            "Autopilot",
             "BME280",
             "Battery",
             "Battery2",
@@ -2212,7 +2181,7 @@
         "default": "OneValue",
         "description": "Type of page for page 3",
         "list": [
-            "Anchor",
+            "Autopilot",
             "BME280",
             "Battery",
             "Battery2",
@@ -2525,7 +2494,7 @@
         "default": "TwoValues",
         "description": "Type of page for page 4",
         "list": [
-            "Anchor",
+            "Autopilot",
             "BME280",
             "Battery",
             "Battery2",
@@ -2829,7 +2798,7 @@
         "default": "ThreeValues",
         "description": "Type of page for page 5",
         "list": [
-            "Anchor",
+            "Autopilot",
             "BME280",
             "Battery",
             "Battery2",
@@ -3124,7 +3093,7 @@
         "default": "FourValues",
         "description": "Type of page for page 6",
         "list": [
-            "Anchor",
+            "Autopilot",
             "BME280",
             "Battery",
             "Battery2",
@@ -3410,7 +3379,7 @@
         "default": "FourValues2",
         "description": "Type of page for page 7",
         "list": [
-            "Anchor",
+            "Autopilot",
             "BME280",
             "Battery",
             "Battery2",
@@ -3687,7 +3656,7 @@
         "default": "Clock",
         "description": "Type of page for page 8",
         "list": [
-            "Anchor",
+            "Autopilot",
             "BME280",
             "Battery",
             "Battery2",
@@ -3955,7 +3924,7 @@
         "default": "RollPitch",
         "description": "Type of page for page 9",
         "list": [
-            "Anchor",
+            "Autopilot",
             "BME280",
             "Battery",
             "Battery2",
@@ -4214,7 +4183,7 @@
         "default": "Battery2",
         "description": "Type of page for page 10",
         "list": [
-            "Anchor",
+            "Autopilot",
             "BME280",
             "Battery",
             "Battery2",

lib/obp60task/config_obp60.json

@@ -75,20 +75,6 @@
             "obp60":"true"
         }
     },
-    {
-        "name": "chainLength",
-        "label": "Anchor Chain Length [m]",
-        "type": "number",
-        "default": "0",
-        "check": "checkMinMax",
-        "min": 0,
-        "max": 255,
-        "description": "The length of the anchor chain [0...255m]",
-        "category": "OBP60 Settings",
-        "capabilities": {
-            "obp60":"true"
-        }
-    },
     {
         "name": "fuelTank",
         "label": "Fuel Tank [l]",
@@ -244,6 +230,17 @@
             "obp60": "true"
         }
     },
+    {
+        "name": "smoothCharts",
+        "label": "Smooth chart lines",
+        "type": "boolean",
+        "default": "false",
+        "description": "Print chart lines with a smoothed gradient",
+        "category": "OBP60 Settings",
+        "capabilities": {
+            "obp40": "true"
+        }
+    },
     {
         "name": "lengthFormat",
         "label": "Length Format",
@@ -1107,34 +1104,6 @@
             { "mapsource": ["Local Service"] }
         ]
     },
-    {
-        "name": "mapServer",
-        "label": "map server",
-        "type": "string",
-        "default": "",
-        "description": "Server for converting map tiles. Use only one hostname or IP address",
-        "category": "OBP60 Navigation",
-        "capabilities": {
-            "obp60": "true"
-        },
-        "condition": [
-            { "mapsource": ["Remote Service"] }
-        ]
-    },
-    {
-        "name": "mapTilePath",
-        "label": "map tile path",
-        "type": "string",
-        "default": "map.php",
-        "description": "Path to converter access e.g. index.php or map.php",
-        "category": "OBP40 Navigation",
-        "capabilities": {
-            "obp40": "true"
-        },
-        "condition": [
-            { "mapsource": ["Remote Service"] }
-        ]
-    },
     {
         "name": "maptype",
         "label": "Map Type",
@@ -1277,8 +1246,9 @@
         "label": "Status Time Source",
         "type": "list",
         "default": "GPS",
-        "description": "Data source for date and time display in status line [RTC|GPS]",
+        "description": "Data source for date and time display in status line [iRTC|RTC|GPS]",
         "list": [
+            {"l":"Internal real time clock (iRTC)","v":"iRTC"},
             {"l":"Real time clock (RTC)","v":"RTC"},
             {"l":"Time via bus (GPS)","v":"GPS"}
         ],
@@ -1528,6 +1498,7 @@
             "obp60":"true"
         }
     },
+
     {
         "name": "page1type",
         "label": "Type",
@@ -1535,7 +1506,7 @@
         "default": "Voltage",
         "description": "Type of page for page 1",
         "list": [
-            "Anchor",
+            "Autopilot",
             "BME280",
             "Battery",
             "Battery2",
@@ -1836,7 +1807,7 @@
         "default": "WindRose",
         "description": "Type of page for page 2",
         "list": [
-            "Anchor",
+            "Autopilot",
             "BME280",
             "Battery",
             "Battery2",
@@ -2129,7 +2100,7 @@
         "default": "OneValue",
         "description": "Type of page for page 3",
         "list": [
-            "Anchor",
+            "Autopilot",
             "BME280",
             "Battery",
             "Battery2",
@@ -2414,7 +2385,7 @@
         "default": "TwoValues",
         "description": "Type of page for page 4",
         "list": [
-            "Anchor",
+            "Autopilot",
             "BME280",
             "Battery",
             "Battery2",
@@ -2691,7 +2662,7 @@
         "default": "ThreeValues",
         "description": "Type of page for page 5",
         "list": [
-            "Anchor",
+            "Autopilot",
             "BME280",
             "Battery",
             "Battery2",
@@ -2960,7 +2931,7 @@
         "default": "FourValues",
         "description": "Type of page for page 6",
         "list": [
-            "Anchor",
+            "Autopilot",
             "BME280",
             "Battery",
             "Battery2",
@@ -3221,7 +3192,7 @@
         "default": "FourValues2",
         "description": "Type of page for page 7",
         "list": [
-            "Anchor",
+            "Autopilot",
             "BME280",
             "Battery",
             "Battery2",
@@ -3474,7 +3445,7 @@
         "default": "Clock",
         "description": "Type of page for page 8",
         "list": [
-            "Anchor",
+            "Autopilot",
             "BME280",
             "Battery",
             "Battery2",
@@ -3719,7 +3690,7 @@
         "default": "RollPitch",
         "description": "Type of page for page 9",
         "list": [
-            "Anchor",
+            "Autopilot",
             "BME280",
             "Battery",
             "Battery2",
@@ -3956,7 +3927,7 @@
         "default": "Battery2",
         "description": "Type of page for page 10",
         "list": [
-            "Anchor",
+            "Autopilot",
             "BME280",
             "Battery",
             "Battery2",

lib/obp60task/debugging.txt

@@ -3,4 +3,7 @@ Debugging tool
 
 log.txt = text file with error messages from terminal console
 
+cd /home/norbert/esp32-nmea2000-obp60
 tools/decoder.py -p ESP32S3 -t ~/.platformio/packages/toolchain-xtensa-esp32s3/ -e .pio/build/obp60_s3/firmware.elf log.txt
+
+tools/decoder.py -p ESP32S3 -t ~/.platformio/packages/toolchain-xtensa-esp32s3/ -e .pio/build/obp70_s3/firmware.elf /home/norbert/Dokumente/Multifunktionsdisplay_OBP60/Crashes/20260313/log.txt

lib/obp60task/extra_task.py

@@ -2,6 +2,14 @@
 
 import subprocess
 
+def cleanup_patches(source, target, env):
+    for p in patchfiles:
+        patch = os.path.join(patchdir, p)
+        print(f"removing {patch}")
+        res = subprocess.run(["git", "apply", "-R", patch], capture_output=True, text=True)
+        if res.returncode != 0:
+            print(res.stderr)
+
 patching = False
 
 epdtype = "unknown"
@@ -46,11 +54,13 @@ if patching:
         print("patchdir not found, no patches applied")
     else:
         patchfiles = [f for f in os.listdir(patchdir)]
-        for p in patchfiles:
+        if len(patchfiles) > 0:
-            patch = os.path.join(patchdir, p)
+            for p in patchfiles:
-            print(f"applying {patch}")
+                patch = os.path.join(patchdir, p)
-            res = subprocess.run(["git", "apply", patch], capture_output=True, text=True)
+                print(f"applying {patch}")
-            if res.returncode != 0:
+                res = subprocess.run(["git", "apply", patch], capture_output=True, text=True)
-                print(res.stderr)
+                if res.returncode != 0:
+                    print(res.stderr)
+            env.AddPostAction("$PROGPATH", cleanup_patches)
         else:
             print("no patches found")

lib/obp60task/movingAvg.cpp

@@ -1,67 +0,0 @@
-// Arduino Moving Average Library
-// https://github.com/JChristensen/movingAvg
-// Copyright (C) 2018 by Jack Christensen and licensed under
-// GNU GPL v3.0, https://www.gnu.org/licenses/gpl.html
-
-#include <movingAvg.h>
-
-// initialize - allocate the interval array
-void movingAvg::begin()
-{
-    m_readings = new int[m_interval];
-}
-
-// add a new reading and return the new moving average
-int movingAvg::reading(int newReading)
-{
-    // add each new data point to the sum until the m_readings array is filled
-    if (m_nbrReadings < m_interval) {
-        ++m_nbrReadings;
-        m_sum += newReading;
-    }
-    // once the array is filled, subtract the oldest data point and add the new one
-    else {
-        m_sum = m_sum - m_readings[m_next] + newReading;
-    }
-
-    m_readings[m_next] = newReading;
-    if (++m_next >= m_interval) m_next = 0;
-    return (m_sum + m_nbrReadings / 2) / m_nbrReadings;
-}
-
-// just return the current moving average
-int movingAvg::getAvg()
-{
-    return (m_sum + m_nbrReadings / 2) / m_nbrReadings;
-}
-
-// return the average for a subset of the data, the most recent nPoints readings.
-// for invalid values of nPoints, return zero.
-int movingAvg::getAvg(int nPoints)
-{
-    if (nPoints < 1 || nPoints > m_interval || nPoints > m_nbrReadings) {
-        return 0;
-    }
-    else {
-        long sum{0};
-        int i = m_next;
-        for (int n=0; n<nPoints; ++n) {
-            if (i == 0) {
-                i = m_interval - 1;
-            }
-            else {
-                --i;
-            }
-            sum += m_readings[i];
-        }
-        return (sum + nPoints / 2) / nPoints;
-    }
-}
-
-// start the moving average over again
-void movingAvg::reset()
-{
-    m_nbrReadings = 0;
-    m_sum = 0;
-    m_next = 0;
-}

lib/obp60task/movingAvg.h

@@ -3,27 +3,37 @@
 // Copyright (C) 2018 by Jack Christensen and licensed under
 // GNU GPL v3.0, https://www.gnu.org/licenses/gpl.html
 
+// Extended to template class for handling of multiple data types
+
 #ifndef MOVINGAVG_H_INCLUDED
 #define MOVINGAVG_H_INCLUDED
 
+template <typename T>
 class movingAvg
 {
     public:
         movingAvg(int interval)
-            : m_interval{interval}, m_nbrReadings{0}, m_sum{0}, m_next{0} {}
+            : m_interval{interval}, m_nbrReadings{0}, m_sum{0}, m_next{0}, m_readings{nullptr} {}
+        ~movingAvg() { delete[] m_readings; }
         void begin();
-        int reading(int newReading);
+        T reading(T newReading);
-        int getAvg();
+        T getAvg();
-        int getAvg(int nPoints);
+        T getAvg(int nPoints);
-        int getCount() {return m_nbrReadings;}
+        int getCount() { return m_nbrReadings; }
         void reset();
-        int* getReadings() {return m_readings;}
+        T* getReadings() { return m_readings; }
 
     private:
         int m_interval;     // number of data points for the moving average
         int m_nbrReadings;  // number of readings
-        long m_sum;         // sum of the m_readings array
+        // Sum type adapts to T: long for integers, T for floating point
+        using SumType = typename std::conditional<std::is_floating_point<T>::value, T, long>::type;
+        SumType m_sum;
         int m_next;         // index to the next reading
-        int* m_readings;    // pointer to the dynamically allocated interval array
+        T* m_readings;      // pointer to the dynamically allocated interval array
 };
+
+// Include the implementation to satisfy template instantiation requirements
+#include "movingAvg.tpp"
+
 #endif

lib/obp60task/movingAvg.tpp

@@ -0,0 +1,88 @@
+// Arduino Moving Average Library
+// https://github.com/JChristensen/movingAvg
+// Copyright (C) 2018 by Jack Christensen and licensed under
+// GNU GPL v3.0, https://www.gnu.org/licenses/gpl.html
+
+// Extended to template class for handling of multiple data types
+
+//template <typename T>
+//movingAvg<T>::movingAvg(int interval)
+//    : m_interval{interval}, m_nbrReadings{0}, m_sum{0}, m_next{0}, m_readings{nullptr}
+//{}
+
+// initialize - allocate the interval array
+template <typename T>
+void movingAvg<T>::begin()
+{
+    m_readings = new T[m_interval];
+}
+
+// add a new reading and return the new moving average
+template <typename T>
+T movingAvg<T>::reading(T newReading)
+{
+    // add each new data point to the sum until the m_readings array is filled
+    if (m_nbrReadings < m_interval) {
+        ++m_nbrReadings;
+        m_sum += newReading;
+    }
+    // once the array is filled, subtract the oldest data point and add the new one
+    else {
+        m_sum = m_sum - m_readings[m_next] + newReading;
+    }
+
+    m_readings[m_next] = newReading;
+    if (++m_next >= m_interval) m_next = 0;
+    return getAvg();
+}
+
+// just return the current moving average
+template <typename T>
+T movingAvg<T>::getAvg()
+{
+    if (m_nbrReadings == 0) return 0;
+
+    // Apply rounding for integers only
+    if (std::is_floating_point<T>::value) {
+        return m_sum / m_nbrReadings;
+    } else {
+        return (m_sum + (SumType)m_nbrReadings / 2) / m_nbrReadings;
+    }
+}
+
+// return the average for a subset of the data, the most recent nPoints readings.
+// for invalid values of nPoints, return zero.
+template <typename T>
+T movingAvg<T>::getAvg(int nPoints)
+{
+    if (nPoints < 1 || nPoints > m_interval || nPoints > m_nbrReadings) {
+        return 0;
+    }
+
+    SumType sum{0};
+    int i = m_next;
+    for (int n=0; n<nPoints; ++n) {
+        if (i == 0) {
+            i = m_interval - 1;
+        }
+        else {
+            --i;
+        }
+        sum += m_readings[i];
+    }
+
+    if (std::is_floating_point<T>::value) {
+        return sum / nPoints;
+    } else {
+        return (sum + (SumType)nPoints / 2) / nPoints; //
+    }
+}
+
+// start the moving average over again
+template <typename T>
+void movingAvg<T>::reset()
+{
+    m_nbrReadings = 0;
+    m_sum = 0;
+    m_next = 0;
+}

lib/obp60task/obp60task.cpp

@@ -9,7 +9,6 @@
 #include <NMEA0183.h>                   // NMEA0183
 #include <NMEA0183Msg.h>
 #include <NMEA0183Messages.h>
-#include <GxEPD2_BW.h>                  // GxEPD2 lib for b/w E-Ink displays
 #include "OBP60Extensions.h"            // Functions lib for extension board
 #include "OBP60Keypad.h"                // Functions for keypad
 #include "OBPDataOperations.h"          // Functions lib for data operations such as true wind calculation
@@ -264,8 +263,6 @@ void registerAllPages(PageList &list){
     list.add(&registerPageDigitalOut);
     extern PageDescription registerPageAutopilot;
     list.add(&registerPageAutopilot);
-    extern PageDescription registerPageAnchor;
-    list.add(&registerPageAnchor);
 }
 
 // Undervoltage detection for shutdown display
@@ -286,8 +283,12 @@ void underVoltageError(CommonData &common) {
     getdisplay().setFont(&Ubuntu_Bold8pt8b);
     getdisplay().setCursor(65, 175);
     getdisplay().print("Charge battery and restart system");
-    getdisplay().nextPage();                // Partial update
+    displayNextPage();                // Partial update
+    #ifdef TFT_DISPLAY
+    getpaneldisplay().powerSave(true);      // Display power save
+    #else
     getdisplay().powerOff();                // Display power off
+    #endif
     setPortPin(OBP_POWER_EPD, false);       // Power off ePaper display
     setPortPin(OBP_POWER_SD, false);        // Power off SD card
 #else
@@ -297,7 +298,7 @@ void underVoltageError(CommonData &common) {
     buzzer(TONE4, 20);                      // Buzzer tone 4kHz 20ms
     setPortPin(OBP_POWER_50, false);        // Power rail 5.0V Off
     // Shutdown EInk display
-    getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+    displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
     getdisplay().fillScreen(common.bgcolor);// Clear screen
     getdisplay().setTextColor(common.fgcolor);
     getdisplay().setFont(&Ubuntu_Bold20pt8b);
@@ -306,8 +307,12 @@ void underVoltageError(CommonData &common) {
     getdisplay().setFont(&Ubuntu_Bold8pt8b);
     getdisplay().setCursor(65, 175);
     getdisplay().print("To wake up repower system");
-    getdisplay().nextPage();                // Partial update
+    displayNextPage();                // Partial update
+    #ifdef TFT_DISPLAY
+    getpaneldisplay().powerSave(true);      // Display power save
+    #else
     getdisplay().powerOff();                // Display power off
+    #endif
 #endif
     while (true) {
         esp_deep_sleep_start(); // Deep Sleep without wakeup. Wakeup only after power cycle (restart).
@@ -318,7 +323,7 @@ inline bool underVoltageDetection(float voffset, float vslope) {
     // Read supply voltage
 #if defined VOLTAGE_SENSOR && defined LIPO_ACCU_1200
     float actVoltage = (float(analogRead(OBP_ANALOG0)) * 3.3 / 4096 + 0.53) * 2;   // Vin = 1/2 for OBP40
-    float minVoltage = 3.65;  // Absolut minimum volatge for 3,7V LiPo accu
+    float minVoltage = 3.65;  // Absolut minimum voltage for 3,7V LiPo accu
 #else
     float actVoltage = (float(analogRead(OBP_ANALOG0)) * 3.3 / 4096 + 0.17) * 20;   // Vin = 1/20 for OBP60
     float minVoltage = MIN_VOLTAGE;
@@ -327,6 +332,7 @@ inline bool underVoltageDetection(float voffset, float vslope) {
     return (calVoltage < minVoltage);
 }
 
+
 // OBP60 Task
 //####################################################################################
 void OBP60Task(GwApi *api){
@@ -334,7 +340,7 @@ void OBP60Task(GwApi *api){
 //    return;
     GwLog *logger=api->getLogger();
     GwConfigHandler *config=api->getConfig();
-#if defined HARDWARE_V20 || HARDWARE_V21
+#ifdef BOARD_OBP60S3
     startLedTask(api);
 #endif
     PageList allPages;
@@ -343,7 +349,7 @@ void OBP60Task(GwApi *api){
     commonData.logger=logger;
     commonData.config=config;
 
-#if defined HARDWARE_V20 || HARDWARE_V21
+#ifdef BOARD_OBP60S3
     // Keyboard coordinates for page footer
     initKeys(commonData);
 #endif
@@ -377,36 +383,47 @@ void OBP60Task(GwApi *api){
 
     #ifdef DISPLAY_GDEY042T81
         getdisplay().init(115200, true, 2, false);  // Init for Waveshare boards with "clever" reset circuit, 2ms reset pulse
+    #elif defined(TFT_DISPLAY)
+        getpaneldisplay().init();                   // Init for TFT LCD panel
     #else
         getdisplay().init(115200);                  // Init for normal displays
     #endif
 
+    #ifdef TFT_DISPLAY
+    getpaneldisplay().setRotation(0);            // Set display orientation (horizontal)
+    getpaneldisplay().setPanelOffset(0, 0);      // Use full native framebuffer coordinates
+    getpaneldisplay().fillScreen(0x0000);        // Initialize full TFT screen to black (native RGB565)
+    getpaneldisplay().setPanelOffset(OBP_TFT_OFFSET_X, OBP_TFT_OFFSET_Y); // Restore configured operating panel offset
+    #else
     getdisplay().setRotation(0);                 // Set display orientation (horizontal)
-    getdisplay().setFullWindow();                // Set full Refresh
+    #endif
-    getdisplay().firstPage();                    // set first page
+    displaySetFullWindow();                       // Set full Refresh (E-Ink only)
+    displayFirstPage();                           // set first page
     getdisplay().fillScreen(commonData.bgcolor);
     getdisplay().setTextColor(commonData.fgcolor);
-    getdisplay().nextPage();                     // Full Refresh
+    displayNextPage();                            // Full Refresh
-    getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+    displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update (E-Ink only)
     getdisplay().fillScreen(commonData.bgcolor);
-    getdisplay().nextPage();                     // Fast Refresh
+    displayNextPage();                            // Fast Refresh
-    getdisplay().nextPage();                     // Fast Refresh
+    displayNextPage();                            // Fast Refresh
     if(String(displaymode) == "Logo + QR Code" || String(displaymode) == "Logo"){
         getdisplay().fillScreen(commonData.bgcolor);
-        getdisplay().drawBitmap(0, 0, gImage_Logo_OBP_400x300_sw, getdisplay().width(), getdisplay().height(), commonData.fgcolor); // Draw start logo
+        // draw the fixed-size logo via generic display wrapper
-        getdisplay().nextPage();                 // Fast Refresh
+        displayDrawBitmap(0, 0, gImage_Logo_OBP_400x300_sw,
-        getdisplay().nextPage();                 // Fast Refresh
+                          400, 300, commonData.fgcolor);
+        displayNextPage();                 // Fast Refresh
+        displayNextPage();                 // Fast Refresh
         delay(SHOW_TIME);                        // Logo show time
         if(String(displaymode) == "Logo + QR Code"){
             getdisplay().fillScreen(commonData.bgcolor);
             qrWiFi(systemname, wifipass, commonData.fgcolor, commonData.bgcolor);  // Show QR code for WiFi connection
-            getdisplay().nextPage();             // Fast Refresh
+            displayNextPage();             // Fast Refresh
-            getdisplay().nextPage();             // Fast Refresh
+            displayNextPage();             // Fast Refresh
             delay(SHOW_TIME);                    // QR code show time
         }
         getdisplay().fillScreen(commonData.bgcolor);
-        getdisplay().nextPage();                 // Fast Refresh
+        displayNextPage();                 // Fast Refresh
-        getdisplay().nextPage();                 // Fast Refresh
+        displayNextPage();                 // Fast Refresh
     }
     
     // Init pages
@@ -434,7 +451,7 @@ void OBP60Task(GwApi *api){
 #endif
     LOG_DEBUG(GwLog::LOG,"...done");
 
-    int lastPage=-1; // initialize with an impiossible value, so we can detect wether we are during startup and no page has been displayed yet
+    int lastPage=-1; // initialize with an impossible value, so we can detect wether we are during startup and no page has been displayed yet
 
     BoatValueList boatValues; //all the boat values for the api query
     HstryBuffers hstryBufferList(1920, &boatValues, logger);  // Create empty list of boat data history buffers (1.920 values = seconds = 32 min.)
@@ -481,7 +498,8 @@ void OBP60Task(GwApi *api){
             pages[i].parameters.values.push_back(value); 
        }
 
-       // Read the specified boat data types of relevant pages and create a history buffer for each type
+       // Read the specified boat data types of relevant pages and create a history buffer for each type for later use in charts
+       // applies only for pages that uses charts
        if (pages[i].parameters.pageName == "OneValue" || pages[i].parameters.pageName == "TwoValues" || pages[i].parameters.pageName == "WindPlot") {
            for (auto pVal : pages[i].parameters.values) {
                 hstryBufferList.addBuffer(pVal->getName());
@@ -527,8 +545,8 @@ void OBP60Task(GwApi *api){
     // Configuration values for main loop
     String gpsFix = api->getConfig()->getConfigItem(api->getConfig()->flashLED,true)->asString();
     String gpsOn=api->getConfig()->getConfigItem(api->getConfig()->useGPS,true)->asString();
+    float tz = api->getConfig()->getConfigItem(api->getConfig()->timeZone,true)->asFloat();
 
-    commonData.tz = api->getConfig()->getConfigItem(api->getConfig()->timeZone,true)->asFloat();
     commonData.backlight.mode = backlightMapping(config->getConfigItem(config->backlight,true)->asString());
     commonData.backlight.color = colorMapping(config->getConfigItem(config->blColor,true)->asString());
     commonData.backlight.brightness = uint(config->getConfigItem(config->blBrightness,true)->asInt());
@@ -703,7 +721,7 @@ void OBP60Task(GwApi *api){
                 starttime5 = millis();
                 if(time->valid == true && date->valid == true && lat->valid == true && lon->valid == true){
                     // Provide sundata to all pages
-                    commonData.sundata = calcSunsetSunrise(time->value , date->value, lat->value, lon->value, commonData.tz);
+                    commonData.sundata = calcSunsetSunrise(time->value , date->value, lat->value, lon->value, tz);
                     // Backlight with sun control
                     if (commonData.backlight.mode == BacklightMode::SUN) {
                     // if(String(backlight) == "Control by Sun"){
@@ -716,7 +734,7 @@ void OBP60Task(GwApi *api){
                     }
                 } else if (homevalid and commonData.data.rtcValid) {
                     // No gps fix but valid home location and time configured
-                    commonData.sundata = calcSunsetSunriseRTC(&commonData.data.rtcTime, homelat, homelon, commonData.tz);
+                    commonData.sundata = calcSunsetSunriseRTC(&commonData.data.rtcTime, homelat, homelon, tz);
                 }
             }
             
@@ -724,25 +742,29 @@ void OBP60Task(GwApi *api){
             if(millis() > starttime4 + 8000 && delayedDisplayUpdate == true){
                 starttime1 = millis();
                 starttime2 = millis();
-                getdisplay().setFullWindow();    // Set full update
+                displaySetFullWindow();            // Set full update
+                #ifdef TFT_DISPLAY
+                // TFT LCD doesn't need refresh operations
+                #else
                 if(fastrefresh == "true"){
-                    getdisplay().nextPage();                     // Full update
+                    displayNextPage();                     // Full update
                 }
                 else{
                     getdisplay().fillScreen(commonData.fgcolor); // Clear display
                     #ifdef DISPLAY_GDEY042T81
-                        getdisplay().hibernate();                  // Set display in hybenate mode
+                        getdisplay().hibernate();                  // Set display in hibenate mode
                         getdisplay().init(115200, true, 2, false); // Init for Waveshare boards with "clever" reset circuit, 2ms reset pulse
                     #else
                         getdisplay().init(115200);               // Init for normal displays
                     #endif
-                    getdisplay().firstPage();                    // Full update
+                    displayFirstPage();                    // Full update
-                    getdisplay().nextPage();                     // Full update
+                    displayNextPage();                     // Full update
 //                    getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
 //                    getdisplay().fillScreen(commonData.bgcolor); // Clear display
 //                    getdisplay().nextPage();                     // Partial update
 //                    getdisplay().nextPage();                     // Partial update
                 }
+                #endif
                 delayedDisplayUpdate = false;
             }
 
@@ -752,31 +774,38 @@ void OBP60Task(GwApi *api){
                 starttime1 = millis();
                 starttime2 = millis();
                 LOG_DEBUG(GwLog::DEBUG,"E-Ink full refresh first 5 min");
-                getdisplay().setFullWindow();    // Set full update
+                displaySetFullWindow();            // Set full update
+                #ifdef TFT_DISPLAY
+                // TFT LCD doesn't need refresh operations
+                #else
                 if(fastrefresh == "true"){
-                    getdisplay().nextPage();                     // Full update
+                    displayNextPage();                     // Full update
                 }
                 else{
                     getdisplay().fillScreen(commonData.fgcolor); // Clear display
                     #ifdef DISPLAY_GDEY042T81
-                        getdisplay().hibernate();                  // Set display in hybenate mode
+                        getdisplay().hibernate();                  // Set display in hibernate mode
                         getdisplay().init(115200, true, 2, false); // Init for Waveshare boards with "clever" reset circuit, 2ms reset pulse
                     #else
                         getdisplay().init(115200);               // Init for normal displays
                     #endif
-                    getdisplay().firstPage();                    // Full update
+                    displayFirstPage();                    // Full update
-                    getdisplay().nextPage();                     // Full update
+                    displayNextPage();                     // Full update
 //                    getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
 //                    getdisplay().fillScreen(commonData.bgcolor); // Clear display
 //                    getdisplay().nextPage();                     // Partial update
 //                    getdisplay().nextPage();                     // Partial update
                 }
+                #endif
             }
 
             // Subtask E-Ink full refresh
             if(millis() > starttime2 + fullrefreshtime * 60 * 1000){
                 starttime2 = millis();
                 LOG_DEBUG(GwLog::DEBUG,"E-Ink full refresh");
+                #ifdef TFT_DISPLAY
+                // TFT LCD: no special refresh
+                #else
                 getdisplay().setFullWindow();    // Set full update
                 if(fastrefresh == "true"){
                     getdisplay().nextPage();                     // Full update
@@ -784,7 +813,7 @@ void OBP60Task(GwApi *api){
                 else{
                     getdisplay().fillScreen(commonData.fgcolor); // Clear display
                     #ifdef DISPLAY_GDEY042T81
-                        getdisplay().hibernate();                  // Set display in hybenate mode
+                        getdisplay().hibernate();                  // Set display in hibernate mode
                         getdisplay().init(115200, true, 2, false); // Init for Waveshare boards with "clever" reset circuit, 2ms reset pulse
                     #else
                         getdisplay().init(115200);               // Init for normal displays
@@ -796,6 +825,7 @@ void OBP60Task(GwApi *api){
 //                    getdisplay().nextPage();                     // Partial update
 //                    getdisplay().nextPage();                     // Partial update
                 }
+                #endif
             }        
                 
             // Refresh display data, default all 1s
@@ -808,16 +838,15 @@ void OBP60Task(GwApi *api){
             if(millis() > starttime3 + pagetime){
                 LOG_DEBUG(GwLog::DEBUG,"Page with refreshtime=%d", pagetime);
                 starttime3 = millis();
+                bool pageChanged = (lastPage != pageNumber);
 
                 //refresh data from api
                 api->getBoatDataValues(boatValues.numValues,boatValues.allBoatValues);
                 api->getStatus(commonData.status);
 
-                if (calcTrueWnds) {
+                trueWind.handleWinds(calcTrueWnds); // calculate true wind data from apparent wind values
-                    trueWind.addWinds(); // calculate true wind data from apparent wind values
-                }
                 calibrationDataList.handleCalibration(&boatValues); // Process calibration for all boat data in <calibrationDataList>
-                hstryBufferList.handleHstryBufs(useSimuData, commonData); // Handle history buffers for certain boat data for windplot page and other usage
+                hstryBufferList.handleHstryBufs(useSimuData, commonData); // Handle history buffers for certain boat data for charts and other usage
 
                 // Clear display
                 // getdisplay().fillRect(0, 0, getdisplay().width(), getdisplay().height(), commonData.bgcolor);
@@ -844,16 +873,16 @@ void OBP60Task(GwApi *api){
                     if (currentPage == NULL){
                         LOG_DEBUG(GwLog::ERROR,"page number %d not found", pageNumber);
                         // Error handling for missing page
-                        getdisplay().setPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
+                        displaySetPartialWindow(0, 0, getdisplay().width(), getdisplay().height()); // Set partial update
                         getdisplay().fillScreen(commonData.bgcolor);  // Clear display
                         getdisplay().drawXBitmap(200 - unknown_width / 2, 150 - unknown_height / 2, unknown_bits, unknown_width, unknown_height, commonData.fgcolor);
                         getdisplay().setCursor(140, 250);
                         getdisplay().setFont(&Atari16px);
                         getdisplay().print("Here be dragons!");
-                        getdisplay().nextPage(); // Partial update (fast)
+                        displayNextPage(); // Partial update (fast)
                     }
                     else{
-                        if (lastPage != pageNumber){
+                        if (pageChanged){
 			    if (lastPage != -1){ // skip cleanup if we are during startup, and no page has been displayed yet. 
                                 pages[lastPage].page->leavePage(pages[lastPage].parameters); // call page cleanup code
                                 if (hasFRAM) fram.write(FRAM_PAGE_NO, pageNumber); // remember new page for device restart
@@ -873,10 +902,12 @@ void OBP60Task(GwApi *api){
                             displayAlarm(commonData);
                         }
                         if (ret & PAGE_UPDATE) {
-                            getdisplay().nextPage(); // Partial update (fast)
+                            displayNextPage(); // Partial update (fast)
                         }
                         if (ret & PAGE_HIBERNATE) {
+    #ifndef TFT_DISPLAY
                             getdisplay().hibernate();
+    #endif
                         }
                     }
 

lib/obp60task/obp60task.h

@@ -3,7 +3,7 @@
 //we only compile for some boards
 #if defined BOARD_OBP60S3 || defined BOARD_OBP40S3
     #define USBSerial Serial
-    #ifdef HARDWARE_V21
+    #ifdef BOARD_OBP60S3
         // CAN NMEA2000
         #define ESP32_CAN_TX_PIN 46
         #define ESP32_CAN_RX_PIN 3
@@ -35,13 +35,19 @@
     // OBP60 Task
     void OBP60Task(GwApi *param);
     DECLARE_USERTASK_PARAM(OBP60Task, 35000);   // Need 35k RAM as stack size
-    #ifdef HARDWARE_V21
+    #if defined(BOARD_OBP60S3) && defined(TFT_DISPLAY)
+    DECLARE_CAPABILITY(obp70,true);
+    #endif
+    #if defined(BOARD_OBP60S3) && !defined(TFT_DISPLAY)
     DECLARE_CAPABILITY(obp60,true);
     #endif
     #ifdef BOARD_OBP40S3
     DECLARE_CAPABILITY(obp40,true)
     #endif
-    #ifdef BOARD_OBP60S3
+    #if defined(BOARD_OBP60S3) && defined(TFT_DISPLAY)
+    DECLARE_STRING_CAPABILITY(HELP_URL, "https://obp60-v2-docu.readthedocs.io/en/latest/"); // Link to help pages
+    #endif
+    #if defined(BOARD_OBP60S3) && !defined(TFT_DISPLAY)
     DECLARE_STRING_CAPABILITY(HELP_URL, "https://obp60-v2-docu.readthedocs.io/en/latest/"); // Link to help pages
     #endif
     #ifdef BOARD_OBP40S3

lib/obp60task/patches/01-nmea2000.patch

@@ -0,0 +1,103 @@
+diff --git a/lib/api/GwApi.h b/lib/api/GwApi.h
+index 88f9690..9663a65 100644
+--- a/lib/api/GwApi.h
++++ b/lib/api/GwApi.h
+@@ -2,6 +2,8 @@
+ #define _GWAPI_H
+ #include "GwMessage.h"
+ #include "N2kMsg.h"
++#include "Nmea2kTwai.h"
++#include "N2kDeviceList.h"
+ #include "NMEA0183Msg.h"
+ #include "GWConfig.h"
+ #include "GwBoatData.h"
+@@ -222,6 +224,8 @@ class GwApi{
+          * accessing boat data must only be executed from within the main thread
+          * you need to use the request pattern as shown in GwExampleTask.cpp
+          */
++        virtual Nmea2kTwai *getNMEA2000()=0;
++        virtual tN2kDeviceList *getN2kDeviceList()=0;
+         virtual GwBoatData *getBoatData()=0;
+         virtual ~GwApi(){}
+ };
+diff --git a/lib/obp60task/OBP60Extensions.h b/lib/obp60task/OBP60Extensions.h
+index 9e2bc99..34eaeac 100644
+--- a/lib/obp60task/OBP60Extensions.h
++++ b/lib/obp60task/OBP60Extensions.h
+@@ -29,6 +29,9 @@
+     #define MOUNT_POINT "/sdcard"
+ #endif
+ 
++// Patches to apply to gateway code
++#define PATCH_N2K
++
+ // FRAM address reservations 32kB: 0x0000 - 0x7FFF
+ // 0x0000 - 0x03ff: single variables
+ #define FRAM_PAGE_NO 0x0002
+diff --git a/lib/usercode/GwUserCode.cpp b/lib/usercode/GwUserCode.cpp
+index 1b007f8..90087d4 100644
+--- a/lib/usercode/GwUserCode.cpp
++++ b/lib/usercode/GwUserCode.cpp
+@@ -216,6 +216,14 @@ public:
+     {
+         return api->getLogger();
+     }
++    virtual Nmea2kTwai *getNMEA2000()
++    {
++        return api->getNMEA2000();
++    }
++    virtual tN2kDeviceList *getN2kDeviceList()
++    {
++        return api->getN2kDeviceList();
++    }
+     virtual GwBoatData *getBoatData()
+     {
+         return api->getBoatData();
+@@ -428,4 +436,4 @@ void GwUserCode::handleWebRequest(const String &url,AsyncWebServerRequest *req){
+     }
+     LOG_DEBUG(GwLog::DEBUG,"no task found for web request %s[%s]",url.c_str(),tname.c_str());
+     req->send(404, "text/plain", "not found");
+-}
+\ No newline at end of file
++}
+diff --git a/src/main.cpp b/src/main.cpp
+index 95d5d1e..01fcd32 100644
+--- a/src/main.cpp
++++ b/src/main.cpp
+@@ -100,6 +100,7 @@ GwLog logger(LOGLEVEL,NULL);
+ GwConfigHandler config(&logger);
+ 
+ #include "Nmea2kTwai.h"
++#include <N2kDeviceList.h>
+ static const unsigned long CAN_RECOVERY_PERIOD=3000; //ms
+ static const unsigned long NMEA2000_HEARTBEAT_INTERVAL=5000;
+ class Nmea2kTwaiLog : public Nmea2kTwai{
+@@ -126,6 +127,7 @@ class Nmea2kTwaiLog : public Nmea2kTwai{
+ #endif
+ 
+ Nmea2kTwai &NMEA2000=*(new Nmea2kTwaiLog((gpio_num_t)ESP32_CAN_TX_PIN,(gpio_num_t)ESP32_CAN_RX_PIN,CAN_RECOVERY_PERIOD,&logger));
++tN2kDeviceList *pN2kDeviceList;
+ 
+ #ifdef GWBUTTON_PIN
+ bool fixedApPass=false;
+@@ -333,6 +335,12 @@ public:
+     status.n2kTx=countNMEA2KOut.getGlobal();
+     channels.fillStatus(status);
+   }
++  virtual Nmea2kTwai *getNMEA2000(){
++    return &NMEA2000;
++  }
++  virtual tN2kDeviceList *getN2kDeviceList(){
++    return pN2kDeviceList;
++  }
+   virtual GwBoatData *getBoatData(){
+     return &boatData;
+   }
+@@ -935,6 +943,7 @@ void setup() {
+   NMEA2000.SetMsgHandler([](const tN2kMsg &n2kMsg){
+     handleN2kMessage(n2kMsg,N2K_CHANNEL_ID);
+   });
++  pN2kDeviceList = new tN2kDeviceList(&NMEA2000);
+   NMEA2000.Open();
+   logger.logDebug(GwLog::LOG,"starting addon tasks");
+   logger.flush();

lib/obp60task/patches/02-wpname.patch

@@ -0,0 +1,115 @@
+diff --git a/lib/boatData/GwBoatData.cpp b/lib/boatData/GwBoatData.cpp
+index 424ebe4..b717097 100644
+--- a/lib/boatData/GwBoatData.cpp
++++ b/lib/boatData/GwBoatData.cpp
+@@ -6,6 +6,7 @@
+ #define GWTYPE_UINT32 2
+ #define GWTYPE_UINT16 3
+ #define GWTYPE_INT16 4
++#define GWTYPE_STRING 5
+ #define GWTYPE_USER 100
+ 
+ class GwBoatItemTypes
+@@ -15,6 +16,7 @@ public:
+     static int getType(const uint16_t &x) { return GWTYPE_UINT16; }
+     static int getType(const int16_t &x) { return GWTYPE_INT16; }
+     static int getType(const double &x) { return GWTYPE_DOUBLE; }
++    static int getType(const String &x) { return GWTYPE_STRING; }
+     static int getType(const GwSatInfoList &x) { return GWTYPE_USER + 1; }
+ };
+ 
+@@ -252,6 +254,10 @@ static void writeToString(GwTextWriter *writer, const int16_t &value)
+ {
+     writer->writeInteger(value);
+ }
++static void writeToString(GwTextWriter *writer, String value)
++{
++    writer->writeString(value.c_str());
++}
+ static void writeToString(GwTextWriter *writer, GwSatInfoList &value)
+ {
+     writer->writeInteger(value.getNumSats());
+@@ -288,6 +294,8 @@ template class GwBoatItem<double>;
+ template class GwBoatItem<uint32_t>;
+ template class GwBoatItem<uint16_t>;
+ template class GwBoatItem<int16_t>;
++template class GwBoatItem<String>;
++
+ void GwSatInfoList::houseKeeping(unsigned long ts)
+ {
+     if (ts == 0)
+diff --git a/lib/boatData/GwBoatData.h b/lib/boatData/GwBoatData.h
+index ae50b3f..5b32f70 100644
+--- a/lib/boatData/GwBoatData.h
++++ b/lib/boatData/GwBoatData.h
+@@ -58,6 +58,7 @@ class GwBoatItemBase{
+         GWSC(formatRot);
+         GWSC(formatDate);
+         GWSC(formatTime);
++        GWSC(formatName);
+     protected:
+         int type;
+         unsigned long lastSet=0;
+@@ -92,6 +93,7 @@ class GwBoatItemBase{
+         virtual int getLastSource(){return lastUpdateSource;}
+         virtual void refresh(unsigned long ts=0){uls(ts);}
+         virtual double getDoubleValue()=0;
++        virtual String getStringValue()=0;
+         String getName(){return name;}
+         const String & getFormat() const{return format;}
+         virtual void setInvalidTime(GwConfigHandler *cfg);
+@@ -120,7 +122,19 @@ template<class T> class GwBoatItem : public GwBoatItemBase{
+             if (! isValid(millis())) return defaultv;
+             return data;
+         }
+-        virtual double getDoubleValue(){return (double)data;}
++        virtual double getDoubleValue(){
++            if constexpr (std::is_same<T, String>::value) {
++                return 0.0;
++                // TODO any better ideas?
++                // perhaps return std::numeric_limits<double>::quiet_NaN();
++            } else {
++                return (double)data;
++            }
++        }
++        virtual String getStringValue(){
++            return (String)data;
++        }
++
+         virtual void fillString();
+         virtual void toJsonDoc(GwJsonDocument *doc, unsigned long minTime);
+         virtual int getLastSource(){return lastUpdateSource;}
+@@ -235,6 +249,7 @@ class GwBoatData{
+     GWBOATDATA(double,XTE,formatXte) // cross track error
+     GWBOATDATA(double,WPLat,formatLatitude) // waypoint latitude
+     GWBOATDATA(double,WPLon,formatLongitude) // waypoint longitude
++    GWBOATDATA(String,WPName,formatName) // waypoint name
+     GWSPECBOATDATA(GwBoatDataSatList,SatInfo,GwSatInfoList::toType,formatFixed0);
+     public:
+         GwBoatData(GwLog *logger, GwConfigHandler *cfg);
+diff --git a/lib/nmea0183ton2k/NMEA0183DataToN2K.cpp b/lib/nmea0183ton2k/NMEA0183DataToN2K.cpp
+index 6989570..238af38 100644
+--- a/lib/nmea0183ton2k/NMEA0183DataToN2K.cpp
++++ b/lib/nmea0183ton2k/NMEA0183DataToN2K.cpp
+@@ -355,6 +355,7 @@ private:
+             AppendN2kRouteWPInfo(n2kMsg,destinationId,rmb.destID,rmb.latitude,rmb.longitude);
+             send(n2kMsg,msg.sourceId);
+             }
++        boatData->WPName->update(String(rmb.destID), msg.sourceId);
+     }
+     void convertRMC(const SNMEA0183Msg &msg)
+     {
+diff --git a/platformio.ini b/platformio.ini
+index b738131..e131a6e 100644
+--- a/platformio.ini
++++ b/platformio.ini
+@@ -68,6 +68,9 @@ lib_ldf_mode = off
+ monitor_speed = 115200
+ build_flags = 
+ 	-D PIO_ENV_BUILD=$PIOENV
++	-std=gnu++17
++build_unflags =
++	-std=gnu++11
+ 
+ [sensors]
+ ; collect the libraries for sensors here

lib/obp60task/platformio.ini

@@ -4,9 +4,66 @@
 #by uncommenting the next line
 
 default_envs = 
+    obp70_s3
     obp60_s3
     obp40_s3
 
+[env:obp70_s3]
+platform = espressif32@6.8.1
+board_build.variants_dir = variants
+board = obp70_s3_n16r8  #ESP32-S3 N16R8, 16MB flash, 8MB PSRAM, production series
+board_build.partitions = default_16MB.csv #ESP32-S3 N16, 16MB flash
+custom_config = lib/obp60task/config_obp70.json
+custom_script = lib/obp60task/extra_task.py
+framework = arduino
+lib_deps = 
+    ${basedeps.lib_deps}
+    Wire
+    SPI
+    ESP32time
+    HTTPClient
+    WiFiClientSecure
+    esphome/AsyncTCP-esphome@2.1.1
+    robtillaart/PCF8574@0.3.9
+    adafruit/Adafruit Unified Sensor @ 1.1.13
+    blemasle/MCP23017@2.0.0
+    adafruit/Adafruit BusIO@1.5.0
+    adafruit/Adafruit GFX Library@1.11.9
+    #zinggjm/GxEPD2@1.5.8
+    #https://github.com/ZinggJM/GxEPD2
+    https://github.com/thooge/GxEPD2
+    sstaub/Ticker@4.4.0
+    adafruit/Adafruit BMP280 Library@2.6.2
+    adafruit/Adafruit BME280 Library@2.2.2
+    adafruit/Adafruit BMP085 Library@1.2.1
+    enjoyneering/HTU21D@1.2.1
+    robtillaart/INA226@0.2.0
+    paulstoffregen/OneWire@2.3.8
+    milesburton/DallasTemperature@3.11.0
+    signetica/SunRise@2.0.2
+    adafruit/Adafruit FRAM I2C@2.0.3
+    lovyan03/LovyanGFX@1.2.19
+build_flags=
+    #https://thingpulse.com/usb-settings-for-logging-with-the-esp32-s3-in-platformio/?srsltid=AfmBOopGskbkr4GoeVkNlFaZXe_zXkLceKF6Rn-tmoXABCeAR2vWsdHL
+#    -D CORE_DEBUG_LEVEL=1           #Debug level for CPU core via CDC (serial device)
+#    -D TIME=$UNIX_TIME              #Set PC time for RTC (only settable via VSC)
+    -D DISABLE_DIAGNOSTIC_OUTPUT    #Disable diagnostic output for GxEPD2 lib
+    -D BOARD_OBP60S3                #Board OBP60 V2.1 with ESP32S3
+#    -D HARDWARE_V20                 #OBP60 hardware revision V2.0
+    -D HARDWARE_V21                 #OBP60 hardware revision V2.1
+    -D TFT_DISPLAY                  #Enable TFT LCD display path (instead of E-Ink)
+#    -D TFT_320x480_ST7796           #TFT panel type: ST7796 (320x480, 80 MHz), best performance
+    -D TFT_320x480_ILI9488          #TFT panel type: ILI9488 (320x480, 40 MHz), lower performance
+    -D OBP_TFT_ENABLE_SCALING=1     #TFT scaling on/off (1=scale to max Y=320, 0=no scaling)
+    -D OBP_TFT_SCALE_ANTIALIAS=1    #Antialiasing for TFT scaling (1=on, 0=off)
+#    -D ENABLE_PATCHES               #enable patching of gateway code
+    ${env.build_flags}
+#CONFIG_ESP_TASK_WDT_TIMEOUT_S = 10 #Task Watchdog timeout period (seconds) [1...60] 5 default
+upload_port = /dev/ttyACM0          #OBP60 download via USB-C direct
+upload_protocol = esptool           #firmware upload via USB OTG seriell, by first upload need to set the ESP32-S3 in the upload mode with shortcut GND to Pin27 
+upload_speed = 230400
+monitor_speed = 115200    
+
 [env:obp60_s3]
 platform = espressif32@6.8.1
 board_build.variants_dir = variants
@@ -26,7 +83,7 @@ lib_deps =
     ESP32time
     HTTPClient
     WiFiClientSecure
-    esphome/AsyncTCP-esphome@2.0.1
+    esphome/AsyncTCP-esphome@2.1.1
     robtillaart/PCF8574@0.3.9
     adafruit/Adafruit Unified Sensor @ 1.1.13
     blemasle/MCP23017@2.0.0
@@ -82,7 +139,7 @@ lib_deps =
     ESP32time
     HTTPClient
     WiFiClientSecure
-    esphome/AsyncTCP-esphome@2.0.1
+    esphome/AsyncTCP-esphome@2.1.1
     robtillaart/PCF8574@0.3.9
     adafruit/Adafruit Unified Sensor @ 1.1.13
     blemasle/MCP23017@2.0.0
@@ -107,8 +164,8 @@ build_flags=
     -D HARDWARE_V10                 #OBP40 hardware revision V1.0 SKU:DIE07300S V1.1 (CrowPanel 4.2)
     -D DISPLAY_GDEY042T81           #new E-Ink display from Good Display (Waveshare), R10 2.2 ohm - good (contast lost by shunshine)
     #-D DISPLAY_ZJY400300-042CAAMFGN #alternativ E-Ink display from ZZE Technology, R10 2.2 ohm - very good   
-    #-D LIPO_ACCU_1200               #Hardware extension, LiPo accu 3,7V 1200mAh
+    -D LIPO_ACCU_1200               #Hardware extension, LiPo accu 3,7V 1200mAh
-    #-D VOLTAGE_SENSOR               #Hardware extension, LiPo voltage sensor with two resistors
+    -D VOLTAGE_SENSOR               #Hardware extension, LiPo voltage sensor with two resistors
     #-D ENABLE_PATCHES               #enable patching of gateway code
     ${env.build_flags}
 upload_port = /dev/ttyUSB0          #OBP40 download via external USB/Serail converter

lib/obp60task/run_obp70_s3

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+# This script compile the software für OBP60-S3
+
+# Attention! Start this cript only in the Gitpod Docker container.
+# Start the script with: bash run
+
+# Compile the firmware
+echo "Compiling Firmware"
+platformio run -e obp70_s3

lib/statistics/GwStatistics.h

@@ -1,5 +1,13 @@
 #pragma once
 #include <Arduino.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+static inline int64_t gwMonotonicUs(){
+  TickType_t ticks=xTaskGetTickCount();
+  return ((int64_t)ticks) * ((int64_t)portTICK_PERIOD_MS) * 1000;
+}
+
 class TimeAverage{
   double factor=0.3;
   double current=0;
@@ -70,7 +78,7 @@ class TimeMonitor{
     }
     void reset(){
       if (last != 0 && start != 0) loop->add(last-start);
-      start=esp_timer_get_time();
+      start=gwMonotonicUs();
       for (size_t i=0;i<len;i++) current[i]=0;
       count++;
       
@@ -114,7 +122,7 @@ class TimeMonitor{
       for (size_t i=0;i<index;i++){
         if (current[i] != 0) sv=current[i];
       }
-      int64_t now=esp_timer_get_time();
+      int64_t now=gwMonotonicUs();
       last=now;
       current[index]=now;
       int64_t currentv=now-sv;

platformio.ini

@@ -21,8 +21,8 @@ lib_deps =
     ttlappalainen_NMEA2000=https://github.com/wellenvogel/NMEA2000.git#20251126
 	ttlappalainen/NMEA0183 @ 1.10.1
 	ArduinoJson @ 6.18.5
-	AsyncTCP-esphome @ 2.0.1
+	AsyncTCP-esphome @ 2.1.1
-	ottowinter/ESPAsyncWebServer-esphome@2.0.1
+	ottowinter/ESPAsyncWebServer-esphome@3.4.0
 	FS
 	Preferences
 	ESPmDNS
@@ -34,8 +34,8 @@ lib_deps=
 	ttlappalainen_NMEA2000=symlink://../NMEA2000
 	ttlappalainen/NMEA0183 @ 1.10.1
 	ArduinoJson @ 6.18.5
-	AsyncTCP-esphome @ 2.0.1
+	AsyncTCP-esphome @ 2.1.1
-	ottowinter/ESPAsyncWebServer-esphome@2.0.1
+	ottowinter/ESPAsyncWebServer-esphome@3.4.0
 	FS
 	Preferences
 	ESPmDNS

src/main.cpp

@@ -767,7 +767,7 @@ void loopFunction(void *){
     //if(Serial1.available()) {}
     //if(Serial.available()) {}
     //if(Serial2.available()) {}
-    //delay(1);
+    vTaskDelay(1);
   }
 }
 const String USERPREFIX="/api/user/";

variants/obp70s3/pins_arduino.h

@@ -0,0 +1,74 @@
+#ifndef Pins_Arduino_h
+#define Pins_Arduino_h
+
+#include <stdint.h>
+#include "soc/soc_caps.h"
+
+#define USB_VID 0x303a
+#define USB_PID 0x1001
+
+/*
+#define EXTERNAL_NUM_INTERRUPTS 46
+#define NUM_DIGITAL_PINS        48
+#define NUM_ANALOG_INPUTS       20
+
+// Multi Function Display OBP60 V2.0
+static const uint8_t LED_BUILTIN = SOC_GPIO_PIN_COUNT+48;
+#define BUILTIN_LED  LED_BUILTIN // backward compatibility
+#define LED_BUILTIN LED_BUILTIN
+#define RGB_BUILTIN LED_BUILTIN
+#define RGB_BRIGHTNESS 64
+
+#define analogInputToDigitalPin(p)  (((p)<20)?(analogChannelToDigitalPin(p)):-1)
+#define digitalPinToInterrupt(p)    (((p)<48)?(p):-1)
+#define digitalPinHasPWM(p)         (p < 46)
+*/
+
+static const uint8_t TX = 43;
+static const uint8_t RX = 44;
+
+static const uint8_t SDA = 47;
+static const uint8_t SCL = 21;
+
+static const uint8_t SS    = 39;
+static const uint8_t MOSI  = 48;
+static const uint8_t MISO  = 11;
+static const uint8_t SCK   = 38;
+
+static const uint8_t A0 = 1;
+static const uint8_t A1 = 2;
+static const uint8_t A2 = 3;
+static const uint8_t A3 = 4;
+static const uint8_t A4 = 5;
+static const uint8_t A5 = 6;
+static const uint8_t A6 = 7;
+static const uint8_t A7 = 8;
+static const uint8_t A8 = 9;
+static const uint8_t A9 = 10;
+static const uint8_t A10 = 11;
+static const uint8_t A11 = 12;
+static const uint8_t A12 = 13;
+static const uint8_t A13 = 14;
+static const uint8_t A14 = 15;
+static const uint8_t A15 = 16;
+static const uint8_t A16 = 17;
+static const uint8_t A17 = 18;
+static const uint8_t A18 = 19;
+static const uint8_t A19 = 20;
+
+static const uint8_t T1 = 1;
+static const uint8_t T2 = 2;
+static const uint8_t T3 = 3;
+static const uint8_t T4 = 4;
+static const uint8_t T5 = 5;
+static const uint8_t T6 = 6;
+static const uint8_t T7 = 7;
+static const uint8_t T8 = 8;
+static const uint8_t T9 = 9;
+static const uint8_t T10 = 10;
+static const uint8_t T11 = 11;
+static const uint8_t T12 = 12;
+static const uint8_t T13 = 13;
+static const uint8_t T14 = 14;
+
+#endif /* Pins_Arduino_h */