Fixed and finished SD card code. Added uptime feature to system page.

Automate gen_set.py with page detection and command line parameters

extra_script.py

@@ -526,3 +526,17 @@ env.Append(
 )
 #script does not run on clean yet - maybe in the future
 env.AddPostAction("clean",cleangenerated)
+
+#look for extra task scripts and include them here
+for taskdir in userTaskDirs:
+    script = os.path.join(taskdir, "extra_task.py")
+    if os.path.isfile(script):
+        taskname = os.path.basename(os.path.normpath(taskdir))
+        print("#extra task script for '{}'".format(taskname))
+        with open(script) as fh:
+            try:
+                code = compile(fh.read(), taskname, 'exec')
+            except SyntaxError:
+                print("#ERROR: script does not compile")
+                continue
+            exec(code)

lib/obp60task/OBP60Extensions.cpp

@@ -64,6 +64,12 @@ PCF8574 pcf8574_Out(PCF8574_I2C_ADDR1); // First digital output modul PCF8574 fr
 Adafruit_FRAM_I2C fram;
 bool hasFRAM = false;
 
+// SD Card
+#ifdef BOARD_OBP40S3
+sdmmc_card_t *sdcard;
+#endif
+bool hasSDCard = false;
+
 // Global vars
 bool blinkingLED = false;       // Enable / disable blinking flash LED
 bool statusLED = false;         // Actual status of flash LED on/off
@@ -78,6 +84,9 @@ LedTaskData *ledTaskData=nullptr;
 
 void hardwareInit(GwApi *api)
 {
+    GwLog *logger = api->getLogger();
+    GwConfigHandler *config = api->getConfig();
+
     Wire.begin();
     // Init PCF8574 digital outputs
     Wire.setClock(I2C_SPEED);       // Set I2C clock on 10 kHz
@@ -87,7 +96,7 @@ void hardwareInit(GwApi *api)
     fram = Adafruit_FRAM_I2C();
     if (esp_reset_reason() ==  ESP_RST_POWERON) {
         // help initialize FRAM
-        api->getLogger()->logDebug(GwLog::LOG,"Delaying I2C init for 250ms due to cold boot");
+        logger->logDebug(GwLog::LOG, "Delaying I2C init for 250ms due to cold boot");
         delay(250);
     }
     // FRAM (e.g. MB85RC256V)
@@ -99,11 +108,88 @@ void hardwareInit(GwApi *api)
         // Boot counter
         uint8_t framcounter = fram.read(0x0000);
         fram.write(0x0000, framcounter+1);
-        api->getLogger()->logDebug(GwLog::LOG,"FRAM detected: 0x%04x/0x%04x (counter=%d)", manufacturerID, productID, framcounter);
+        logger->logDebug(GwLog::LOG, "FRAM detected: 0x%04x/0x%04x (counter=%d)", manufacturerID, productID, framcounter);
     }
     else {
         hasFRAM = false;
-        api->getLogger()->logDebug(GwLog::LOG,"NO FRAM detected");
+        logger->logDebug(GwLog::LOG, "NO FRAM detected");
+    }
+    // SD Card
+    hasSDCard = false;
+#ifdef BOARD_OBP40S3
+    if (config->getBool(config->useSDCard)) {
+        esp_err_t ret;
+        sdmmc_host_t host = SDSPI_HOST_DEFAULT();
+        host.slot = SPI3_HOST;
+        logger->logDebug(GwLog::DEBUG, "SDSPI_HOST: max_freq_khz=%d" , host.max_freq_khz);
+        spi_bus_config_t bus_cfg = {
+            .mosi_io_num = SD_SPI_MOSI,
+            .miso_io_num = SD_SPI_MISO,
+            .sclk_io_num = SD_SPI_CLK,
+            .quadwp_io_num = -1,
+            .quadhd_io_num = -1,
+            .max_transfer_sz = 4000,
+        };
+        ret = spi_bus_initialize((spi_host_device_t) host.slot, &bus_cfg, SDSPI_DEFAULT_DMA);
+        if (ret != ESP_OK) {
+            logger->logDebug(GwLog::ERROR, "Failed to initialize SPI bus for SD card");
+        } else {
+            sdspi_device_config_t slot_config = SDSPI_DEVICE_CONFIG_DEFAULT();
+            slot_config.gpio_cs = SD_SPI_CS;
+            slot_config.host_id = (spi_host_device_t) host.slot;
+            esp_vfs_fat_sdmmc_mount_config_t mount_config = {
+                .format_if_mount_failed = false,
+                .max_files = 5,
+                .allocation_unit_size = 16 * 1024
+            };
+            ret = esp_vfs_fat_sdspi_mount(MOUNT_POINT, &host, &slot_config, &mount_config, &sdcard);
+            if (ret != ESP_OK) {
+                if (ret == ESP_FAIL) {
+                    logger->logDebug(GwLog::ERROR, "Failed to mount SD card filesystem");
+                } else {
+                    // ret == 263 could be not powered up yet
+                    logger->logDebug(GwLog::ERROR, "Failed to initialize SD card (error #%d)", ret);
+                }
+            } else {
+                logger->logDebug(GwLog::LOG, "SD card filesystem mounted at '%s'", MOUNT_POINT);
+                hasSDCard = true;
+            }
+        }
+        if (hasSDCard) {
+            // read some stats
+            String features = "";
+            if (sdcard->is_mem) features += "MEM "; // Memory card
+            if (sdcard->is_sdio) features += "IO "; // IO Card
+            if (sdcard->is_mmc) features += "MMC "; // MMC Card
+            if (sdcard->is_ddr) features += "DDR ";
+            // if (sdcard->is_uhs1) features += "UHS-1 ";
+            // ext_csd. Extended information
+            // uint8_t rev, uint8_t power_class
+            logger->logDebug(GwLog::LOG, "SD card features: %s", features);
+            logger->logDebug(GwLog::LOG, "SD card size: %lluMB", ((uint64_t) sdcard->csd.capacity) * sdcard->csd.sector_size / (1024 * 1024));
+        }
+    }
+#endif
+}
+
+void powerInit(String powermode) {
+    // Max Power | Only 5.0V | Min Power
+    if (powermode == "Max Power" || powermode == "Only 5.0V") {
+#ifdef HARDWARE_V21
+        setPortPin(OBP_POWER_50, true); // Power on 5.0V rail
+#endif
+#ifdef BOARD_OBP40S3
+        setPortPin(OBP_POWER_EPD, true);// Power on ePaper display
+        setPortPin(OBP_POWER_SD, true); // Power on SD card
+#endif
+    } else { // Min Power
+#ifdef HARDWARE_V21
+        setPortPin(OBP_POWER_50, false); // Power off 5.0V rail
+#endif
+#ifdef BOARD_OBP40S3
+        setPortPin(OBP_POWER_EPD, false);// Power off ePaper display
+        setPortPin(OBP_POWER_SD, false); // Power off SD card
+#endif
     }
 }
 

lib/obp60task/OBP60Extensions.h

@@ -7,6 +7,12 @@
 #include <GxEPD2_BW.h>                  // E-paper lib V2
 #include <Adafruit_FRAM_I2C.h>          // I2C FRAM
 
+#ifdef BOARD_OBP40S3
+#include "esp_vfs_fat.h"
+#include "sdmmc_cmd.h"
+#define MOUNT_POINT "/sdcard"
+#endif
+
 // FRAM address reservations 32kB: 0x0000 - 0x7FFF
 // 0x0000 - 0x03ff: single variables
 #define FRAM_PAGE_NO 0x0002
@@ -15,6 +21,7 @@
 #define FRAM_VOLTAGE_AVG 0x000A
 #define FRAM_VOLTAGE_TREND 0x000B
 #define FRAM_VOLTAGE_MODE 0x000C
+// Wind page
 #define FRAM_WIND_SIZE 0x000D
 #define FRAM_WIND_SRC 0x000E
 #define FRAM_WIND_MODE 0x000F
@@ -24,6 +31,10 @@
 
 extern Adafruit_FRAM_I2C fram;
 extern bool hasFRAM;
+extern bool hasSDCard;
+#ifdef BOARD_OBP40S3
+extern sdmmc_card_t *sdcard;
+#endif
 
 // Fonts declarations for display (#includes see OBP60Extensions.cpp)
 extern const GFXfont DSEG7Classic_BoldItalic16pt7b;
@@ -75,6 +86,7 @@ void deepSleep(CommonData &common);
 uint8_t getLastPage();
 
 void hardwareInit(GwApi *api);
+void powerInit(String powermode);
 
 void setPortPin(uint pin, bool value);          // Set port pin for extension port
 

lib/obp60task/OBP60Formatter.cpp

@@ -49,9 +49,9 @@ String formatLongitude(double lon) {
     return String(degree, 0) + "\x90 " + String(minute, 4) + "' " + ((lon > 0) ? "E" : "W");
 }
 
-FormatedData formatValue(GwApi::BoatValue *value, CommonData &commondata){
+FormattedData formatValue(GwApi::BoatValue *value, CommonData &commondata){
     GwLog *logger = commondata.logger;
-    FormatedData result;
+    FormattedData result;
     static int dayoffset = 0;
     double rawvalue = 0;
 
@@ -65,6 +65,7 @@ FormatedData formatValue(GwApi::BoatValue *value, CommonData &commondata){
     String tempFormat = commondata.config->getString(commondata.config->tempFormat);            // [K|°C|°F]
     String dateFormat = commondata.config->getString(commondata.config->dateFormat);            // [DE|GB|US]
     bool usesimudata = commondata.config->getBool(commondata.config->useSimuData);              // [on|off]
+    String precision = commondata.config->getString(commondata.config->valueprecision);         // [1|2]
 
     // If boat value not valid
     if (! value->valid && !usesimudata){
@@ -72,6 +73,19 @@ FormatedData formatValue(GwApi::BoatValue *value, CommonData &commondata){
         return result;
     }
 
+    const char* fmt_dec_1;
+    const char* fmt_dec_10;
+    const char* fmt_dec_100;
+    if (precision == "1") {
+        fmt_dec_1 = "%3.1f";
+        fmt_dec_10 = "%3.0f";
+        fmt_dec_100 = "%3.0f";
+    } else {
+        fmt_dec_1 = "%3.2f";
+        fmt_dec_10 = "%3.1f";
+        fmt_dec_100 = "%3.0f";
+    }
+
 //    LOG_DEBUG(GwLog::DEBUG,"formatValue init: getFormat: %s date->value: %f time->value: %f", value->getFormat(), commondata.date->value, commondata.time->value);
     static const int bsize = 30;
     char buffer[bsize+1];
@@ -91,25 +105,25 @@ FormatedData formatValue(GwApi::BoatValue *value, CommonData &commondata){
         tmElements_t parts;
         time_t tv=tNMEA0183Msg::daysToTime_t(value->value + dayoffset);
         tNMEA0183Msg::breakTime(tv,parts);
-        if(usesimudata == false) { 
-            if(String(dateFormat) == "DE"){
-                snprintf(buffer,bsize,"%02d.%02d.%04d",parts.tm_mday,parts.tm_mon+1,parts.tm_year+1900);
+        if (usesimudata == false) { 
+            if (String(dateFormat) == "DE") {
+                snprintf(buffer,bsize, "%02d.%02d.%04d", parts.tm_mday, parts.tm_mon+1, parts.tm_year+1900);
             }
-            else if(String(dateFormat) == "GB"){
-                snprintf(buffer,bsize,"%02d/%02d/%04d",parts.tm_mday,parts.tm_mon+1,parts.tm_year+1900);
+            else if(String(dateFormat) == "GB") {
+                snprintf(buffer, bsize, "%02d/%02d/%04d", parts.tm_mday, parts.tm_mon+1, parts.tm_year+1900);
             }
-            else if(String(dateFormat) == "US"){
-                snprintf(buffer,bsize,"%02d/%02d/%04d",parts.tm_mon+1,parts.tm_mday,parts.tm_year+1900);
+            else if(String(dateFormat) == "US") {
+                snprintf(buffer, bsize, "%02d/%02d/%04d", parts.tm_mon+1, parts.tm_mday, parts.tm_year+1900);
             }
-            else if(String(dateFormat) == "ISO"){
-                snprintf(buffer,bsize,"%04d-%02d-%02d",parts.tm_year+1900,parts.tm_mon+1,parts.tm_mday);
+            else if(String(dateFormat) == "ISO") {
+                snprintf(buffer, bsize, "%04d-%02d-%02d", parts.tm_year+1900, parts.tm_mon+1, parts.tm_mday);
             }
-            else{
-                snprintf(buffer,bsize,"%02d.%02d.%04d",parts.tm_mday,parts.tm_mon+1,parts.tm_year+1900);  
+            else {
+                snprintf(buffer, bsize, "%02d.%02d.%04d", parts.tm_mday, parts.tm_mon+1, parts.tm_year+1900);  
             }
         }
         else{
-            snprintf(buffer,bsize,"01.01.2022"); 
+            snprintf(buffer, bsize, "01.01.2022"); 
         }
         if(timeZone == 0){
             result.unit = "UTC";
@@ -130,11 +144,11 @@ FormatedData formatValue(GwApi::BoatValue *value, CommonData &commondata){
         if (timeInSeconds > 86400) {timeInSeconds = timeInSeconds - 86400;}
         if (timeInSeconds <  0) {timeInSeconds = timeInSeconds + 86400;}
 //        LOG_DEBUG(GwLog::DEBUG,"... formatTime value: %f tz: %f corrected timeInSeconds: %f ", value->value, timeZone, timeInSeconds);
-        if(usesimudata == false) {
-            val=modf(timeInSeconds/3600.0,&inthr);
-            val=modf(val*3600.0/60.0,&intmin);
+        if (usesimudata == false) {
+            val = modf(timeInSeconds/3600.0, &inthr);
+            val = modf(val*3600.0/60.0, &intmin);
             modf(val*60.0,&intsec);
-            snprintf(buffer,bsize,"%02.0f:%02.0f:%02.0f",inthr,intmin,intsec);
+            snprintf(buffer, bsize, "%02.0f:%02.0f:%02.0f", inthr, intmin, intsec);
         }
         else{
             static long sec;
@@ -143,7 +157,7 @@ FormatedData formatValue(GwApi::BoatValue *value, CommonData &commondata){
                 sec ++;
             }
             sec = sec % 60;
-            snprintf(buffer,bsize,"11:36:%02i", int(sec));
+            snprintf(buffer, bsize, "11:36:%02i", int(sec));
             lasttime = millis();
         }
         if(timeZone == 0){
@@ -156,23 +170,23 @@ FormatedData formatValue(GwApi::BoatValue *value, CommonData &commondata){
     //########################################################
     else if (value->getFormat() == "formatFixed0"){
         if(usesimudata == false) {
-            snprintf(buffer,bsize,"%3.0f",value->value);
+            snprintf(buffer, bsize, "%3.0f", value->value);
             rawvalue = value->value;
         }
         else{
             rawvalue = 8.0 + float(random(0, 10)) / 10.0;
-            snprintf(buffer,bsize,"%3.0f", rawvalue);
+            snprintf(buffer, bsize, "%3.0f", rawvalue);
         }
         result.unit = "";
     }
     //########################################################
     else if (value->getFormat() == "formatCourse" || value->getFormat() == "formatWind"){
         double course = 0;
-        if(usesimudata == false) {
+        if (usesimudata == false) {
             course = value->value;
             rawvalue = value->value;
         }
-        else{
+        else {
             course = 2.53 + float(random(0, 10) / 100.0);
             rawvalue = course;
         }
@@ -185,7 +199,7 @@ FormatedData formatValue(GwApi::BoatValue *value, CommonData &commondata){
     //########################################################
     else if (value->getFormat() == "formatKnots" && (value->getName() == "SOG" || value->getName() == "STW")){
         double speed = 0;
-        if(usesimudata == false) {
+        if (usesimudata == false) {
             speed = value->value;
             rawvalue = value->value;
         }
@@ -193,85 +207,85 @@ FormatedData formatValue(GwApi::BoatValue *value, CommonData &commondata){
             rawvalue = 4.0 + float(random(0, 40));
             speed = rawvalue;
         }
-        if(String(speedFormat) == "km/h"){
+        if (String(speedFormat) == "km/h"){
         speed = speed * 3.6;            // Unit conversion form m/s to km/h
             result.unit = "km/h";
         }
-        else if(String(speedFormat) == "kn"){
+        else if (String(speedFormat) == "kn"){
             speed = speed * 1.94384;    // Unit conversion form m/s to kn
             result.unit = "kn";
         }
-        else{
+        else {
             speed = speed;              // Unit conversion form m/s to m/s
             result.unit = "m/s";
         }
-        if(speed < 10){
-            snprintf(buffer,bsize,"%3.2f",speed);
+        if(speed < 10) {
+            snprintf(buffer, bsize, fmt_dec_1, speed);
         }
-        if(speed >= 10 && speed < 100){
-            snprintf(buffer,bsize,"%3.1f",speed);
+        else if (speed < 100) {
+            snprintf(buffer, bsize, fmt_dec_10, speed);
         }
-        if(speed >= 100){
-            snprintf(buffer,bsize,"%3.0f",speed);
+        else {
+            snprintf(buffer, bsize, fmt_dec_100, speed);
         }
     }
     //########################################################
     else if (value->getFormat() == "formatKnots" && (value->getName() == "AWS" || value->getName() == "TWS" || value->getName() == "MaxAws" || value->getName() == "MaxTws")){
         double speed = 0;
-        if(usesimudata == false) {
+        if (usesimudata == false) {
             speed = value->value;
             rawvalue = value->value;
         }
-        else{
+        else {
             rawvalue = 4.0 + float(random(0, 40));
             speed = rawvalue;
         }
-        if(String(windspeedFormat) == "km/h"){
+        if (String(windspeedFormat) == "km/h"){
             speed = speed * 3.6;        // Unit conversion form m/s to km/h
             result.unit = "km/h";
         }
-        else if(String(windspeedFormat) == "kn"){
+        else if (String(windspeedFormat) == "kn"){
             speed = speed * 1.94384;      // Unit conversion form m/s to kn
             result.unit = "kn";
         }
         else if(String(windspeedFormat) == "bft"){
-            if(speed < 0.3){
+            if (speed < 0.3) {
                 speed = 0;
             }
-            if(speed >=0.3 && speed < 1.5){
+            else if (speed < 1.5) {
                 speed = 1;
             }
-            if(speed >=1.5 && speed < 3.3){
+            else if (speed < 3.3) {
                 speed = 2;
             }
-            if(speed >=3.3 && speed < 5.4){
+            else if (speed < 5.4) {
                 speed = 3;
             }
-            if(speed >=5.4 && speed < 7.9){
+            else if (speed < 7.9) {
                 speed = 4;
             }
-            if(speed >=7.9 && speed < 10.7){
+            else if (speed < 10.7) {
                 speed = 5;
             }
-            if(speed >=10.7 && speed < 13.8){
+            else if (speed < 13.8) {
                 speed = 6;
             }
-            if(speed >=13.8 && speed < 17.1){
+            else if (speed < 17.1) {
                 speed = 7;
             }
-            if(speed >=17.1 && speed < 20.7){
+            else if (speed < 20.7) {
                 speed = 8;
             }
-            if(speed >=20.7 && speed < 24.4){
+            else if (speed < 24.4) {
                 speed = 9;
             }
-            if(speed >=24.4 && speed < 28.4){
+            else if (speed < 28.4) {
                 speed = 10;
             }
-            if(speed >=28.4 && speed < 32.6){
+            else if (speed < 32.6) {
                 speed = 11;
             }
-            if(speed >=32.6){
+            else {
                 speed = 12;
             }
             result.unit = "bft";
@@ -280,82 +294,85 @@ FormatedData formatValue(GwApi::BoatValue *value, CommonData &commondata){
             speed = speed;              // Unit conversion form m/s to m/s
             result.unit = "m/s";
         }
-        if(String(windspeedFormat) == "bft"){
-            snprintf(buffer,bsize,"%2.0f",speed);
+        if (String(windspeedFormat) == "bft"){
+            snprintf(buffer, bsize, "%2.0f", speed);
         }
         else{
-            if(speed < 10){
-                snprintf(buffer,bsize,"%3.2f",speed);
+            if (speed < 10){
+                snprintf(buffer, bsize, fmt_dec_1, speed);
             }
-            if(speed >= 10 && speed < 100){
-                snprintf(buffer,bsize,"%3.1f",speed);
+            else if (speed < 100){
+                snprintf(buffer, bsize, fmt_dec_10, speed);
             }
-            if(speed >= 100){
-                snprintf(buffer,bsize,"%3.0f",speed);
+            else {
+                snprintf(buffer, bsize, fmt_dec_100, speed);
             }
         }
     }
     //########################################################
     else if (value->getFormat() == "formatRot"){
         double rotation = 0;
-        if(usesimudata == false) {
+        if (usesimudata == false) {
             rotation = value->value;
             rawvalue = value->value;
         }
-        else{
+        else {
             rawvalue = 0.04 + float(random(0, 10)) / 100.0;
             rotation = rawvalue;
         }
         rotation = rotation * 57.2958;      // Unit conversion form rad/s to deg/s
         result.unit = "Deg/s";
-        if(rotation < -100){
+        if (rotation < -100){
             rotation = -99;
         }
-        if(rotation > 100){
+        if (rotation > 100){
             rotation = 99;
         }
-        if(rotation > -10 && rotation < 10){
-            snprintf(buffer,bsize,"%3.2f",rotation);
+        if (rotation > -10 && rotation < 10){
+            snprintf(buffer, bsize, "%3.2f", rotation);
         }
-        if(rotation <= -10 || rotation >= 10){
-            snprintf(buffer,bsize,"%3.0f",rotation);
+        if (rotation <= -10 || rotation >= 10){
+            snprintf(buffer, bsize, "%3.0f", rotation);
         }
     }
     //########################################################
     else if (value->getFormat() == "formatDop"){
         double dop = 0;
-        if(usesimudata == false) {
+        if (usesimudata == false) {
             dop = value->value;
             rawvalue = value->value;
         }
-        else{
+        else {
             rawvalue = 2.0 + float(random(0, 40)) / 10.0;
             dop = rawvalue;
         }
         result.unit = "m";
-        if(dop > 99.9){
+        if (dop > 99.9){
             dop = 99.9;
         }
-        if(dop < 10){
-            snprintf(buffer,bsize,"%3.2f",dop);
+        if (dop < 10){
+            snprintf(buffer, bsize, fmt_dec_1, dop);
         }
-        if(dop >= 10 && dop < 100){
-            snprintf(buffer,bsize,"%3.1f",dop);
+        else if(dop < 100){
+            snprintf(buffer, bsize, fmt_dec_10, dop);
+        }
+        else {
+            snprintf(buffer, bsize, fmt_dec_100, dop);
         }
     }
     //########################################################
     else if (value->getFormat() == "formatLatitude"){
-        if(usesimudata == false) {
+        if (usesimudata == false) {
             double lat = value->value;
             rawvalue = value->value;
             String latitude = "";
             String latdir = "";
             float degree = abs(int(lat));
             float minute = abs((lat - int(lat)) * 60);
-            if(lat > 0){
+            if (lat > 0){
                 latdir = "N";
             }
-            else{
+            else {
                 latdir = "S";
             }
             latitude = String(degree,0) + "\x90 " + String(minute,4) + "' " + latdir;
@@ -364,41 +381,41 @@ FormatedData formatValue(GwApi::BoatValue *value, CommonData &commondata){
         }
         else{
             rawvalue = 35.0 + float(random(0, 10)) / 10000.0;
-            snprintf(buffer,bsize," 51\" %2.4f' N", rawvalue);
+            snprintf(buffer, bsize, " 51\" %2.4f' N", rawvalue);
         }
     }
     //########################################################
     else if (value->getFormat() == "formatLongitude"){
-        if(usesimudata == false) {
+        if (usesimudata == false) {
             double lon = value->value;
             rawvalue = value->value;
             String longitude = "";
             String londir = "";
             float degree = abs(int(lon));
             float minute = abs((lon - int(lon)) * 60);
-            if(lon > 0){
+            if (lon > 0){
                 londir = "E";
             }
-            else{
+            else {
                 londir = "W";
             }
             longitude = String(degree,0) + "\x90 " + String(minute,4) + "' " + londir;
             result.unit = "";
             strcpy(buffer, longitude.c_str());
         }
-        else{
+        else {
             rawvalue = 6.0 + float(random(0, 10)) / 100000.0;
-            snprintf(buffer,bsize," 15\" %2.4f'", rawvalue);
+            snprintf(buffer, bsize, " 15\" %2.4f'", rawvalue);
         }
     }
     //########################################################
     else if (value->getFormat() == "formatDepth"){
         double depth = 0;
-        if(usesimudata == false) {
+        if (usesimudata == false) {
             depth = value->value;
             rawvalue = value->value;
         }
-        else{
+        else {
             rawvalue = 18.0 + float(random(0, 100)) / 10.0;
             depth = rawvalue;
         }
@@ -409,14 +426,14 @@ FormatedData formatValue(GwApi::BoatValue *value, CommonData &commondata){
         else{
             result.unit = "m";
         }
-        if(depth < 10){
-            snprintf(buffer,bsize,"%3.2f",depth);
+        if (depth < 10) {
+            snprintf(buffer, bsize, fmt_dec_1, depth);
         }
-        if(depth >= 10 && depth < 100){
-            snprintf(buffer,bsize,"%3.1f",depth);
+        else if (depth < 100){
+            snprintf(buffer, bsize, fmt_dec_10, depth);
         }
-        if(depth >= 100){
-            snprintf(buffer,bsize,"%3.0f",depth);
+        else {
+            snprintf(buffer, bsize, fmt_dec_100, depth);
         }
     }
     //########################################################
@@ -430,50 +447,50 @@ FormatedData formatValue(GwApi::BoatValue *value, CommonData &commondata){
             xte = rawvalue;
         }
         if (xte >= 100) {
-            snprintf(buffer,bsize,"%3.0f",value->value);
+            snprintf(buffer, bsize, fmt_dec_100, value->value);
         } else if (xte >= 10) {
-            snprintf(buffer,bsize,"%3.1f",value->value);
+            snprintf(buffer, bsize, fmt_dec_10, value->value);
         } else {
-            snprintf(buffer,bsize,"%3.2f",value->value);
+            snprintf(buffer, bsize, fmt_dec_1, value->value);
         }
         result.unit = "nm";
     }
     //########################################################
     else if (value->getFormat() == "kelvinToC"){
         double temp = 0;
-        if(usesimudata == false) {
+        if (usesimudata == false) {
             temp = value->value;
             rawvalue = value->value;
         }
-        else{
+        else {
             rawvalue = 296.0 + float(random(0, 10)) / 10.0;
             temp = rawvalue;
         }
-        if(String(tempFormat) == "C"){
+        if (String(tempFormat) == "C") {
             temp = temp - 273.15;
             result.unit = "C";
         }
-        else if(String(tempFormat) == "F"){
+        else if (String(tempFormat) == "F") {
             temp = (temp - 273.15) * 9 / 5 + 32;
             result.unit = "F";
         }
         else{
             result.unit = "K";
         }
-        if(temp < 10){
-            snprintf(buffer,bsize,"%3.2f",temp);
+        if(temp < 10) {
+            snprintf(buffer, bsize, fmt_dec_1, temp);
         }
-        if(temp >= 10 && temp < 100){
-            snprintf(buffer,bsize,"%3.1f",temp);
+        else if (temp < 100) {
+            snprintf(buffer, bsize, fmt_dec_10, temp);
         }
-        if(temp >= 100){
-            snprintf(buffer,bsize,"%3.0f",temp);
+        else {
+            snprintf(buffer, bsize, fmt_dec_100, temp);
         }
     }
     //########################################################
     else if (value->getFormat() == "mtr2nm"){
         double distance = 0;
-        if(usesimudata == false) {
+        if (usesimudata == false) {
             distance = value->value;
             rawvalue = value->value;
         }
@@ -481,25 +498,25 @@ FormatedData formatValue(GwApi::BoatValue *value, CommonData &commondata){
             rawvalue = 2960.0 + float(random(0, 10));
             distance = rawvalue;
         }
-        if(String(distanceFormat) == "km"){
+        if (String(distanceFormat) == "km") {
             distance = distance * 0.001;
             result.unit = "km";
         }
-        else if(String(distanceFormat) == "nm"){
+        else if (String(distanceFormat) == "nm") {
             distance = distance * 0.000539957;
             result.unit = "nm";
         }
-        else{;
+        else {
             result.unit = "m";
         }
-        if(distance < 10){
-            snprintf(buffer,bsize,"%3.2f",distance);
+        if (distance < 10){
+            snprintf(buffer, bsize, fmt_dec_1, distance);
         }
-        if(distance >= 10 && distance < 100){
-            snprintf(buffer,bsize,"%3.1f",distance);
+        else if (distance < 100){
+            snprintf(buffer, bsize, fmt_dec_10, distance);
         }
-        if(distance >= 100){
-            snprintf(buffer,bsize,"%3.0f",distance);
+        else {
+            snprintf(buffer, bsize, fmt_dec_100, distance);
         }
     }
     //########################################################
@@ -508,122 +525,122 @@ FormatedData formatValue(GwApi::BoatValue *value, CommonData &commondata){
     //########################################################
      else if (value->getFormat() == "formatXdr:P:P"){
         double pressure = 0;
-        if(usesimudata == false) {
+        if (usesimudata == false) {
             pressure = value->value;
             rawvalue = value->value;
             pressure = pressure / 100.0;        // Unit conversion form Pa to hPa
         }
-        else{
+        else {
             rawvalue = 968 + float(random(0, 10));
             pressure = rawvalue;
         }
-        snprintf(buffer,bsize,"%4.0f",pressure);
+        snprintf(buffer, bsize, "%4.0f", pressure);
         result.unit = "hPa";
     }
     //########################################################
     else if (value->getFormat() == "formatXdr:P:B"){
         double pressure = 0;
-        if(usesimudata == false) {
+        if (usesimudata == false) {
             pressure = value->value;
             rawvalue = value->value;
             pressure = pressure / 100.0;      // Unit conversion form Pa to mBar
         }
-        else{
+        else {
             rawvalue = value->value;
             pressure = 968 + float(random(0, 10));
         }
-        snprintf(buffer,bsize,"%4.0f",pressure);
+        snprintf(buffer, bsize, "%4.0f", pressure);
         result.unit = "mBar";
     }
     //########################################################
     else if (value->getFormat() == "formatXdr:U:V"){
         double voltage = 0;
-        if(usesimudata == false) {
+        if (usesimudata == false) {
             voltage = value->value;
             rawvalue = value->value;
         }
-        else{
+        else {
             rawvalue = 12 + float(random(0, 30)) / 10.0;
             voltage = rawvalue;
         }
-        if(voltage < 10){
-            snprintf(buffer,bsize,"%3.2f",voltage);
+        if (voltage < 10) {
+            snprintf(buffer, bsize, fmt_dec_1, voltage);
         }
-        else{
-            snprintf(buffer,bsize,"%3.1f",voltage);
+        else {
+            snprintf(buffer, bsize, fmt_dec_10, voltage);
         }
         result.unit = "V";
     }
     //########################################################
     else if (value->getFormat() == "formatXdr:I:A"){
         double current = 0;
-        if(usesimudata == false) {
+        if (usesimudata == false) {
             current = value->value;
             rawvalue = value->value;
         }
-        else{
+        else {
             rawvalue = 8.2 + float(random(0, 50)) / 10.0;
             current = rawvalue;
         }
-        if(current < 10){
-            snprintf(buffer,bsize,"%3.2f",current);
+        if (current < 10) {
+            snprintf(buffer, bsize, fmt_dec_1, current);
         }
-        if(current >= 10 && current < 100){
-            snprintf(buffer,bsize,"%3.1f",current);
+        else if(current < 100) {
+            snprintf(buffer, bsize, fmt_dec_10, current);
         }
-        if(current >= 100){
-            snprintf(buffer,bsize,"%3.0f",current);
+        else {
+            snprintf(buffer, bsize, fmt_dec_100, current);
         }
         result.unit = "A";
     }
     //########################################################
     else if (value->getFormat() == "formatXdr:C:K"){
         double temperature = 0;
-        if(usesimudata == false) {
+        if (usesimudata == false) {
             temperature = value->value - 273.15;    // Convert K to C
             rawvalue = value->value - 273.15;
         }
-        else{
+        else {
             rawvalue = 21.8 + float(random(0, 50)) / 10.0;
             temperature = rawvalue;
         }
-        if(temperature < 10){
-            snprintf(buffer,bsize,"%3.2f",temperature);
+        if (temperature < 10) {
+            snprintf(buffer, bsize, fmt_dec_1, temperature);
         }
-        if(temperature >= 10 && temperature < 100){
-            snprintf(buffer,bsize,"%3.1f",temperature);
+        else if (temperature < 100) {
+            snprintf(buffer, bsize, fmt_dec_10, temperature);
         }
-        if(temperature >= 100){
-            snprintf(buffer,bsize,"%3.0f",temperature);
+        else {
+            snprintf(buffer, bsize, fmt_dec_100, temperature);
         }
         result.unit = "Deg C";
     }
     //########################################################
     else if (value->getFormat() == "formatXdr:C:C"){
         double temperature = 0;
-        if(usesimudata == false) {
+        if (usesimudata == false) {
             temperature = value->value;    // Value in C
             rawvalue = value->value;
         }
-        else{
+        else {
             rawvalue = 21.8 + float(random(0, 50)) / 10.0;
             temperature = rawvalue;
         }
-        if(temperature < 10){
-            snprintf(buffer,bsize,"%3.2f",temperature);
+        if (temperature < 10) {
+            snprintf(buffer, bsize, fmt_dec_1, temperature);
         }
-        if(temperature >= 10 && temperature < 100){
-            snprintf(buffer,bsize,"%3.1f",temperature);
+        else if(temperature < 100) {
+            snprintf(buffer, bsize, fmt_dec_10, temperature);
         }
-        if(temperature >= 100){
-            snprintf(buffer,bsize,"%3.0f",temperature);
+        else {
+            snprintf(buffer, bsize, fmt_dec_100, temperature);
         }
         result.unit = "Deg C";
     }
     //########################################################
     else if (value->getFormat() == "formatXdr:H:P"){
         double humidity = 0;
-        if(usesimudata == false) {
+        if (usesimudata == false) {
             humidity = value->value;    // Value in %
             rawvalue = value->value;
         }
@@ -631,143 +648,143 @@ FormatedData formatValue(GwApi::BoatValue *value, CommonData &commondata){
             rawvalue = 41.3 + float(random(0, 50)) / 10.0;
             humidity = rawvalue;
         }
-        if(humidity < 10){
-            snprintf(buffer,bsize,"%3.2f",humidity);
+        if (humidity < 10) {
+            snprintf(buffer, bsize, fmt_dec_1, humidity);
         }
-        if(humidity >= 10 && humidity < 100){
-            snprintf(buffer,bsize,"%3.1f",humidity);
+        else if(humidity < 100) {
+            snprintf(buffer, bsize, fmt_dec_10, humidity);
         }
-        if(humidity >= 100){
-            snprintf(buffer,bsize,"%3.0f",humidity);
+        else {
+            snprintf(buffer, bsize, fmt_dec_100, humidity);
         }
         result.unit = "%";
     }
     //########################################################
     else if (value->getFormat() == "formatXdr:V:P"){
         double volume = 0;
-        if(usesimudata == false) {
+        if (usesimudata == false) {
             volume = value->value;    // Value in %
             rawvalue = value->value;
         }
-        else{
+        else {
             rawvalue = 85.8 + float(random(0, 50)) / 10.0;
             volume = rawvalue;
         }
-        if(volume < 10){
-            snprintf(buffer,bsize,"%3.2f",volume);
+        if (volume < 10) {
+            snprintf(buffer, bsize, fmt_dec_1, volume);
         }
-        if(volume >= 10 && volume < 100){
-            snprintf(buffer,bsize,"%3.1f",volume);
+        else if (volume < 100) {
+            snprintf(buffer, bsize, fmt_dec_10, volume);
         }
-        if(volume >= 100){
-            snprintf(buffer,bsize,"%3.0f",volume);
+        else if (volume >= 100) {
+            snprintf(buffer, bsize, fmt_dec_100, volume);
         }
         result.unit = "%";
     }
     //########################################################
     else if (value->getFormat() == "formatXdr:V:M"){
         double volume = 0;
-        if(usesimudata == false) {
+        if (usesimudata == false) {
             volume = value->value;    // Value in l
             rawvalue = value->value;
         }
-        else{
+        else {
             rawvalue = 75.2 + float(random(0, 50)) / 10.0;
             volume = rawvalue;
         }
-        if(volume < 10){
-            snprintf(buffer,bsize,"%3.2f",volume);
+        if (volume < 10) {
+            snprintf(buffer, bsize, fmt_dec_1, volume);
         }
-        if(volume >= 10 && volume < 100){
-            snprintf(buffer,bsize,"%3.1f",volume);
+        else if (volume < 100) {
+            snprintf(buffer, bsize, fmt_dec_10, volume);
         }
-        if(volume >= 100){
-            snprintf(buffer,bsize,"%3.0f",volume);
+        else {
+            snprintf(buffer, bsize, fmt_dec_100, volume);
         }
         result.unit = "l";
     }
     //########################################################
     else if (value->getFormat() == "formatXdr:R:I"){
         double flow = 0;
-        if(usesimudata == false) {
+        if (usesimudata == false) {
             flow = value->value;    // Value in l/min
             rawvalue = value->value;
         }
-        else{
+        else {
             rawvalue = 7.5 + float(random(0, 20)) / 10.0;
             flow = rawvalue;
         }
-        if(flow < 10){
-            snprintf(buffer,bsize,"%3.2f",flow);
+        if (flow < 10) {
+            snprintf(buffer, bsize, fmt_dec_1, flow);
         }
-        if(flow >= 10 && flow < 100){
-            snprintf(buffer,bsize,"%3.1f",flow);
+        else if (flow < 100) {
+            snprintf(buffer, bsize, fmt_dec_10, flow);
         }
-        if(flow >= 100){
-            snprintf(buffer,bsize,"%3.0f",flow);
+        else {
+            snprintf(buffer, bsize, fmt_dec_100, flow);
         }
         result.unit = "l/min";
     }
     //########################################################
     else if (value->getFormat() == "formatXdr:G:"){
         double generic = 0;
-        if(usesimudata == false) {
-            generic = value->value;    // Value in l/min
+        if (usesimudata == false) {
+            generic = value->value;
             rawvalue = value->value;
         }
-        else{
+        else {
             rawvalue = 18.5 + float(random(0, 20)) / 10.0;
             generic = rawvalue;
         }
-        if(generic < 10){
-            snprintf(buffer,bsize,"%3.2f",generic);
+        if (generic < 10) {
+            snprintf(buffer, bsize, fmt_dec_1, generic);
         }
-        if(generic >= 10 && generic < 100){
-            snprintf(buffer,bsize,"%3.1f",generic);
+        else if (generic < 100) {
+            snprintf(buffer, bsize, fmt_dec_10, generic);
         }
-        if(generic >= 100){
-            snprintf(buffer,bsize,"%3.0f",generic);
+        else {
+            snprintf(buffer, bsize, fmt_dec_100, generic);
         }
         result.unit = "";
     }
     //########################################################
     else if (value->getFormat() == "formatXdr:A:P"){
         double dplace = 0;
-        if(usesimudata == false) {
+        if (usesimudata == false) {
             dplace = value->value;    // Value in %
             rawvalue = value->value;
         }
-        else{
+        else {
             rawvalue = 55.3 + float(random(0, 20)) / 10.0;
             dplace = rawvalue;
         }
-        if(dplace < 10){
-            snprintf(buffer,bsize,"%3.2f",dplace);
+        if (dplace < 10) {
+            snprintf(buffer, bsize, fmt_dec_1, dplace);
         }
-        if(dplace >= 10 && dplace < 100){
-            snprintf(buffer,bsize,"%3.1f",dplace);
+        else if (dplace < 100) {
+            snprintf(buffer, bsize, fmt_dec_10, dplace);
         }
-        if(dplace >= 100){
-            snprintf(buffer,bsize,"%3.0f",dplace);
+        else {
+            snprintf(buffer, bsize, fmt_dec_100, dplace);
         }
         result.unit = "%";
     }
     //########################################################
     else if (value->getFormat() == "formatXdr:A:D"){
         double angle = 0;
-        if(usesimudata == false) {
+        if (usesimudata == false) {
             angle = value->value;
             angle = angle * 57.2958;      // Unit conversion form rad to deg
             rawvalue = value->value;
         }
-        else{
+        else {
             rawvalue = PI / 100 + (random(-5, 5) / 360 * 2* PI);
             angle = rawvalue * 57.2958;
         }
-        if(angle > -10 && angle < 10){
+        if (angle > -10 && angle < 10) {
             snprintf(buffer,bsize,"%3.1f",angle);
         }
-        else{
+        else {
             snprintf(buffer,bsize,"%3.0f",angle);
         }
         result.unit = "Deg";
@@ -775,41 +792,41 @@ FormatedData formatValue(GwApi::BoatValue *value, CommonData &commondata){
     //########################################################
     else if (value->getFormat() == "formatXdr:T:R"){
         double rpm = 0;
-        if(usesimudata == false) {
+        if (usesimudata == false) {
             rpm = value->value;    // Value in rpm
             rawvalue = value->value;
         }
-        else{
+        else {
             rawvalue = 2505 + random(0, 20);
             rpm = rawvalue;
         }
-        if(rpm < 10){
-            snprintf(buffer,bsize,"%3.2f",rpm);
+        if (rpm < 10) {
+            snprintf(buffer, bsize, fmt_dec_1, rpm);
         }
-        if(rpm >= 10 && rpm < 100){
-            snprintf(buffer,bsize,"%3.1f",rpm);
+        else if (rpm < 100) {
+            snprintf(buffer, bsize, fmt_dec_10, rpm);
         }
-        if(rpm >= 100){
-            snprintf(buffer,bsize,"%3.0f",rpm);
+        else {
+            snprintf(buffer, bsize, fmt_dec_100, rpm);
         }
         result.unit = "rpm";
     }
     //########################################################
     // Default format
     //########################################################
-    else{
-        if(value->value < 10){
-            snprintf(buffer,bsize,"%3.2f",value->value);
+    else {
+        if (value->value < 10) {
+            snprintf(buffer, bsize, fmt_dec_1, value->value);
         }
-        if(value->value >= 10 && value->value < 100){
-            snprintf(buffer,bsize,"%3.1f",value->value);
+        else if (value->value < 100) {
+            snprintf(buffer, bsize, fmt_dec_10, value->value);
         }
-        if(value->value >= 100){
-            snprintf(buffer,bsize,"%3.0f",value->value);
+        else {
+            snprintf(buffer, bsize, fmt_dec_100, value->value);
         }
         result.unit = "";
     }
-    buffer[bsize]=0;
+    buffer[bsize] = 0;
     result.value = rawvalue;        // Return value is only necessary in case of simulation of graphic pointer
     result.svalue = String(buffer);
     return result;

lib/obp60task/OBP60Hardware.h

@@ -82,7 +82,7 @@
     // Direction pin for RS485 NMEA0183
     #define OBP_DIRECTION_PIN 8
     // I2C
-    #define I2C_SPEED 10000UL       // 10kHz clock speed on I2C bus
+    #define I2C_SPEED 100000UL       // 100kHz clock speed on I2C bus
     #define OBP_I2C_SDA 21
     #define OBP_I2C_SCL 38
     // DS1388 RTC
@@ -120,10 +120,10 @@
     #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)
     // SPI SD-Card
-    #define SD_SPI_CS 10
-    #define SD_SPI_MOSI 40
-    #define SD_SPI_CLK 39
-    #define SD_SPI_MISO 13
+    #define SD_SPI_CS GPIO_NUM_10
+    #define SD_SPI_MOSI GPIO_NUM_40
+    #define SD_SPI_CLK GPIO_NUM_39
+    #define SD_SPI_MISO GPIO_NUM_13
 
     // GPS (NEO-6M, NEO-M8N, ATGM336H)
     #define OBP_GPS_RX 19

lib/obp60task/OBPDataOperations.cpp

@@ -0,0 +1,157 @@
+#include "OBPDataOperations.h"
+
+double WindUtils::to2PI(double a)
+{
+    a = fmod(a, 2 * M_PI);
+    if (a < 0.0) {
+        a += 2 * M_PI;
+    }
+    return a;
+}
+
+double WindUtils::toPI(double a)
+{
+    a += M_PI;
+    a = to2PI(a);
+    a -= M_PI;
+
+    return a;
+}
+
+double WindUtils::to360(double a)
+{
+    a = fmod(a, 360);
+    if (a < 0.0) {
+        a += 360;
+    }
+    return a;
+}
+
+double WindUtils::to180(double a)
+{
+    a += 180;
+    a = to360(a);
+    a -= 180;
+
+    return a;
+}
+
+void WindUtils::toCart(const double* phi, const double* r, double* x, double* y)
+{
+    *x = *r * sin(*phi);
+    *y = *r * cos(*phi);
+}
+
+void WindUtils::toPol(const double* x, const double* y, double* phi, double* r)
+{
+    *phi = (M_PI / 2) - atan2(*y, *x);
+    *phi = to2PI(*phi);
+    *r = sqrt(*x * *x + *y * *y);
+}
+
+void WindUtils::addPolar(const double* phi1, const double* r1,
+    const double* phi2, const double* r2,
+    double* phi, double* r)
+{
+    double x1, y1, x2, y2;
+    toCart(phi1, r1, &x1, &y1);
+    toCart(phi2, r2, &x2, &y2);
+    x1 += x2;
+    y1 += y2;
+    toPol(&x1, &y1, phi, r);
+}
+
+void WindUtils::calcTwdSA(const double* AWA, const double* AWS,
+    const double* CTW, const double* STW, const double* HDT,
+    double* TWD, double* TWS, double* TWA)
+{
+    double awd = *AWA + *HDT;
+    awd = to2PI(awd);
+    double stw = -*STW;
+    //    Serial.println("\ncalcTwdSA: AWA: " + String(*AWA) + ", AWS: " + String(*AWS) + ", CTW: " + String(*CTW) + ", STW: " + String(*STW) + ", HDT: " + String(*HDT));
+    addPolar(&awd, AWS, CTW, &stw, TWD, TWS);
+
+    // Normalize TWD and TWA to 0-360°
+    *TWD = to2PI(*TWD);
+    *TWA = toPI(*TWD - *HDT);
+    //    Serial.println("calcTwdSA: TWD: " + String(*TWD) + ", TWS: " + String(*TWS));
+}
+
+bool WindUtils::calcTrueWind(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 stw, hdt, ctw;
+    double twd, tws, twa;
+    static const double DBL_MIN = std::numeric_limits<double>::lowest();
+
+    if (*hdtVal != DBL_MIN) {
+        hdt = *hdtVal; // Use HDT if available
+    } else {
+        if (*hdmVal != DBL_MIN && *varVal != DBL_MIN) {
+            hdt = *hdmVal + *varVal; // Use corrected HDM if HDT is not available
+            hdt = to2PI(hdt);
+        } else if (*cogVal != DBL_MIN) {
+            hdt = *cogVal; // Use COG as fallback if HDT and HDM are not available
+        } else {
+            return false; // Cannot calculate without valid HDT or HDM+VAR or COG
+        }
+    }
+
+    if (*cogVal != DBL_MIN) {
+        ctw = *cogVal; // Use COG as CTW if available
+        //    ctw = *cogVal + ((*cogVal - hdt) / 2); // Estimate CTW from COG
+    } else {
+        ctw = hdt; // 2nd approximation for CTW; hdt must exist if we reach this part of the code
+    }
+
+    if (*stwVal != DBL_MIN) {
+        stw = *stwVal; // Use STW if available
+    } else if (*sogVal != DBL_MIN) {
+        stw = *sogVal;
+    } else {
+        // If STW and SOG are not available, we cannot calculate true wind
+        return false;
+    }
+
+    if ((*awaVal == DBL_MIN) || (*awsVal == DBL_MIN)) {
+        // Cannot calculate true wind without valid AWA, AWS; other checks are done earlier
+        return false;
+    } else {
+        calcTwdSA(awaVal, awsVal, &ctw, &stw, &hdt, &twd, &tws, &twa);
+        *twdVal = twd;
+        *twsVal = tws;
+        *twaVal = twa;
+
+        return true;
+    }
+}
+
+void HstryBuf::fillWndBufSimData(tBoatHstryData& hstryBufs)
+// Fill most part of TWD and TWS history buffer with simulated data
+{
+    double value = 20.0;
+    int16_t value2 = 0;
+    for (int i = 0; i < 900; i++) {
+        value += random(-20, 20);
+        value = WindUtils::to360(value);
+        value2 = static_cast<int16_t>(value * DEG_TO_RAD * 1000);
+        hstryBufs.twdHstry->add(value2);
+    }
+}
+
+/* double genTwdSimDat()
+{
+    simTwd += random(-20, 20);
+    if (simTwd < 0.0)
+        simTwd += 360.0;
+    if (simTwd >= 360.0)
+        simTwd -= 360.0;
+
+    int16_t z = static_cast<int16_t>(DegToRad(simTwd) * 1000.0);
+    pageData.boatHstry.twdHstry->add(z); // Fill the buffer with some test data
+
+    simTws += random(-200, 150) / 10.0; // TWS value in knots
+    simTws = constrain(simTws, 0.0f, 50.0f); // Ensure TWS is between 0 and 50 knots
+    twsValue = simTws;
+}*/

lib/obp60task/OBPDataOperations.h

@@ -0,0 +1,36 @@
+#pragma once
+#include "GwApi.h"
+#include "OBPRingBuffer.h"
+#include <Arduino.h>
+#include <math.h>
+
+typedef struct {
+    RingBuffer<int16_t>* twdHstry;
+    RingBuffer<int16_t>* twsHstry;
+} tBoatHstryData; // Holds pointers to all history buffers for boat data
+
+class HstryBuf {
+
+public:
+    void fillWndBufSimData(tBoatHstryData& hstryBufs); // Fill most part of the TWD and TWS history buffer with simulated data
+};
+
+class WindUtils {
+
+public:
+    static double to2PI(double a);
+    static double toPI(double a);
+    static double to360(double a);
+    static double to180(double a);
+    static void toCart(const double* phi, const double* r, double* x, double* y);
+    static void toPol(const double* x, const double* y, double* phi, double* r);
+    static void addPolar(const double* phi1, const double* r1,
+        const double* phi2, const double* r2,
+        double* phi, double* r);
+    static void calcTwdSA(const double* AWA, const double* AWS,
+        const double* CTW, const double* STW, const double* HDT,
+        double* TWD, double* TWS, double* TWA);
+    static bool calcTrueWind(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);
+};

lib/obp60task/OBPRingBuffer.h

@@ -0,0 +1,60 @@
+#pragma once
+#include "GwSynchronized.h"
+#include <algorithm>
+#include <limits>
+#include <stdexcept>
+#include <vector>
+#include "WString.h"
+
+template <typename T>
+class RingBuffer {
+private:
+    mutable SemaphoreHandle_t bufLocker;
+    std::vector<T> buffer;
+    size_t capacity;
+    size_t head; // Points to the next insertion position
+    size_t first; // Points to the first (oldest) valid element
+    size_t last; // Points to the last (newest) valid element
+    size_t count; // Number of valid elements currently in buffer
+    bool is_Full; // Indicates that all buffer elements are used and ringing is in use
+    T MIN_VAL; // lowest possible value of buffer
+    T MAX_VAL; // highest possible value of buffer of type <T>
+
+    // metadata for buffer
+    String dataName; // Name of boat data in buffer
+    String dataFmt; // Format of boat data in buffer
+    int updFreq; // Update frequency in milliseconds
+    T smallest; // Value range of buffer: smallest value
+    T largest; // Value range of buffer: biggest value
+
+public:
+    RingBuffer(size_t size);
+    void setMetaData(String name, String format, int updateFrequency, T minValue, T maxValue); // Set meta data for buffer
+    bool getMetaData(String& name, String& format, int& updateFrequency, T& minValue, T& maxValue); // Get meta data of buffer
+    String getName() const; // Get buffer name
+    void add(const T& value); // Add a new value to  buffer
+    T get(size_t index) const; // Get value at specific position (0-based index from oldest to newest)
+    T getFirst() const; // Get the first (oldest) value in buffer
+    T getLast() const; // Get the last (newest) value in buffer
+    T getMin() const; // Get the lowest value in buffer
+    T getMin(size_t amount) const; // Get minimum value of the last <amount> values of buffer
+    T getMax() const; // Get the highest value in buffer
+    T getMax(size_t amount) const; // Get maximum value of the last <amount> values of buffer
+    T getMid() const; // Get mid value between <min> and <max> value in buffer
+    T getMid(size_t amount) const; // Get mid value between <min> and <max> value of the last <amount> values of buffer
+    T getMedian() const; // Get the median value in buffer
+    T getMedian(size_t amount) const; // Get the median value of the last <amount> values of buffer
+    size_t getCapacity() const; // Get the buffer capacity (maximum size)
+    size_t getCurrentSize() const; // Get the current number of elements in buffer
+    size_t getFirstIdx() const; // Get the index of oldest value in buffer
+    size_t getLastIdx() const; // Get the index of newest value in buffer
+    bool isEmpty() const; // Check if buffer is empty
+    bool isFull() const; // Check if buffer is full
+    T getMinVal() const; // Get lowest possible value for buffer; used for initialized buffer data
+    T getMaxVal() const; // Get highest possible value for buffer
+    void clear(); // Clear buffer
+    T operator[](size_t index) const; // Operator[] for convenient access (same as get())
+    std::vector<T> getAllValues() const; // Get all current values as a vector
+};
+
+#include "OBPRingBuffer.tpp"

lib/obp60task/OBPRingBuffer.tpp

@@ -0,0 +1,376 @@
+#include "OBPRingBuffer.h"
+
+template <typename T>
+RingBuffer<T>::RingBuffer(size_t size)
+    : capacity(size)
+    , head(0)
+    , first(0)
+    , last(0)
+    , count(0)
+    , is_Full(false)
+{
+    bufLocker = xSemaphoreCreateMutex();
+
+    if (size == 0) {
+        // return false;
+    }
+
+    MIN_VAL = std::numeric_limits<T>::lowest();
+    MAX_VAL = std::numeric_limits<T>::max();
+    dataName = "";
+    dataFmt = "";
+    updFreq = -1;
+    smallest = MIN_VAL;
+    largest = MAX_VAL;
+
+    buffer.resize(size, MIN_VAL);
+
+    // return true;
+}
+
+// Specify meta data of buffer content
+template <typename T>
+void RingBuffer<T>::setMetaData(String name, String format, int updateFrequency, T minValue, T maxValue)
+{
+    GWSYNCHRONIZED(&bufLocker);
+    dataName = name;
+    dataFmt = format;
+    updFreq = updateFrequency;
+    smallest = std::max(MIN_VAL, minValue);
+    largest = std::min(MAX_VAL, maxValue);
+}
+
+// Get meta data of buffer content
+template <typename T>
+bool RingBuffer<T>::getMetaData(String& name, String& format, int& updateFrequency, T& minValue, T& maxValue)
+{
+    if (dataName == "" || dataFmt == "" || updFreq == -1) {
+        return false; // Meta data not set
+    }
+
+    GWSYNCHRONIZED(&bufLocker);
+    name = dataName;
+    format = dataFmt;
+    updateFrequency = updFreq;
+    minValue = smallest;
+    maxValue = largest;
+    return true;
+}
+
+// Get buffer name
+template <typename T>
+String RingBuffer<T>::getName() const
+{
+    return dataName;
+}
+
+// Add a new value to buffer
+template <typename T>
+void RingBuffer<T>::add(const T& value)
+{
+    GWSYNCHRONIZED(&bufLocker);
+    if (value < smallest || value > largest) {
+        buffer[head] = MIN_VAL; // Store MIN_VAL if value is out of range
+    } else {
+        buffer[head] = value;
+    }
+    last = head;
+
+    if (is_Full) {
+        first = (first + 1) % capacity; // Move pointer to oldest element when overwriting
+    } else {
+        count++;
+        if (count == capacity) {
+            is_Full = true;
+        }
+    }
+
+    head = (head + 1) % capacity;
+}
+
+// Get value at specific position (0-based index from oldest to newest)
+template <typename T>
+T RingBuffer<T>::get(size_t index) const
+{
+    GWSYNCHRONIZED(&bufLocker);
+    if (isEmpty() || index < 0 || index >= count) {
+        return MIN_VAL;
+    }
+
+    size_t realIndex = (first + index) % capacity;
+    return buffer[realIndex];
+}
+
+// Operator[] for convenient access (same as get())
+template <typename T>
+T RingBuffer<T>::operator[](size_t index) const
+{
+    return get(index);
+}
+
+// Get the first (oldest) value in the buffer
+template <typename T>
+T RingBuffer<T>::getFirst() const
+{
+    if (isEmpty()) {
+        return MIN_VAL;
+    }
+    return get(0);
+}
+
+// Get the last (newest) value in the buffer
+template <typename T>
+T RingBuffer<T>::getLast() const
+{
+    if (isEmpty()) {
+        return MIN_VAL;
+    }
+    return get(count - 1);
+}
+
+// Get the lowest value in the buffer
+template <typename T>
+T RingBuffer<T>::getMin() const
+{
+    if (isEmpty()) {
+        return MIN_VAL;
+    }
+
+    T minVal = MAX_VAL;
+    T value;
+    for (size_t i = 0; i < count; i++) {
+        value = get(i);
+        if (value < minVal && value != MIN_VAL) {
+            minVal = value;
+        }
+    }
+    return minVal;
+}
+
+// Get minimum value of the last <amount> values of buffer
+template <typename T>
+T RingBuffer<T>::getMin(size_t amount) const
+{
+    if (isEmpty() || amount <= 0) {
+        return MIN_VAL;
+    }
+    if (amount > count)
+        amount = count;
+
+    T minVal = MAX_VAL;
+    T value;
+    for (size_t i = 0; i < amount; i++) {
+        value = get(count - 1 - i);
+        if (value < minVal && value != MIN_VAL) {
+            minVal = value;
+        }
+    }
+    return minVal;
+}
+
+// Get the highest value in the buffer
+template <typename T>
+T RingBuffer<T>::getMax() const
+{
+    if (isEmpty()) {
+        return MIN_VAL;
+    }
+
+    T maxVal = MIN_VAL;
+    T value;
+    for (size_t i = 0; i < count; i++) {
+        value = get(i);
+        if (value > maxVal && value != MIN_VAL) {
+            maxVal = value;
+        }
+    }
+    return maxVal;
+}
+
+// Get maximum value of the last <amount> values of buffer
+template <typename T>
+T RingBuffer<T>::getMax(size_t amount) const
+{
+    if (isEmpty() || amount <= 0) {
+        return MIN_VAL;
+    }
+    if (amount > count)
+        amount = count;
+
+    T maxVal = MIN_VAL;
+    T value;
+    for (size_t i = 0; i < amount; i++) {
+        value = get(count - 1 - i);
+        if (value > maxVal && value != MIN_VAL) {
+            maxVal = value;
+        }
+    }
+    return maxVal;
+}
+
+// Get mid value between <min> and <max> value in the buffer
+template <typename T>
+T RingBuffer<T>::getMid() const
+{
+    if (isEmpty()) {
+        return MIN_VAL;
+    }
+
+    return (getMin() + getMax()) / static_cast<T>(2);
+}
+
+// Get mid value between <min> and <max> value of the last <amount> values of buffer
+template <typename T>
+T RingBuffer<T>::getMid(size_t amount) const
+{
+    if (isEmpty() || amount <= 0) {
+        return MIN_VAL;
+    }
+
+    if (amount > count)
+        amount = count;
+
+    return (getMin(amount) + getMax(amount)) / static_cast<T>(2);
+}
+
+// Get the median value in the buffer
+template <typename T>
+T RingBuffer<T>::getMedian() const
+{
+    if (isEmpty()) {
+        return MIN_VAL;
+    }
+
+    // Create a temporary vector with current valid elements
+    std::vector<T> temp;
+    temp.reserve(count);
+
+    for (size_t i = 0; i < count; i++) {
+        temp.push_back(get(i));
+    }
+
+    // Sort to find median
+    std::sort(temp.begin(), temp.end());
+
+    if (count % 2 == 1) {
+        // Odd number of elements
+        return temp[count / 2];
+    } else {
+        // Even number of elements - return average of middle two
+        // Note: For integer types, this truncates. For floating point, it's exact.
+        return (temp[count / 2 - 1] + temp[count / 2]) / 2;
+    }
+}
+
+// Get the median value of the last <amount> values of buffer
+template <typename T>
+T RingBuffer<T>::getMedian(size_t amount) const
+{
+    if (isEmpty() || amount <= 0) {
+        return MIN_VAL;
+    }
+    if (amount > count)
+        amount = count;
+
+    // Create a temporary vector with current valid elements
+    std::vector<T> temp;
+    temp.reserve(amount);
+
+    for (size_t i = 0; i < amount; i++) {
+        temp.push_back(get(i));
+    }
+
+    // Sort to find median
+    std::sort(temp.begin(), temp.end());
+
+    if (amount % 2 == 1) {
+        // Odd number of elements
+        return temp[amount / 2];
+    } else {
+        // Even number of elements - return average of middle two
+        // Note: For integer types, this truncates. For floating point, it's exact.
+        return (temp[amount / 2 - 1] + temp[amount / 2]) / 2;
+    }
+}
+
+// Get the buffer capacity (maximum size)
+template <typename T>
+size_t RingBuffer<T>::getCapacity() const
+{
+    return capacity;
+}
+
+// Get the current number of elements in the buffer
+template <typename T>
+size_t RingBuffer<T>::getCurrentSize() const
+{
+    return count;
+}
+
+// Get the first index of buffer
+template <typename T>
+size_t RingBuffer<T>::getFirstIdx() const
+{
+    return first;
+}
+
+// Get the last index of buffer
+template <typename T>
+size_t RingBuffer<T>::getLastIdx() const
+{
+    return last;
+}
+
+// Check if buffer is empty
+template <typename T>
+bool RingBuffer<T>::isEmpty() const
+{
+    return count == 0;
+}
+
+// Check if buffer is full
+template <typename T>
+bool RingBuffer<T>::isFull() const
+{
+    return is_Full;
+}
+
+// Get lowest possible value for buffer; used for non-set buffer data
+template <typename T>
+T RingBuffer<T>::getMinVal() const
+{
+    return MIN_VAL;
+}
+
+// Get highest possible value for buffer
+template <typename T>
+T RingBuffer<T>::getMaxVal() const
+{
+    return MAX_VAL;
+}
+
+// Clear buffer
+template <typename T>
+void RingBuffer<T>::clear()
+{
+    GWSYNCHRONIZED(&bufLocker);
+    head = 0;
+    first = 0;
+    last = 0;
+    count = 0;
+    is_Full = false;
+}
+
+// Get all current values as a vector
+template <typename T>
+std::vector<T> RingBuffer<T>::getAllValues() const
+{
+    std::vector<T> result;
+    result.reserve(count);
+
+    for (size_t i = 0; i < count; i++) {
+        result.push_back(get(i));
+    }
+
+    return result;
+}

lib/obp60task/PageClock.cpp

@@ -120,7 +120,7 @@ bool homevalid = false; // homelat and homelon are valid
         }
         else{
             value1 = simtime++;                         // Simulation data for time value 11:36 in seconds
-        }                                               // Other simulation data see OBP60Formater.cpp
+        }                                               // Other simulation data see OBP60Formatter.cpp
         bool valid1 = bvalue1->valid;                   // Valid information 
         String svalue1 = formatValue(bvalue1, *commonData).svalue;    // Formatted value as string including unit conversion and switching decimal places
         String unit1 = formatValue(bvalue1, *commonData).unit;        // Unit of value

lib/obp60task/PageCompass.cpp

@@ -83,7 +83,7 @@ class PageCompass : public Page
         String DataText[HowManyValues];
         String DataUnits[HowManyValues];
         String DataFormat[HowManyValues];
-        FormatedData TheFormattedData;
+        FormattedData TheFormattedData;
 
         for (int i = 0; i < HowManyValues; i++){
             bvalue = pageData.values[i];

lib/obp60task/PageFourValues.cpp

@@ -53,7 +53,7 @@ class PageFourValues : public Page
         String unit1 = formatValue(bvalue1, *commonData).unit;        // Unit of value
 
         // Get boat values #2
-        GwApi::BoatValue *bvalue2 = pageData.values[1]; // Second element in list (only one value by PageOneValue)
+        GwApi::BoatValue *bvalue2 = pageData.values[1]; // Second element in list
         String name2 = xdrDelete(bvalue2->getName());   // Value name
         name2 = name2.substring(0, 6);                  // String length limit for value name
         calibrationData.calibrateInstance(bvalue2, logger); // Check if boat data value is to be calibrated
@@ -63,7 +63,7 @@ class PageFourValues : public Page
         String unit2 = formatValue(bvalue2, *commonData).unit;        // Unit of value
 
         // Get boat values #3
-        GwApi::BoatValue *bvalue3 = pageData.values[2]; // Second element in list (only one value by PageOneValue)
+        GwApi::BoatValue *bvalue3 = pageData.values[2]; // Third element in list
         String name3 = xdrDelete(bvalue3->getName());   // Value name
         name3 = name3.substring(0, 6);                  // String length limit for value name
         calibrationData.calibrateInstance(bvalue3, logger); // Check if boat data value is to be calibrated
@@ -73,7 +73,7 @@ class PageFourValues : public Page
         String unit3 = formatValue(bvalue3, *commonData).unit;        // Unit of value
 
         // Get boat values #4
-        GwApi::BoatValue *bvalue4 = pageData.values[3]; // Second element in list (only one value by PageOneValue)
+        GwApi::BoatValue *bvalue4 = pageData.values[3]; // Fourth element in list
         String name4 = xdrDelete(bvalue4->getName());   // Value name
         name4 = name4.substring(0, 6);                  // String length limit for value name
         calibrationData.calibrateInstance(bvalue4, logger); // Check if boat data value is to be calibrated

lib/obp60task/PageKeelPosition.cpp

@@ -86,8 +86,7 @@ public:
             float x = 200 + (rInstrument-30)*sin(i/180.0*pi);  //  x-coordinate dots
             float y = 150 - (rInstrument-30)*cos(i/180.0*pi);  //  y-coordinate cots 
             const char *ii = " ";
-            switch (i)
-            {
+            switch (i) {
                 case 0: ii=" "; break;      // Use a blank for a empty scale value
                 case 30 : ii=" "; break;
                 case 60 : ii=" "; break;

lib/obp60task/PageRollPitch.cpp

@@ -41,9 +41,9 @@ public:
         String backlightMode = config->getString(config->backlight);
         int rolllimit = config->getInt(config->rollLimit);
         String roffset = config->getString(config->rollOffset);
-        double rolloffset = roffset.toFloat()/360*(2*PI);
+        double rolloffset = roffset.toFloat()/360*(2*M_PI);
         String poffset = config->getString(config->pitchOffset);
-        double pitchoffset = poffset.toFloat()/360*(2*PI);
+        double pitchoffset = poffset.toFloat()/360*(2*M_PI);
 
         // Get boat values for roll
         GwApi::BoatValue *bvalue1 = pageData.values[0]; // First element in list (xdrRoll)
@@ -55,17 +55,17 @@ public:
         }
         else{
             if(simulation == true){
-                value1 = (20 + float(random(0, 50)) / 10.0)/360*2*PI;
+                value1 = (20 + float(random(0, 50)) / 10.0)/360*2*M_PI;
             }
             else{
                 value1 = 0;
             }
         }
-        if(value1/(2*PI)*360 > -10 && value1/(2*PI)*360 < 10){
-            svalue1 = String(value1/(2*PI)*360,1);      // Convert raw value to string
+        if(value1/(2*M_PI)*360 > -10 && value1/(2*M_PI)*360 < 10){
+            svalue1 = String(value1/(2*M_PI)*360,1);      // Convert raw value to string
         }
         else{
-            svalue1 = String(value1/(2*PI)*360,0);
+            svalue1 = String(value1/(2*M_PI)*360,0);
         }
         if(valid1 == true){
            svalue1old = svalue1;                                       // Save the old value
@@ -80,17 +80,17 @@ public:
         }
         else{
              if(simulation == true){
-                value2 = (float(random(-5, 5)))/360*2*PI;
+                value2 = (float(random(-5, 5)))/360*2*M_PI;
             }
             else{
                 value2 = 0;
             }
         }
-        if(value2/(2*PI)*360 > -10 && value2/(2*PI)*360 < 10){
-            svalue2 = String(value2/(2*PI)*360,1);      // Convert raw value to string
+        if(value2/(2*PI)*360 > -10 && value2/(2*M_PI)*360 < 10){
+            svalue2 = String(value2/(2*M_PI)*360,1);      // Convert raw value to string
         }
         else{
-            svalue2 = String(value2/(2*PI)*360,0);
+            svalue2 = String(value2/(2*M_PI)*360,0);
         }
         if(valid2 == true){
            svalue2old = svalue2;                                       // Save the old value
@@ -99,7 +99,7 @@ public:
         // Optical warning by limit violation
         if(String(flashLED) == "Limit Violation"){
             // Limits for roll
-            if(value1*360/(2*PI) >= -1*rolllimit && value1*360/(2*PI) <= rolllimit){
+            if(value1*360/(2*M_PI) >= -1*rolllimit && value1*360/(2*M_PI) <= rolllimit){
                 setBlinkingLED(false);
                 setFlashLED(false);
             }
@@ -177,11 +177,10 @@ public:
             // Only scaling +/- 60 degrees
             if((i >= 0 && i <= 60) ||  (i >= 300 && i <= 360)){
                 // Scaling values
-                float x = 200 + (rInstrument+25)*sin(i/180.0*pi);  //  x-coordinate dots
-                float y = 150 - (rInstrument+25)*cos(i/180.0*pi);  //  y-coordinate cots
+                float x = 200 + (rInstrument+25)*sin(i/180.0*M_PI);  //  x-coordinate dots
+                float y = 150 - (rInstrument+25)*cos(i/180.0*M_PI);  //  y-coordinate cots
                 const char *ii = "";
-                switch (i)
-                {
+                switch (i) {
                     case 0: ii="0"; break;
                     case 20 : ii="20"; break;
                     case 40 : ii="40"; break;
@@ -203,11 +202,11 @@ public:
                 }
 
                 // Draw sub scale with dots
-                float x1c = 200 + rInstrument*sin(i/180.0*pi);
-                float y1c = 150 - rInstrument*cos(i/180.0*pi);
+                float x1c = 200 + rInstrument*sin(i/180.0*M_PI);
+                float y1c = 150 - rInstrument*cos(i/180.0*M_PI);
                 getdisplay().fillCircle((int)x1c, (int)y1c, 2, commonData->fgcolor);
-                float sinx=sin(i/180.0*pi);
-                float cosx=cos(i/180.0*pi); 
+                float sinx=sin(i/180.0*M_PI);
+                float cosx=cos(i/180.0*M_PI);
 
                 // Draw sub scale with lines (two triangles)
                 if(i % 20 == 0){
@@ -229,11 +228,11 @@ public:
         // Draw mast position pointer
         float startwidth = 8;           // Start width of pointer
 
-//        value1 = (2 * pi ) - value1;    // Mirror coordiante system for pointer, keel and boat
+//        value1 = (2 * M_PI ) - value1;    // Mirror coordiante system for pointer, keel and boat
 
         if(valid1 == true || holdvalues == true || simulation == true){
-            float sinx=sin(value1 + pi);
-            float cosx=cos(value1 + pi);
+            float sinx=sin(value1 + M_PI);
+            float cosx=cos(value1 + M_PI);
             // Normal pointer
             // Pointer as triangle with center base 2*width
             float xx1 = -startwidth;

lib/obp60task/PageSystem.cpp

@@ -1,5 +1,15 @@
 #if defined BOARD_OBP60S3 || defined BOARD_OBP40S3
 
+/*
+ * Special system page, called directly with fast key sequence 5,4
+ * Out of normal page order.
+ * Consists of some sub-pages with following content:
+ *   1. Hard and software information
+ *   2. System settings
+ *   3. NMEA2000 device list
+ *   4. SD Card information if available
+ */
+
 #include "Pagedata.h"
 #include "OBP60Extensions.h"
 #include "images/logo64.xbm"
@@ -7,8 +17,7 @@
 #include "qrcode.h"
 
 #ifdef BOARD_OBP40S3
-#include <SD.h>
-#include <FS.h>
+#include "dirent.h"
 #endif
 
 #define STRINGIZE_IMPL(x) #x
@@ -19,35 +28,27 @@
 #define DISPLAYINFO STRINGIZE(EPDTYPE)
 #define GXEPD2INFO STRINGIZE(GXEPD2VERS)
 
-/*
- * Special system page, called directly with fast key sequence 5,4
- * Out of normal page order.
- * Consists of some sub-pages with following content:
- *   1. Hard and software information
- *   2. System settings
- *   3. NMEA2000 device list
- */
-
 class PageSystem : public Page
 {
-uint64_t chipid;
-bool simulation;
-bool sdcard;
-String buzzer_mode;
-uint8_t buzzer_power;
-String cpuspeed;
-String rtc_module;
-String gps_module;
-String env_module;
+private:
+    uint64_t chipid;
+    bool simulation;
+    bool use_sdcard;
+    String buzzer_mode;
+    uint8_t buzzer_power;
+    String cpuspeed;
+    String rtc_module;
+    String gps_module;
+    String env_module;
 
-String batt_sensor;
-String solar_sensor;
-String gen_sensor;
-String rot_sensor;
-double homelat;
-double homelon;
+    String batt_sensor;
+    String solar_sensor;
+    String gen_sensor;
+    String rot_sensor;
+    double homelat;
+    double homelon;
 
-char mode = 'N'; // (N)ormal, (S)ettings, (D)evice list, (C)ard
+    char mode = 'N'; // (N)ormal, (S)ettings, (D)evice list, (C)ard
 
 public:
     PageSystem(CommonData &common){
@@ -55,11 +56,12 @@ public:
         common.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);
         }
         chipid = ESP.getEfuseMac();
         simulation = common.config->getBool(common.config->useSimuData);
 #ifdef BOARD_OBP40S3
-        sdcard = common.config->getBool(common.config->useSDCard);
+        use_sdcard = common.config->getBool(common.config->useSDCard);
 #endif
         buzzer_mode = common.config->getString(common.config->buzzerMode);
         buzzer_mode.toLowerCase();
@@ -76,7 +78,7 @@ public:
         homelon = common.config->getString(common.config->homeLON).toDouble();
     }
 
-    virtual void setupKeys(){
+    void setupKeys() {
         commonData->keydata[0].label = "EXIT";
         commonData->keydata[1].label = "MODE";
         commonData->keydata[2].label = "";
@@ -85,7 +87,7 @@ public:
         commonData->keydata[5].label = "ILUM";
     }
 
-    virtual int handleKey(int key){
+    int handleKey(int key) {
         // do *NOT* handle key #1 this handled by obp60task as exit
         // Switch display mode
         commonData->logger->logDebug(GwLog::LOG, "System keyboard handler");
@@ -95,7 +97,7 @@ public:
             } else if (mode == 'S') {
                 mode = 'D';
             } else if (mode == 'D') {
-                if (sdcard) {
+                if (hasSDCard) {
                     mode = 'C';
                 } else {
                     mode = 'N';
@@ -117,6 +119,7 @@ public:
         }
         // standby / deep sleep
         if (key == 5) {
+            commonData->logger->logDebug(GwLog::LOG, "System going into deep sleep mode...");
             deepSleep(*commonData);
         }
         // Code for keylock
@@ -132,6 +135,7 @@ public:
         }
         // standby / deep sleep
         if (key == 12) {
+            commonData->logger->logDebug(GwLog::LOG, "System going into deep sleep mode...");
             deepSleep(*commonData);
         }
 #endif
@@ -178,7 +182,7 @@ public:
         }
 
         // Logging boat values
-        LOG_DEBUG(GwLog::LOG,"Drawing at PageSystem");
+        logger->logDebug(GwLog::LOG, "Drawing at PageSystem, Mode=%c", mode);
 
         // Draw page
         //***********************************************************
@@ -257,14 +261,37 @@ public:
             getdisplay().setCursor(8, y0 + 48);
             getdisplay().print("SD-Card:");
             getdisplay().setCursor(90, y0 + 48);
-            if (sdcard) {
-                uint64_t cardsize = SD.cardSize() / (1024 * 1024);
-                getdisplay().print(String(cardsize) + String(" MB"));
+            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:");
@@ -371,8 +398,61 @@ public:
             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

lib/obp60task/PageThreeValues.cpp

@@ -51,7 +51,7 @@ class PageThreeValues : public Page
         String unit1 = formatValue(bvalue1, *commonData).unit;        // Unit of value
 
         // Get boat values #2
-        GwApi::BoatValue *bvalue2 = pageData.values[1]; // Second element in list (only one value by PageOneValue)
+        GwApi::BoatValue *bvalue2 = pageData.values[1]; // Second element in list
         String name2 = xdrDelete(bvalue2->getName());   // Value name
         name2 = name2.substring(0, 6);                  // String length limit for value name
         calibrationData.calibrateInstance(bvalue2, logger); // Check if boat data value is to be calibrated
@@ -61,7 +61,7 @@ class PageThreeValues : public Page
         String unit2 = formatValue(bvalue2, *commonData).unit;        // Unit of value
 
         // Get boat values #3
-        GwApi::BoatValue *bvalue3 = pageData.values[2]; // Second element in list (only one value by PageOneValue)
+        GwApi::BoatValue *bvalue3 = pageData.values[2]; // Third element in list
         String name3 = xdrDelete(bvalue3->getName());      // Value name
         name3 = name3.substring(0, 6);                  // String length limit for value name
         calibrationData.calibrateInstance(bvalue3, logger); // Check if boat data value is to be calibrated

lib/obp60task/PageTwoValues.cpp

@@ -49,7 +49,7 @@ class PageTwoValues : public Page
         String unit1 = formatValue(bvalue1, *commonData).unit;        // Unit of value
 
         // Get boat values #2
-        GwApi::BoatValue *bvalue2 = pageData.values[1]; // Second element in list (only one value by PageOneValue)
+        GwApi::BoatValue *bvalue2 = pageData.values[1]; // Second element in list
         String name2 = xdrDelete(bvalue2->getName());   // Value name
         name2 = name2.substring(0, 6);                  // String length limit for value name
         calibrationData.calibrateInstance(bvalue2, logger); // Check if boat data value is to be calibrated

lib/obp60task/PageWhite.cpp

@@ -2,8 +2,14 @@
 
 #include "Pagedata.h"
 #include "OBP60Extensions.h"
-#include "MFD_OBP60_400x300_sw.h"       // MFD with logo
-#include "Logo_OBP_400x300_sw.h"        // OBP Logo
+
+#include "images/OBP_400x300.xbm"     // OBP Logo
+#ifdef BOARD_OBP60S3
+#include "images/OBP60_400x300.xbm"   // MFD with logo
+#endif
+#ifdef BOARD_OBP40S3
+#include "images/OBP40_400x300.xbm"   // MFD with logo
+#endif
 
 class PageWhite : public Page
 {
@@ -61,20 +67,21 @@ public:
         }
 
         if (mode == 'L') {
-            getdisplay().drawBitmap(0, 0, gImage_Logo_OBP_400x300_sw, getdisplay().width(), getdisplay().height(), commonData->fgcolor);
+            getdisplay().drawXBitmap(0, 0, OBP_400x300_bits, OBP_400x300_width, OBP_400x300_height, commonData->fgcolor);
         } else if (mode == 'M') {
-            getdisplay().drawBitmap(0, 0, gImage_MFD_OBP60_400x300_sw, getdisplay().width(), getdisplay().height(), commonData->fgcolor);
+#ifdef BOARD_OBP60S3
+            getdisplay().drawXBitmap(0, 0, OBP60_400x300_bits, OBP60_400x300_width, OBP60_400x300_height, commonData->fgcolor);
+#endif
+#ifdef BOARD_OBP40S3
+            getdisplay().drawXBitmap(0, 0, OBP40_400x300_bits, OBP40_400x300_width, OBP40_400x300_height, commonData->fgcolor);
+#endif
         }
 
-        // Update display
-        // getdisplay().nextPage();
         int ret = PAGE_UPDATE;
         if (mode == 'W') {
-            //getdisplay().hibernate();
             ret |= PAGE_HIBERNATE;
         }
         return ret;
-
     };
 };
 

lib/obp60task/PageWindPlot.cpp

@@ -0,0 +1,479 @@
+#if defined BOARD_OBP60S3 || defined BOARD_OBP40S3
+
+#include "BoatDataCalibration.h"
+#include "OBP60Extensions.h"
+#include "OBPRingBuffer.h"
+#include "Pagedata.h"
+#include <vector>
+
+static const double radToDeg = 180.0 / M_PI; // Conversion factor from radians to degrees
+
+// Get maximum difference of last <amount> of TWD ringbuffer values to center chart
+int getRng(const RingBuffer<int16_t>& windDirHstry, int center, size_t amount)
+{
+    int minVal = windDirHstry.getMinVal();
+    size_t count = windDirHstry.getCurrentSize();
+    //    size_t capacity = windDirHstry.getCapacity();
+    //    size_t last = windDirHstry.getLastIdx();
+
+    if (windDirHstry.isEmpty() || amount <= 0) {
+        return minVal;
+    }
+    if (amount > count)
+        amount = count;
+
+    int value = 0;
+    int rng = 0;
+    int maxRng = minVal;
+    // Start from the newest value (last) and go backwards x times
+    for (size_t i = 0; i < amount; i++) {
+        //        value = windDirHstry.get(((last - i) % capacity + capacity) % capacity);
+        value = windDirHstry.get(count - 1 - i);
+
+        if (value == minVal) {
+            continue;
+        }
+
+        value = value / 1000.0 * radToDeg;
+        rng = abs(((value - center + 540) % 360) - 180);
+        if (rng > maxRng)
+            maxRng = rng;
+    }
+    if (maxRng > 180) {
+        maxRng = 180;
+    }
+
+    return maxRng;
+}
+
+// ****************************************************************
+class PageWindPlot : public Page {
+
+    bool keylock = false; // Keylock
+    char chrtMode = 'D'; // Chart mode: 'D' for TWD, 'S' for TWS, 'B' for both
+    int dataIntv = 1; // Update interval for wind history chart:
+                      // (1)|(2)|(3)|(4) seconds for approx. 4, 8, 12, 16 min. history chart
+    bool showTWS = true; // Show TWS value in chart area
+
+public:
+    PageWindPlot(CommonData& common)
+    {
+        commonData = &common;
+        common.logger->logDebug(GwLog::LOG, "Instantiate PageWindPlot");
+    }
+
+    virtual void setupKeys()
+    {
+        Page::setupKeys();
+        //        commonData->keydata[0].label = "MODE";
+        commonData->keydata[1].label = "INTV";
+        commonData->keydata[4].label = "TWS";
+    }
+
+    // Key functions
+    virtual int handleKey(int key)
+    {
+        // Set chart mode TWD | TWS -> to be implemented
+        if (key == 1) {
+            if (chrtMode == 'D') {
+                chrtMode = 'S';
+            } else if (chrtMode == 'S') {
+                chrtMode = 'B';
+            } else {
+                chrtMode = 'D';
+            }
+            return 0; // Commit the key
+        }
+
+        // Set interval for wind history chart update time
+        if (key == 2) {
+            if (dataIntv == 1) {
+                dataIntv = 2;
+            } else if (dataIntv == 2) {
+                dataIntv = 3;
+            } else if (dataIntv == 3) {
+                dataIntv = 4;
+            } else {
+                dataIntv = 1;
+            }
+            return 0; // Commit the key
+        }
+
+        // Switch TWS on/off
+        if (key == 5) {
+            showTWS = !showTWS;
+            return 0; // Commit the key
+        }
+
+        // Keylock function
+        if (key == 11) { // Code for keylock
+            commonData->keylock = !commonData->keylock;
+            return 0; // Commit the key
+        }
+        return key;
+    }
+
+    int displayPage(PageData& pageData)
+    {
+        GwConfigHandler* config = commonData->config;
+        GwLog* logger = commonData->logger;
+
+        float twsValue; // TWS value in chart area
+        static String twdName, twdUnit; // TWD name and unit
+        static int updFreq; // Update frequency for TWD
+        static int16_t twdLowest, twdHighest; // TWD range
+        // static int16_t twdBufMinVal; // lowest possible twd buffer value; used for non-set data
+
+        // current boat data values; TWD only for validation test, TWS for display of current value
+        const int numBoatData = 2;
+        GwApi::BoatValue* bvalue;
+        String BDataName[numBoatData];
+        double BDataValue[numBoatData];
+        bool BDataValid[numBoatData];
+        String BDataText[numBoatData];
+        String BDataUnit[numBoatData];
+        String BDataFormat[numBoatData];
+
+        static bool isInitialized = false; // Flag to indicate that page is initialized
+        static bool wndDataValid = false; // Flag to indicate if wind data is valid
+        static int numNoData; // Counter for multiple invalid data values in a row
+        static bool simulation = false;
+        static bool holdValues = false;
+
+        static int width; // Screen width
+        static int height; // Screen height
+        static int xCenter; // Center of screen in x direction
+        static const int yOffset = 48; // Offset for y coordinates of chart area
+        static int cHeight; // height of chart area
+        static int bufSize; // History buffer size: 960 values for appox. 16 min. history chart
+        static int intvBufSize; // Buffer size used for currently selected time interval
+        int count; // current size of buffer
+        static int numWndVals; // number of wind values available for current interval selection
+        static int bufStart; // 1st data value in buffer to show
+        int numAddedBufVals; // Number of values added to buffer since last display
+        size_t currIdx; // Current index in TWD history buffer
+        static size_t lastIdx; // Last index of TWD history buffer
+        static size_t lastAddedIdx = 0; // Last index of TWD history buffer when new data was added
+        static int oldDataIntv; // remember recent user selection of data interval
+
+        static int wndCenter; // chart wind center value position
+        static int wndLeft; // chart wind left value position
+        static int wndRight; // chart wind right value position
+        static int chrtRng; // Range of wind values from mid wind value to min/max wind value in degrees
+        int diffRng; // Difference between mid and current wind value
+        static const int dfltRng = 40; // Default range for chart
+        int midWndDir; // New value for wndCenter after chart start / shift
+        static int simTwd; // Simulation value for TWD
+        static float simTws; // Simulation value for TWS
+
+        int x, y; // x and y coordinates for drawing
+        static int prevX, prevY; // Last x and y coordinates for drawing
+        static float chrtScl; // Scale for wind values in pixels per degree
+        int chrtVal; // Current wind value
+        static int chrtPrevVal; // Last wind value in chart area for check if value crosses 180 degree line
+
+        LOG_DEBUG(GwLog::LOG, "Display page WindPlot");
+
+        // Get config data
+        simulation = config->getBool(config->useSimuData);
+        holdValues = config->getBool(config->holdvalues);
+        String flashLED = config->getString(config->flashLED);
+        String backlightMode = config->getString(config->backlight);
+
+        if (!isInitialized) {
+            width = getdisplay().width();
+            height = getdisplay().height();
+            xCenter = width / 2;
+            cHeight = height - yOffset - 22;
+            bufSize = pageData.boatHstry.twdHstry->getCapacity();
+            numNoData = 0;
+            simTwd = pageData.boatHstry.twdHstry->getLast() / 1000.0 * radToDeg;
+            simTws = 0;
+            twsValue = 0;
+            bufStart = 0;
+            oldDataIntv = 0;
+            numAddedBufVals, currIdx, lastIdx = 0;
+            lastAddedIdx = pageData.boatHstry.twdHstry->getLastIdx();
+            pageData.boatHstry.twdHstry->getMetaData(twdName, twdUnit, updFreq, twdLowest, twdHighest);
+            wndCenter = INT_MIN;
+            midWndDir = 0;
+            diffRng = dfltRng;
+            chrtRng = dfltRng;
+
+            isInitialized = true; // Set flag to indicate that page is now initialized
+        }
+
+        // read boat data values; TWD only for validation test, TWS for display of current value
+        for (int i = 0; i < numBoatData; i++) {
+            bvalue = pageData.values[i];
+            BDataName[i] = xdrDelete(bvalue->getName());
+            BDataName[i] = BDataName[i].substring(0, 6); // String length limit for value name
+            calibrationData.calibrateInstance(bvalue, logger); // Check if boat data value is to be calibrated
+            BDataValue[i] = bvalue->value; // Value as double in SI unit
+            BDataValid[i] = bvalue->valid;
+            BDataText[i] = formatValue(bvalue, *commonData).svalue; // Formatted value as string including unit conversion and switching decimal places
+            BDataUnit[i] = formatValue(bvalue, *commonData).unit;
+            BDataFormat[i] = bvalue->getFormat(); // Unit of value
+        }
+
+        // Optical warning by limit violation (unused)
+        if (String(flashLED) == "Limit Violation") {
+            setBlinkingLED(false);
+            setFlashLED(false);
+        }
+
+        // Identify buffer size and buffer start position for chart
+        count = pageData.boatHstry.twdHstry->getCurrentSize();
+        currIdx = pageData.boatHstry.twdHstry->getLastIdx();
+        numAddedBufVals = (currIdx - lastAddedIdx + bufSize) % bufSize; // Number of values added to buffer since last display
+        if (dataIntv != oldDataIntv || count == 1) {
+            // new data interval selected by user
+            intvBufSize = cHeight * dataIntv;
+            numWndVals = min(count, (cHeight - 60) * dataIntv);
+            bufStart = max(0, count - numWndVals);
+            lastAddedIdx = currIdx;
+            oldDataIntv = dataIntv;
+        } else {
+            numWndVals = numWndVals + numAddedBufVals;
+            lastAddedIdx = currIdx;
+            if (count == bufSize) {
+                bufStart = max(0, bufStart - numAddedBufVals);
+            }
+        }
+        LOG_DEBUG(GwLog::DEBUG, "PageWindPlot Dataset: count: %d, TWD: %.0f, TWS: %.1f, TWD_valid? %d, intvBufSize: %d, numWndVals: %d, bufStart: %d, numAddedBufVals: %d, lastIdx: %d, old: %d, act: %d",
+            count, pageData.boatHstry.twdHstry->getLast() / 1000.0 * radToDeg, pageData.boatHstry.twsHstry->getLast() / 10.0 * 1.94384, BDataValid[0],
+            intvBufSize, numWndVals, bufStart, numAddedBufVals, pageData.boatHstry.twdHstry->getLastIdx(), oldDataIntv, dataIntv);
+
+        // Set wndCenter from 1st real buffer value
+        if (wndCenter == INT_MIN || (wndCenter == 0 && count == 1)) {
+            midWndDir = pageData.boatHstry.twdHstry->getMid(numWndVals);
+            if (midWndDir != INT16_MIN) {
+                midWndDir = midWndDir / 1000.0 * radToDeg;
+                wndCenter = int((midWndDir + (midWndDir >= 0 ? 5 : -5)) / 10) * 10; // Set new center value; round to nearest 10 degree value
+            } else {
+                wndCenter = 0;
+            }
+            LOG_DEBUG(GwLog::DEBUG, "PageWindPlot Range Init: count: %d, TWD: %.0f, wndCenter: %d, diffRng: %d, chrtRng: %d", count, pageData.boatHstry.twdHstry->getLast() / 1000.0 * radToDeg,
+                wndCenter, diffRng, chrtRng);
+        } else {
+            // check and adjust range between left, center, and right chart limit
+            diffRng = getRng(*pageData.boatHstry.twdHstry, wndCenter, numWndVals);
+            diffRng = (diffRng == INT16_MIN ? 0 : diffRng);
+            if (diffRng > chrtRng) {
+                chrtRng = int((diffRng + (diffRng >= 0 ? 9 : -1)) / 10) * 10; // Round up to next 10 degree value
+            } else if (diffRng + 10 < chrtRng) { // Reduce chart range for higher resolution if possible
+                chrtRng = max(dfltRng, int((diffRng + (diffRng >= 0 ? 9 : -1)) / 10) * 10);
+            }
+        }
+        chrtScl = float(width) / float(chrtRng) / 2.0; // Chart scale: pixels per degree
+        wndLeft = wndCenter - chrtRng;
+        if (wndLeft < 0)
+            wndLeft += 360;
+        wndRight = (chrtRng < 180 ? wndCenter + chrtRng : wndCenter + chrtRng - 1);
+        if (wndRight >= 360)
+            wndRight -= 360;
+
+        // Draw page
+        //***********************************************************************
+
+        // Set display in partial refresh mode
+        getdisplay().setPartialWindow(0, 0, width, height); // Set partial update
+        getdisplay().setTextColor(commonData->fgcolor);
+
+        // chart lines
+        getdisplay().fillRect(0, yOffset, width, 2, commonData->fgcolor);
+        getdisplay().fillRect(xCenter, yOffset, 1, cHeight, commonData->fgcolor);
+
+        // chart labels
+        char sWndLbl[4]; // char buffer for Wind angle label
+        getdisplay().setFont(&Ubuntu_Bold12pt8b);
+        getdisplay().setCursor(xCenter - 88, yOffset - 3);
+        getdisplay().print("TWD"); // Wind data name
+        snprintf(sWndLbl, 4, "%03d", (wndCenter < 0) ? (wndCenter + 360) : wndCenter);
+        drawTextCenter(xCenter, yOffset - 11, sWndLbl);
+        getdisplay().drawCircle(xCenter + 25, yOffset - 17, 2, commonData->fgcolor); // <degree> symbol
+        getdisplay().drawCircle(xCenter + 25, yOffset - 17, 3, commonData->fgcolor); // <degree> symbol
+        getdisplay().setCursor(1, yOffset - 3);
+        snprintf(sWndLbl, 4, "%03d", (wndLeft < 0) ? (wndLeft + 360) : wndLeft);
+        getdisplay().print(sWndLbl); // Wind left value
+        getdisplay().drawCircle(46, yOffset - 17, 2, commonData->fgcolor); // <degree> symbol
+        getdisplay().drawCircle(46, yOffset - 17, 3, commonData->fgcolor); // <degree> symbol
+        getdisplay().setCursor(width - 50, yOffset - 3);
+        snprintf(sWndLbl, 4, "%03d", (wndRight < 0) ? (wndRight + 360) : wndRight);
+        getdisplay().print(sWndLbl); // Wind right value
+        getdisplay().drawCircle(width - 5, yOffset - 17, 2, commonData->fgcolor); // <degree> symbol
+        getdisplay().drawCircle(width - 5, yOffset - 17, 3, commonData->fgcolor); // <degree> symbol
+
+        if (pageData.boatHstry.twdHstry->getMax() == pageData.boatHstry.twdHstry->getMinVal()) {
+            // only <INT16_MIN> values in buffer -> no valid wind data available
+            wndDataValid = false;
+        } else if (!BDataValid[0]) {
+            // currently no valid TWD data available
+            numNoData++;
+            wndDataValid = true;
+            if (numNoData > 3) {
+                // If more than 4 invalid values in a row, send message
+                wndDataValid = false;
+            }
+        } else {
+            numNoData = 0; // reset data error counter
+            wndDataValid = true; // At least some wind data available
+        }
+        // Draw wind values in chart
+        //***********************************************************************
+        if (wndDataValid) {
+            for (int i = 0; i < (numWndVals / dataIntv); i++) {
+                chrtVal = static_cast<int>(pageData.boatHstry.twdHstry->get(bufStart + (i * dataIntv))); // show the latest wind values in buffer; keep 1st value constant in a rolling buffer
+                if (chrtVal == INT16_MIN) {
+                    chrtPrevVal = INT16_MIN;
+                } else {
+                    chrtVal = static_cast<int>((chrtVal / 1000.0 * radToDeg) + 0.5); // Convert to degrees and round
+                    x = ((chrtVal - wndLeft + 360) % 360) * chrtScl;
+                    y = yOffset + cHeight - i; // Position in chart area
+
+//                    if (i >= (numWndVals / dataIntv) - 10)
+                    if (i >= (numWndVals / dataIntv) - 1)
+                        LOG_DEBUG(GwLog::DEBUG, "PageWindPlot Chart: i: %d, chrtVal: %d, bufStart: %d, count: %d, linesToShow: %d", i, chrtVal, bufStart, count, (numWndVals / dataIntv));
+
+                    if ((i == 0) || (chrtPrevVal == INT16_MIN)) {
+                        // just a dot for 1st chart point or after some invalid values
+                        prevX = x;
+                        prevY = y;
+                    } else {
+                        // cross borders check; shift values to [-180..0..180]; when crossing borders, range is 2x 180 degrees
+                        int wndLeftDlt = -180 - ((wndLeft >= 180) ? (wndLeft - 360) : wndLeft);
+                        int chrtVal180 = ((chrtVal + wndLeftDlt + 180) % 360 + 360) % 360 - 180;
+                        int chrtPrevVal180 = ((chrtPrevVal + wndLeftDlt + 180) % 360 + 360) % 360 - 180;
+                        if (((chrtPrevVal180 >= -180) && (chrtPrevVal180 < -90) && (chrtVal180 > 90)) || ((chrtPrevVal180 <= 179) && (chrtPrevVal180 > 90) && chrtVal180 <= -90)) {
+                            // If current value crosses chart borders compared to previous value, split line
+                            int xSplit = (((chrtPrevVal180 > 0 ? wndRight : wndLeft) - wndLeft + 360) % 360) * chrtScl;
+                            getdisplay().drawLine(prevX, prevY, xSplit, y, commonData->fgcolor);
+                            getdisplay().drawLine(prevX, prevY - 1, ((xSplit != prevX) ? xSplit : xSplit - 1), ((xSplit != prevX) ? y - 1 : y), commonData->fgcolor);
+                            prevX = (((chrtVal180 > 0 ? wndRight : wndLeft) - wndLeft + 360) % 360) * chrtScl;
+                        }
+                    }
+
+                    // Draw line with 2 pixels width + make sure vertical line are drawn correctly
+                    getdisplay().drawLine(prevX, prevY, x, y, commonData->fgcolor);
+                    getdisplay().drawLine(prevX, prevY - 1, ((x != prevX) ? x : x - 1), ((x != prevX) ? y - 1 : y), commonData->fgcolor);
+                    chrtPrevVal = chrtVal;
+                    prevX = x;
+                    prevY = y;
+                }
+                // Reaching chart area top end
+                if (i >= (cHeight - 1)) {
+                    oldDataIntv = 0; // force reset of buffer start and number of values to show in next display loop
+
+                    int minWndDir = pageData.boatHstry.twdHstry->getMin(numWndVals) / 1000.0 * radToDeg;
+                    int maxWndDir = pageData.boatHstry.twdHstry->getMax(numWndVals) / 1000.0 * radToDeg;
+                    LOG_DEBUG(GwLog::DEBUG, "PageWindPlot FreeTop: Minimum: %d, Maximum: %d, OldwndCenter: %d", minWndDir, maxWndDir, wndCenter);
+//                    if ((minWndDir + 540 >= wndCenter + 540) || (maxWndDir + 540 <= wndCenter + 540)) {
+                    if (((minWndDir - wndCenter >= 0) && (minWndDir - wndCenter < 180)) || ((maxWndDir - wndCenter <= 0) && (maxWndDir - wndCenter >=180))) {
+                        // Check if all wind value are left or right of center value -> optimize chart range
+                        midWndDir = pageData.boatHstry.twdHstry->getMid(numWndVals) / 1000.0 * radToDeg;
+                        if (midWndDir != INT16_MIN) {
+                            wndCenter = int((midWndDir + (midWndDir >= 0 ? 5 : -5)) / 10) * 10; // Set new center value; round to nearest 10 degree value
+                        }
+                    }
+                    LOG_DEBUG(GwLog::DEBUG, "PageWindPlot FreeTop: cHeight: %d, bufStart: %d, numWndVals: %d, wndCenter: %d", cHeight, bufStart, numWndVals, wndCenter);
+                    break;
+                }
+            }
+
+        } else {
+            // No valid data available
+            LOG_DEBUG(GwLog::LOG, "PageWindPlot: No valid data available");
+            getdisplay().setFont(&Ubuntu_Bold10pt8b);
+            getdisplay().fillRect(xCenter - 33, height / 2 - 20, 66, 24, commonData->bgcolor); // Clear area for message
+            drawTextCenter(xCenter, height / 2 - 10, "No data");
+        }
+
+        // Print TWS value
+        if (showTWS) {
+            int currentZone;
+            static int lastZone = 0;
+            static bool flipTws = false;
+            int xPosTws;
+            static const int yPosTws = yOffset + 40;
+
+            twsValue = pageData.boatHstry.twsHstry->getLast() / 10.0 * 1.94384; // TWS value in knots
+
+            xPosTws = flipTws ? 20 : width - 138;
+            currentZone = (y >= yPosTws - 38) && (y <= yPosTws + 6) && (x >= xPosTws - 4) && (x <= xPosTws + 146) ? 1 : 0; // Define current zone for TWS value
+            if (currentZone != lastZone) {
+                // Only flip when x moves to a different zone
+                if ((y >= yPosTws - 38) && (y <= yPosTws + 6) && (x >= xPosTws - 4) && (x <= xPosTws + 146)) {
+                    flipTws = !flipTws;
+                    xPosTws = flipTws ? 20 : width - 145;
+                }
+            }
+            lastZone = currentZone;
+
+            getdisplay().fillRect(xPosTws - 4, yPosTws - 38, 142, 44, commonData->bgcolor); // Clear area for TWS value
+            getdisplay().setFont(&DSEG7Classic_BoldItalic16pt7b);
+            getdisplay().setCursor(xPosTws, yPosTws);
+            if (!BDataValid[1]) {
+                getdisplay().print("--.-");
+            } else {
+                double dbl = BDataValue[1] * 3.6 / 1.852;
+                if (dbl < 10.0) {
+                    getdisplay().printf("!%3.1f", dbl); // Value, round to 1 decimal
+                } else {
+                    getdisplay().printf("%4.1f", dbl); // Value, round to 1 decimal
+                }
+            }
+            getdisplay().setFont(&Ubuntu_Bold12pt8b);
+            getdisplay().setCursor(xPosTws + 82, yPosTws - 14);
+//            getdisplay().print("TWS"); // Name
+            getdisplay().print(BDataName[1]); // Name
+            getdisplay().setFont(&Ubuntu_Bold8pt8b);
+//            getdisplay().setCursor(xPosTws + 78, yPosTws + 1);
+            getdisplay().setCursor(xPosTws + 82, yPosTws + 1);
+//            getdisplay().printf(" kn"); // Unit
+            getdisplay().print(BDataUnit[1]); // Unit
+        }
+
+        // chart Y axis labels; print at last to overwrite potential chart lines in label area
+        int yPos;
+        int chrtLbl;
+        getdisplay().setFont(&Ubuntu_Bold8pt8b);
+        for (int i = 1; i <= 3; i++) {
+            yPos = yOffset + (i * 60);
+            getdisplay().fillRect(0, yPos, width, 1, commonData->fgcolor);
+            getdisplay().fillRect(0, yPos - 8, 24, 16, commonData->bgcolor); // Clear small area to remove potential chart lines
+            getdisplay().setCursor(1, yPos + 4);
+            if (count >= intvBufSize) {
+                // Calculate minute value for label
+                chrtLbl = ((i - 1 + (prevY < yOffset + 30)) * dataIntv) * -1; // change label if last data point is more than 30 lines (= seconds) from chart line
+            } else {
+                int j = 3 - i;
+                chrtLbl = (int((((numWndVals / dataIntv) - 50) * dataIntv / 60) + 1) - (j * dataIntv)) * -1; // 50 lines left below last chart line
+            }
+            getdisplay().printf("%3d", chrtLbl); // Wind value label
+        }
+
+        return PAGE_UPDATE;
+    };
+};
+
+static Page* createPage(CommonData& common)
+{
+    return new PageWindPlot(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 (0 here)
+ * and will will provide the names of the fixed values we need
+ */
+PageDescription registerPageWindPlot(
+    "WindPlot", // Page name
+    createPage, // Action
+    0, // Number of bus values depends on selection in Web configuration
+    { "TWD", "TWS" }, // Bus values we need in the page
+//    {}, // Bus values we need in the page
+    true // Show display header on/off
+);
+
+#endif

lib/obp60task/PageWindRose.cpp

@@ -48,7 +48,7 @@ public:
         String flashLED = config->getString(config->flashLED);
         String backlightMode = config->getString(config->backlight);
 
-        // Get boat values for AWA
+        // Get boat value for AWA
         GwApi::BoatValue *bvalue1 = pageData.values[0]; // First element in list (only one value by PageOneValue)
         String name1 = xdrDelete(bvalue1->getName());   // Value name
         name1 = name1.substring(0, 6);                  // String length limit for value name
@@ -63,8 +63,8 @@ public:
             unit1old = unit1;                           // Save old unit
         }
 
-        // Get boat values for AWS
-        GwApi::BoatValue *bvalue2 = pageData.values[1]; // First element in list (only one value by PageOneValue)
+        // Get boat value for AWS
+        GwApi::BoatValue *bvalue2 = pageData.values[1]; // Second element in list
         String name2 = xdrDelete(bvalue2->getName());   // Value name
         name2 = name2.substring(0, 6);                  // String length limit for value name
         calibrationData.calibrateInstance(bvalue2, logger); // Check if boat data value is to be calibrated
@@ -77,8 +77,8 @@ public:
             unit2old = unit2;                           // Save old unit
         }
 
-        // Get boat values TWD
-        GwApi::BoatValue *bvalue3 = pageData.values[2]; // Second element in list (only one value by PageOneValue)
+        // Get boat value for TWD
+        GwApi::BoatValue *bvalue3 = pageData.values[2]; // Third element in list
         String name3 = xdrDelete(bvalue3->getName());   // Value name
         name3 = name3.substring(0, 6);                  // String length limit for value name
         calibrationData.calibrateInstance(bvalue3, logger); // Check if boat data value is to be calibrated
@@ -91,8 +91,8 @@ public:
             unit3old = unit3;                           // Save old unit
         }
 
-        // Get boat values TWS
-        GwApi::BoatValue *bvalue4 = pageData.values[3]; // Second element in list (only one value by PageOneValue)
+        // Get boat value for TWS
+        GwApi::BoatValue *bvalue4 = pageData.values[3]; // Fourth element in list
         String name4 = xdrDelete(bvalue4->getName());   // Value name
         name4 = name4.substring(0, 6);                  // String length limit for value name
         calibrationData.calibrateInstance(bvalue4, logger); // Check if boat data value is to be calibrated
@@ -105,8 +105,8 @@ public:
             unit4old = unit4;                           // Save old unit
         }
 
-        // Get boat values DBT
-        GwApi::BoatValue *bvalue5 = pageData.values[4]; // Second element in list (only one value by PageOneValue)
+        // Get boat value for DBT
+        GwApi::BoatValue *bvalue5 = pageData.values[4]; // Fifth element in list
         String name5 = xdrDelete(bvalue5->getName());   // Value name
         name5 = name5.substring(0, 6);                  // String length limit for value name
         calibrationData.calibrateInstance(bvalue5, logger); // Check if boat data value is to be calibrated
@@ -119,8 +119,8 @@ public:
             unit5old = unit5;                           // Save old unit
         }
 
-        // Get boat values STW
-        GwApi::BoatValue *bvalue6 = pageData.values[5]; // Second element in list (only one value by PageOneValue)
+        // Get boat value for STW
+        GwApi::BoatValue *bvalue6 = pageData.values[5]; // Sixth element in list
         String name6 = xdrDelete(bvalue6->getName());   // Value name
         name6 = name6.substring(0, 6);                  // String length limit for value name
         calibrationData.calibrateInstance(bvalue6, logger); // Check if boat data value is to be calibrated
@@ -248,7 +248,7 @@ public:
             float y = 150 - (rInstrument-30)*cos(i/180.0*pi);  //  y-coordinate cots
             const char *ii = "";
             switch (i)
-            {
+{
             case 0: ii="0"; break;
             case 30 : ii="30"; break;
             case 60 : ii="60"; break;

lib/obp60task/PageWindRoseFlex.cpp

@@ -48,7 +48,7 @@ public:
         String flashLED = config->getString(config->flashLED);
         String backlightMode = config->getString(config->backlight);
 
-        // Get boat values for AWA
+        // Get boat values #1
         GwApi::BoatValue *bvalue1 = pageData.values[0]; // First element in list (only one value by PageOneValue)
         String name1 = xdrDelete(bvalue1->getName());   // Value name
         name1 = name1.substring(0, 6);                  // String length limit for value name
@@ -63,8 +63,8 @@ public:
             unit1old = unit1;                           // Save old unit
         }
 
-        // Get boat values for AWS
-        GwApi::BoatValue *bvalue2 = pageData.values[1]; // First element in list (only one value by PageOneValue)
+        // Get boat values #2
+        GwApi::BoatValue *bvalue2 = pageData.values[1]; // Second element in list
         String name2 = xdrDelete(bvalue2->getName());   // Value name
         name2 = name2.substring(0, 6);                  // String length limit for value name
         calibrationData.calibrateInstance(bvalue2, logger); // Check if boat data value is to be calibrated
@@ -77,8 +77,8 @@ public:
             unit2old = unit2;                           // Save old unit
         }
 
-        // Get boat values TWD
-        GwApi::BoatValue *bvalue3 = pageData.values[2]; // Second element in list (only one value by PageOneValue)
+        // Get boat values #3
+        GwApi::BoatValue *bvalue3 = pageData.values[2]; // Third element in list
         String name3 = xdrDelete(bvalue3->getName());   // Value name
         name3 = name3.substring(0, 6);                  // String length limit for value name
         calibrationData.calibrateInstance(bvalue3, logger); // Check if boat data value is to be calibrated
@@ -91,8 +91,8 @@ public:
             unit3old = unit3;                           // Save old unit
         }
 
-        // Get boat values TWS
-        GwApi::BoatValue *bvalue4 = pageData.values[3]; // Second element in list (only one value by PageOneValue)
+        // Get boat values #4
+        GwApi::BoatValue *bvalue4 = pageData.values[3]; // Fourth element in list
         String name4 = xdrDelete(bvalue4->getName());   // Value name
         name4 = name4.substring(0, 6);                  // String length limit for value name
         calibrationData.calibrateInstance(bvalue4, logger); // Check if boat data value is to be calibrated
@@ -105,8 +105,8 @@ public:
             unit4old = unit4;                           // Save old unit
         }
 
-        // Get boat values DBT
-        GwApi::BoatValue *bvalue5 = pageData.values[4]; // Second element in list (only one value by PageOneValue)
+        // Get boat values #5
+        GwApi::BoatValue *bvalue5 = pageData.values[4]; // Fifth element in list
         String name5 = xdrDelete(bvalue5->getName());   // Value name
         name5 = name5.substring(0, 6);                  // String length limit for value name
         calibrationData.calibrateInstance(bvalue5, logger); // Check if boat data value is to be calibrated
@@ -119,8 +119,8 @@ public:
             unit5old = unit5;                           // Save old unit
         }
 
-        // Get boat values STW
-        GwApi::BoatValue *bvalue6 = pageData.values[5]; // Second element in list (only one value by PageOneValue)
+        // Get boat values #5
+        GwApi::BoatValue *bvalue6 = pageData.values[5]; // Sixth element in list
         String name6 = xdrDelete(bvalue6->getName());   // Value name
         name6 = name6.substring(0, 6);                  // String length limit for value name
         calibrationData.calibrateInstance(bvalue6, logger); // Check if boat data value is to be calibrated
@@ -192,7 +192,7 @@ public:
         getdisplay().setFont(&DSEG7Classic_BoldItalic20pt7b);
         getdisplay().setCursor(295, 65);
         if(valid3 == true){
-           // getdisplay().print(abs(value3 * 180 / PI), 0);   // Value          
+           // getdisplay().print(abs(value3 * 180 / M_PI), 0); // Value
             getdisplay().print(svalue4);     // Value
         }
         else{
@@ -236,7 +236,6 @@ public:
 
         // Draw wind rose
         int rInstrument = 110;     // Radius of grafic instrument
-        float pi = 3.141592;
 
         getdisplay().fillCircle(200, 150, rInstrument + 10, commonData->fgcolor);    // Outer circle
         getdisplay().fillCircle(200, 150, rInstrument + 7, commonData->bgcolor);     // Outer circle
@@ -246,11 +245,10 @@ public:
         for(int i=0; i<360; i=i+10)
         {
             // Scaling values
-            float x = 200 + (rInstrument-30)*sin(i/180.0*pi);  //  x-coordinate dots
-            float y = 150 - (rInstrument-30)*cos(i/180.0*pi);  //  y-coordinate dots
+            float x = 200 + (rInstrument-30)*sin(i/180.0*M_PI);  //  x-coordinate dots
+            float y = 150 - (rInstrument-30)*cos(i/180.0*M_PI);  //  y-coordinate dots
             const char *ii = "";
-            switch (i)
-            {
+            switch (i) {
                 case 0: ii="0"; break;
                 case 30 : ii="30"; break;
                 case 60 : ii="60"; break;
@@ -277,11 +275,11 @@ public:
             }
 
             // Draw sub scale with dots
-            float x1c = 200 + rInstrument*sin(i/180.0*pi);
-            float y1c = 150 - rInstrument*cos(i/180.0*pi);
+            float x1c = 200 + rInstrument*sin(i/180.0*M_PI);
+            float y1c = 150 - rInstrument*cos(i/180.0*M_PI);
             getdisplay().fillCircle((int)x1c, (int)y1c, 2, commonData->fgcolor);
-            float sinx=sin(i/180.0*pi);
-            float cosx=cos(i/180.0*pi); 
+            float sinx=sin(i/180.0*M_PI);
+            float cosx=cos(i/180.0*M_PI);
 
             // Draw sub scale with lines (two triangles)
             if(i % 30 == 0){
@@ -331,27 +329,19 @@ public:
 
 //*******************************************************************************************
 
-// Show value6, so that it does not collide with the wind pointer
-if ( cos(value1) > 0){ 
+        // Show value6, so that it does not collide with the wind pointer
         getdisplay().setFont(&DSEG7Classic_BoldItalic16pt7b);
+        if (cos(value1) > 0){
             getdisplay().setCursor(160, 200);
             getdisplay().print(svalue6);                     // Value
             getdisplay().setFont(&Ubuntu_Bold8pt8b);
             getdisplay().setCursor(190, 215);
-    getdisplay().print(" ");
-    if(holdvalues == false){
-        getdisplay().print(unit6);                   // Unit
-    }
-    else{  
-        getdisplay().print(unit6old);                // Unit
-    } 
-    }
-    else{ 
-    getdisplay().setFont(&DSEG7Classic_BoldItalic16pt7b);
+        } else{
             getdisplay().setCursor(160, 130);
             getdisplay().print(svalue6);                     // Value
             getdisplay().setFont(&Ubuntu_Bold8pt8b);
             getdisplay().setCursor(190, 90);
+        }
         getdisplay().print(" ");
         if(holdvalues == false){
             getdisplay().print(unit6);                   // Unit
@@ -359,8 +349,6 @@ if ( cos(value1) > 0){
         else{
             getdisplay().print(unit6old);                // Unit
         }
-    }
-    
 
         return PAGE_UPDATE;
     };
@@ -380,7 +368,6 @@ PageDescription registerPageWindRoseFlex(
     "WindRoseFlex", // Page name
     createPage,     // Action
     6,              // Number of bus values depends on selection in Web configuration; was zero
-    //{"AWA", "AWS", "COG", "SOG", "TWD", "TWS"},    // Bus values we need in the page, modified for WindRose2
     true            // Show display header on/off
 );
 

lib/obp60task/Pagedata.h

@@ -4,15 +4,19 @@
 #include <functional>
 #include <vector>
 #include "LedSpiTask.h"
+#include "OBPRingBuffer.h"
+#include "OBPDataOperations.h"
 
 #define MAX_PAGE_NUMBER 10    // Max number of pages for show data
 
 typedef std::vector<GwApi::BoatValue *> ValueList;
+
 typedef struct{
   String pageName;
   uint8_t pageNumber; // page number in sequence of visible pages
   //the values will always contain the user defined values first
   ValueList values;
+  tBoatHstryData boatHstry;
 } PageData;
 
 // Sensor data structure (only for extended sensors, not for NMEA bus sensors)
@@ -193,7 +197,7 @@ typedef struct{
   double value;
   String svalue;
   String unit;
-} FormatedData;
+} FormattedData;
 
 // Formatter for boat values
-FormatedData formatValue(GwApi::BoatValue *value, CommonData &commondata);
+FormattedData formatValue(GwApi::BoatValue *value, CommonData &commondata);

lib/obp60task/config.json

@@ -219,6 +219,17 @@
             "obp60":"true"
         }
     },
+    {
+        "name": "calcTrueWnds",
+        "label": "Calculate True Wind",
+        "type": "boolean",
+        "default": "false",
+        "description": "If not available, calculate true wind data from appearant wind and other boat data",
+        "category": "OBP60 Settings",
+        "capabilities": {
+            "obp60": "true"
+        }
+    },
     {
         "name": "lengthFormat",
         "label": "Length Format",
@@ -1106,6 +1117,21 @@
             "obp60":"true"
         }
     },
+    {
+        "name": "valueprecision",
+        "label": "Display value precision",
+        "type": "list",
+        "default": "2",
+        "description": "Maximum number of decimal places to display [1|2]",
+        "list": [
+            "1",
+            "2"
+        ],
+        "category": "OBP60 Display",
+        "capabilities": {
+            "obp60":"true"
+        }
+    },
     {
         "name": "backlight",
         "label": "Backlight Mode",
@@ -1313,6 +1339,7 @@
             "Voltage",
             "WhitePage",
             "Wind",
+            "WindPlot",
             "WindRose",
             "WindRoseFlex",
             "XTETrack"
@@ -1593,6 +1620,7 @@
             "Voltage",
             "WhitePage",
             "Wind",
+            "WindPlot",
             "WindRose",
             "WindRoseFlex",
             "XTETrack"
@@ -1870,6 +1898,7 @@
             "Voltage",
             "WhitePage",
             "Wind",
+            "WindPlot",
             "WindRose",
             "WindRoseFlex",
             "XTETrack"
@@ -2144,6 +2173,7 @@
             "Voltage",
             "WhitePage",
             "Wind",
+            "WindPlot",
             "WindRose",
             "WindRoseFlex",
             "XTETrack"
@@ -2415,6 +2445,7 @@
             "Voltage",
             "WhitePage",
             "Wind",
+            "WindPlot",
             "WindRose",
             "WindRoseFlex",
             "XTETrack"
@@ -2683,6 +2714,7 @@
             "Voltage",
             "WhitePage",
             "Wind",
+            "WindPlot",
             "WindRose",
             "WindRoseFlex",
             "XTETrack"
@@ -2948,6 +2980,7 @@
             "Voltage",
             "WhitePage",
             "Wind",
+            "WindPlot",
             "WindRose",
             "WindRoseFlex",
             "XTETrack"
@@ -3210,6 +3243,7 @@
             "Voltage",
             "WhitePage",
             "Wind",
+            "WindPlot",
             "WindRose",
             "WindRoseFlex",
             "XTETrack"
@@ -3469,6 +3503,7 @@
             "Voltage",
             "WhitePage",
             "Wind",
+            "WindPlot",
             "WindRose",
             "WindRoseFlex",
             "XTETrack"
@@ -3725,6 +3760,7 @@
             "Voltage",
             "WhitePage",
             "Wind",
+            "WindPlot",
             "WindRose",
             "WindRoseFlex",
             "XTETrack"

lib/obp60task/config_obp40.json

@@ -219,6 +219,17 @@
             "obp40": "true"
         }
     },
+    {
+        "name": "calcTrueWnds",
+        "label": "Calculate True Wind",
+        "type": "boolean",
+        "default": "false",
+        "description": "If not available, calculate true wind data from appearant wind and other boat data",
+        "category": "OBP40 Settings",
+        "capabilities": {
+            "obp40": "true"
+        }
+    },
     {
         "name": "lengthFormat",
         "label": "Length Format",
@@ -1118,6 +1129,21 @@
             "obp40": "true"
         }
     },
+    {
+        "name": "valueprecision",
+        "label": "Display value precision",
+        "type": "list",
+        "default": "2",
+        "description": "Maximum number of decimal places to display [1|2]",
+        "list": [
+            "1",
+            "2"
+        ],
+        "category": "OBP40 Display",
+        "capabilities": {
+            "obp40":"true"
+        }
+    },
     {
         "name": "backlight",
         "label": "Backlight Mode",
@@ -1336,6 +1362,7 @@
             "Voltage",
             "WhitePage",
             "Wind",
+            "WindPlot",
             "WindRose",
             "WindRoseFlex",
             "XTETrack"
@@ -1616,6 +1643,7 @@
             "Voltage",
             "WhitePage",
             "Wind",
+            "WindPlot",
             "WindRose",
             "WindRoseFlex",
             "XTETrack"
@@ -1893,6 +1921,7 @@
             "Voltage",
             "WhitePage",
             "Wind",
+            "WindPlot",
             "WindRose",
             "WindRoseFlex",
             "XTETrack"
@@ -2167,6 +2196,7 @@
             "Voltage",
             "WhitePage",
             "Wind",
+            "WindPlot",
             "WindRose",
             "WindRoseFlex",
             "XTETrack"
@@ -2438,6 +2468,7 @@
             "Voltage",
             "WhitePage",
             "Wind",
+            "WindPlot",
             "WindRose",
             "WindRoseFlex",
             "XTETrack"
@@ -2706,6 +2737,7 @@
             "Voltage",
             "WhitePage",
             "Wind",
+            "WindPlot",
             "WindRose",
             "WindRoseFlex",
             "XTETrack"
@@ -2971,6 +3003,7 @@
             "Voltage",
             "WhitePage",
             "Wind",
+            "WindPlot",
             "WindRose",
             "WindRoseFlex",
             "XTETrack"
@@ -3233,6 +3266,7 @@
             "Voltage",
             "WhitePage",
             "Wind",
+            "WindPlot",
             "WindRose",
             "WindRoseFlex",
             "XTETrack"
@@ -3492,6 +3526,7 @@
             "Voltage",
             "WhitePage",
             "Wind",
+            "WindPlot",
             "WindRose",
             "WindRoseFlex",
             "XTETrack"
@@ -3748,6 +3783,7 @@
             "Voltage",
             "WhitePage",
             "Wind",
+            "WindPlot",
             "WindRose",
             "WindRoseFlex",
             "XTETrack"

lib/obp60task/gen_set.py

@@ -1,45 +1,55 @@
 #!/usr/bin/env python3
-# A tool to generate that part of config.json  that deals with pages and fields.
-#
-#Usage: 1. modify this script (e.g.add a page, change number of fields, etc.)
-#       2. Delete all lines from config.json from the curly backet before "name": "page1type"  to o the end of the file (as of today, delete from line 917 to the end of the File)
-#       3. run ./gen_set.py >> config.json
 
+"""
+A tool to generate that part of config.json that deals with pages and fields.
+
+Usage example:
+
+ 1. Delete all lines from config.json from the curly backet before
+    "name": "page1type"  to the end of the file
+
+ 2. run ./gen_set.py -d obp60 -p 10 >> config.json
+
+TODO Better handling of default pages
+
+"""
+
+import os
+import sys
+import getopt
+import re
 import json
 
-# List of all pages and the number of parameters they expect.
-no_of_fields_per_page = {
-    "Wind": 0,
-    "XTETrack": 0,
-    "Battery2": 0,
-    "Battery": 0,
-    "BME280": 0,
-    "Clock": 0,
-    "Compass" : 0,
-    "DST810": 0,
-    "Fluid": 1,
-    "FourValues2": 4,
-    "FourValues": 4,
-    "Generator": 0,
-    "KeelPosition": 0,
-    "OneValue": 1,
-    "RollPitch": 2,
-    "RudderPosition": 0,
-    "SixValues" : 6,
-    "Solar": 0,
-    "ThreeValues": 3,
-    "TwoValues": 2,
-    "Voltage": 0,
-    "WhitePage": 0,
-    "WindRose": 0,
-    "WindRoseFlex": 6,
-}
+__version__ = "0.2"
 
-# No changes needed beyond this point
-# max number of pages supported by OBP60
-no_of_pages = 10
-# Default selection for each page
-default_pages = [
+def detect_pages(filename):
+    # returns a dictionary with page name and the number of gui fields
+    pagefiles = []
+    with open(filename, 'r') as fh:
+        pattern = r'extern PageDescription\s*register(Page[^;\s]*)'
+        for line in fh:
+            if "extern PageDescription" in line:
+                match = re.search(pattern, line)
+                if match:
+                    pagefiles.append(match.group(1))
+    try:
+        pagefiles.remove('PageSystem')
+    except ValueError:
+        pass
+    pagedata = {}
+    for pf in pagefiles:
+        filename = pf + ".cpp"
+        with open(filename, 'r') as fh:
+            content = fh.read()
+        pattern =  r'PageDescription\s*?register' + pf + r'\s*\(\s*"([^"]+)".*?\n\s*(\d+)'
+        match = re.search(pattern, content, re.DOTALL)
+        if match:
+            pagedata[match.group(1)] = int(match.group(2))
+    return pagedata
+
+def get_default_page(pageno):
+    # Default selection for each page
+    default_pages = (
         "Voltage",
         "WindRose",
         "OneValue",
@@ -49,35 +59,43 @@ default_pages = [
         "FourValues2",
         "Clock",
         "RollPitch",
-    "Battery2",
-]
-numbers = [
-    "one",
-    "two",
-    "three",
-    "four",
-    "five",
-    "six",
-    "seven",
-    "eight",
-    "nine",
-    "ten",
-]
-pages = sorted(no_of_fields_per_page.keys())
-max_no_of_fields_per_page = max(no_of_fields_per_page.values())
+        "Battery2"
+    )
+    if pageno > len(default_pages):
+        return "OneValue"
+    return default_pages[pageno - 1]
 
-output = []
+def number_to_text(number):
+    if number < 0 or number > 99:
+        raise ValueError("Only numbers from 0 to 99 are allowed.")
+    numbers = ("zero", "one", "two", "three", "four", "five", "six", "seven",
+        "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen",
+        "fifteen", "sixteen", "seventeen", "eighteen", "nineteen")
+    tens = ("", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy",
+        "eighty", "ninety")
+    if number < 20:
+        return numbers[number]
+    else:
+        q, r = divmod(number, 10)
+        return tens[q] + numbers[r]
 
-for page_no in range(1, no_of_pages + 1):
+def create_json(device, no_of_pages, pagedata):
+
+    pages = sorted(pagedata.keys())
+    max_no_of_fields_per_page = max(pagedata.values())
+
+    output = []
+
+    for page_no in range(1, no_of_pages + 1):
         page_data = {
             "name": f"page{page_no}type",
             "label": "Type",
             "type": "list",
-        "default": default_pages[page_no - 1],
+            "default": get_default_page(page_no),
             "description": f"Type of page for page {page_no}",
             "list": pages,
-        "category": f"OBP60 Page {page_no}",
-        "capabilities": {"obp60": "true"},
+            "category": f"{device.upper()} Page {page_no}",
+            "capabilities": {device.lower(): "true"},
             "condition": [{"visiblePages": vp} for vp in range(page_no, no_of_pages + 1)],
             #"fields": [],
         }
@@ -89,13 +107,13 @@ for page_no in range(1, no_of_pages + 1):
                 "label": f"Field {field_no}",
                 "type": "boatData",
                 "default": "",
-            "description": f"The display for field {numbers[field_no - 1]}",
-            "category": f"OBP60 Page {page_no}",
-            "capabilities": {"obp60": "true"},
+                "description": "The display for field {}".format(number_to_text(field_no)),
+                "category": f"{device.upper()} Page {page_no}",
+                "capabilities": {device.lower(): "true"},
                 "condition": [
                     {f"page{page_no}type": page}
                     for page in pages
-                if no_of_fields_per_page[page] >= field_no
+                    if pagedata[page] >= field_no
                 ],
             }
             output.append(field_data)
@@ -115,17 +133,47 @@ for page_no in range(1, no_of_pages + 1):
             {"l":"Fuel Gasoline (6)","v":"6"}
             ],
             "description": "Fluid type in tank",
-        "category": f"OBP60 Page {page_no}",
+            "category": f"{device.upper()} Page {page_no}",
             "capabilities": {
-        "obp60":"true"
+                device.lower(): "true"
             },
             "condition":[{f"page{page_no}type":"Fluid"}]
             }
         output.append(fluid_data)
 
-json_output = json.dumps(output, indent=4)
-# print omitting first and last line containing [ ] of JSON array
-#print(json_output[1:-1])
-# print omitting first line containing [  of JSON array
-print(json_output[1:])
-# print(",")
+    return json.dumps(output, indent=4)
+
+def usage():
+    print("{} v{}".format(os.path.basename(__file__), __version__))
+    print()
+    print("Command line options")
+    print(" -d --device     device name to use e.g. obp60")
+    print(" -p --pages      number of pages to create")
+    print(" -h              show this help")
+    print()
+
+if __name__ == '__main__':
+    try:
+        options, remainder = getopt.getopt(sys.argv[1:], 'd:p:', ['device=','--pages='])
+    except getopt.GetoptError as err:
+        print(err)
+        usage()
+        sys.exit(2)
+
+    device = "obp60"
+    no_of_pages = 10
+    for opt, arg in options:
+        if opt in ('-d', '--device'):
+            device = arg
+        elif opt in ('-p', '--pages'):
+            no_of_pages = int(arg)
+        elif opt == '-h':
+            usage()
+            sys.exit(0)
+
+    # automatic detect pages and number of fields from sourcecode
+    pagedata = detect_pages("obp60task.cpp")
+
+    json_output = create_json(device, no_of_pages, pagedata)
+    # print omitting first line containing [  of JSON array
+    print(json_output[1:])

lib/obp60task/obp60task.cpp

@@ -13,11 +13,11 @@
 #include "OBP60Extensions.h"            // Functions lib for extension board
 #include "OBP60Keypad.h"                // Functions for keypad
 #include "BoatDataCalibration.h"        // Functions lib for data instance calibration
+#include "OBPRingBuffer.h"              // Functions lib with ring buffer for history storage of some boat data
+#include "OBPDataOperations.h"          // Functions lib for data operations such as true wind calculation
 
 #ifdef BOARD_OBP40S3
 #include "driver/rtc_io.h"              // Needs for weakup from deep sleep
-#include <FS.h>                         // SD-Card access
-#include <SD.h>
 #include <SPI.h>
 #endif
 
@@ -32,7 +32,6 @@
 #include "OBP60QRWiFi.h"                // Functions lib for WiFi QR code
 #include "OBPSensorTask.h"              // Functions lib for sensor data
 
-
 // Global vars
 bool initComplete = false;      // Initialization complete
 int taskRunCounter = 0;         // Task couter for loop section
@@ -45,63 +44,23 @@ void OBP60Init(GwApi *api){
     GwConfigHandler *config = api->getConfig();
 
     // Set a new device name and hidden the original name in the main config
-    String devicename = api->getConfig()->getConfigItem(api->getConfig()->deviceName,true)->asString();
-    api->getConfig()->setValue(GwConfigDefinitions::systemName, devicename, GwConfigInterface::ConfigType::HIDDEN);
+    String devicename = config->getConfigItem(config->deviceName, true)->asString();
+    config->setValue(GwConfigDefinitions::systemName, devicename, GwConfigInterface::ConfigType::HIDDEN);
 
-    api->getLogger()->logDebug(GwLog::LOG,"obp60init running");
+    logger->prefix = devicename + ":";
+    logger->logDebug(GwLog::LOG,"obp60init running");
 
     // Check I2C devices
 
+    // Init power
+    String powermode = config->getConfigItem(config->powerMode,true)->asString();
+    logger->logDebug(GwLog::DEBUG, "Power Mode is: %s", powermode.c_str());
+    powerInit(powermode);
 
     // Init hardware
     hardwareInit(api);
 
-    // Init power rail 5.0V
-    String powermode = api->getConfig()->getConfigItem(api->getConfig()->powerMode,true)->asString();
-    api->getLogger()->logDebug(GwLog::DEBUG,"Power Mode is: %s", powermode.c_str());
-    if(powermode == "Max Power" || powermode == "Only 5.0V"){
-        #ifdef HARDWARE_V21
-        setPortPin(OBP_POWER_50, true); // Power on 5.0V rail
-        #endif
-        #ifdef BOARD_OBP40S3
-        setPortPin(OBP_POWER_EPD, true);// Power on ePaper display
-        setPortPin(OBP_POWER_SD, true); // Power on SD card
-        #endif
-    }
-    else{
-        #ifdef HARDWARE_V21
-        setPortPin(OBP_POWER_50, false); // Power off 5.0V rail
-        #endif
-        #ifdef BOARD_OBP40S3
-        setPortPin(OBP_POWER_EPD, false);// Power off ePaper display
-        setPortPin(OBP_POWER_SD, false); // Power off SD card
-        #endif
-    }
-
-    #ifdef BOARD_OBP40S3
-    bool sdcard = config->getBool(config->useSDCard);
-    if (sdcard) {
-        SPIClass SD_SPI = SPIClass(HSPI);
-        SD_SPI.begin(SD_SPI_CLK, SD_SPI_MISO, SD_SPI_MOSI);
-        if (SD.begin(SD_SPI_CS, SD_SPI, 80000000)) {
-            String sdtype = "unknown";
-            uint8_t cardType = SD.cardType();
-            switch (cardType) {
-                case CARD_MMC:
-                   sdtype = "MMC";
-                   break;
-                case CARD_SD:
-                   sdtype = "SDSC";
-                   break;
-                case CARD_SDHC:
-                   sdtype = "SDHC";
-                   break;
-            }
-            uint64_t cardSize = SD.cardSize() / (1024 * 1024);
-            LOG_DEBUG(GwLog::LOG,"SD card type %s of size %d MB detected", sdtype, cardSize);
-        }
-    }
-
+#ifdef BOARD_OBP40S3
     // Deep sleep wakeup configuration
     esp_sleep_enable_ext0_wakeup(OBP_WAKEWUP_PIN, 0);   // 1 = High, 0 = Low
     rtc_gpio_pullup_en(OBP_WAKEWUP_PIN);                // Activate pullup resistor
@@ -110,7 +69,7 @@ void OBP60Init(GwApi *api){
 
     // Settings for e-paper display
     String fastrefresh = api->getConfig()->getConfigItem(api->getConfig()->fastRefresh,true)->asString();
-    api->getLogger()->logDebug(GwLog::DEBUG,"Fast Refresh Mode is: %s", fastrefresh.c_str());
+    logger->logDebug(GwLog::DEBUG, "Fast Refresh Mode is: %s", fastrefresh.c_str());
     #ifdef DISPLAY_GDEY042T81
     if(fastrefresh == "true"){
         static const bool useFastFullUpdate = true;   // Enable fast full display update only for GDEY042T81
@@ -129,11 +88,11 @@ void OBP60Init(GwApi *api){
 
     // Get CPU speed
     int freq = getCpuFrequencyMhz();
-    api->getLogger()->logDebug(GwLog::LOG,"CPU speed at boot: %i MHz", freq);
+    logger->logDebug(GwLog::LOG,"CPU speed at boot: %i MHz", freq);
     
     // Settings for backlight
     String backlightMode = api->getConfig()->getConfigItem(api->getConfig()->backlight,true)->asString();
-    api->getLogger()->logDebug(GwLog::DEBUG,"Backlight Mode is: %s", backlightMode.c_str());
+    logger->logDebug(GwLog::DEBUG,"Backlight Mode is: %s", backlightMode.c_str());
     uint brightness = uint(api->getConfig()->getConfigItem(api->getConfig()->blBrightness,true)->asInt());
     String backlightColor = api->getConfig()->getConfigItem(api->getConfig()->blColor,true)->asString();
     if(String(backlightMode) == "On"){
@@ -148,7 +107,7 @@ void OBP60Init(GwApi *api){
 
     // Settings flash LED mode
     String ledMode = api->getConfig()->getConfigItem(api->getConfig()->flashLED,true)->asString();
-    api->getLogger()->logDebug(GwLog::DEBUG,"LED Mode is: %s", ledMode.c_str());
+    logger->logDebug(GwLog::DEBUG,"LED Mode is: %s", ledMode.c_str());
     if(String(ledMode) == "Off"){
         setBlinkingLED(false);
     }
@@ -275,10 +234,12 @@ void registerAllPages(PageList &list){
     list.add(&registerPageFourValues2);
     extern PageDescription registerPageWind;
     list.add(&registerPageWind);
+    extern PageDescription registerPageWindPlot;
+    list.add(&registerPageWindPlot); 
     extern PageDescription registerPageWindRose;
     list.add(&registerPageWindRose);
     extern PageDescription registerPageWindRoseFlex;
-    list.add(&registerPageWindRoseFlex); // 
+    list.add(&registerPageWindRoseFlex);
     extern PageDescription registerPageVoltage;
     list.add(&registerPageVoltage);
     extern PageDescription registerPageDST810;
@@ -372,6 +333,124 @@ void underVoltageDetection(GwApi *api, CommonData &common){
     }
 }
 
+//bool addTrueWind(GwApi* api, BoatValueList* boatValues, double *twd, double *tws, double *twa) {
+bool addTrueWind(GwApi* api, BoatValueList* boatValues) {
+    // Calculate true wind data and add to obp60task boat data list
+
+    double awaVal, awsVal, cogVal, stwVal, sogVal, hdtVal, hdmVal, varVal;
+    double twd, tws, twa;
+    bool isCalculated = false;
+    const double DBL_MIN = std::numeric_limits<double>::lowest();
+
+    GwApi::BoatValue *twdBVal = boatValues->findValueOrCreate("TWD");
+    GwApi::BoatValue *twsBVal = boatValues->findValueOrCreate("TWS");
+    GwApi::BoatValue *twaBVal = boatValues->findValueOrCreate("TWA");
+    GwApi::BoatValue *awaBVal = boatValues->findValueOrCreate("AWA");
+    GwApi::BoatValue *awsBVal = boatValues->findValueOrCreate("AWS");
+    GwApi::BoatValue *cogBVal = boatValues->findValueOrCreate("COG");
+    GwApi::BoatValue *stwBVal = boatValues->findValueOrCreate("STW");
+    GwApi::BoatValue *sogBVal = boatValues->findValueOrCreate("SOG");
+    GwApi::BoatValue *hdtBVal = boatValues->findValueOrCreate("HDT");
+    GwApi::BoatValue *hdmBVal = boatValues->findValueOrCreate("HDM");
+    GwApi::BoatValue *varBVal = boatValues->findValueOrCreate("VAR");
+    awaVal = awaBVal->valid ? awaBVal->value : DBL_MIN;
+    awsVal = awsBVal->valid ? awsBVal->value : DBL_MIN;
+    cogVal = cogBVal->valid ? cogBVal->value : DBL_MIN;
+    stwVal = stwBVal->valid ? stwBVal->value : DBL_MIN;
+    sogVal = sogBVal->valid ? sogBVal->value : DBL_MIN;
+    hdtVal = hdtBVal->valid ? hdtBVal->value : DBL_MIN;
+    hdmVal = hdmBVal->valid ? hdmBVal->value : DBL_MIN;
+    varVal = varBVal->valid ? varBVal->value : DBL_MIN;
+    api->getLogger()->logDebug(GwLog::DEBUG,"obp60task addTrueWind: AWA %.1f, AWS %.1f, COG %.1f, STW %.1f, SOG %.1f, HDT %.1f, HDM %.1f, VAR %.1f", awaBVal->value * RAD_TO_DEG, awsBVal->value * 3.6 / 1.852,
+            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);
+
+    isCalculated = WindUtils::calcTrueWind(&awaVal, &awsVal, &cogVal, &stwVal, &sogVal, &hdtVal, &hdmVal, &varVal, &twd, &tws, &twa);
+
+    if (isCalculated) { // Replace values only, if successfully calculated and not already available
+        if (!twdBVal->valid) {
+            twdBVal->value = twd;
+            twdBVal->valid = true;
+        }
+        if (!twsBVal->valid) {
+            twsBVal->value = tws;
+            twsBVal->valid = true;
+        }
+        if (!twaBVal->valid) {
+            twaBVal->value = twa;
+            twaBVal->valid = true;
+        }
+    }
+    api->getLogger()->logDebug(GwLog::DEBUG,"obp60task addTrueWind: TWD_Valid %d, isCalculated %d, TWD %.1f, TWA %.1f, TWS %.1f", twdBVal->valid, isCalculated, twdBVal->value * RAD_TO_DEG,
+        twaBVal->value * RAD_TO_DEG, twsBVal->value * 3.6 / 1.852);
+
+    return isCalculated;
+}
+
+void initHstryBuf(GwApi* api, BoatValueList* boatValues, tBoatHstryData hstryBufList) {
+    // Init history buffers for TWD, TWS
+
+    GwApi::BoatValue *calBVal; // temp variable just for data calibration -> we don't want to calibrate the original data here
+
+    int hstryUpdFreq = 1000; // Update frequency for history buffers in ms
+    int hstryMinVal = 0; // Minimum value for these history buffers
+    int twdHstryMax = 6283; // Max value for wind direction (TWD) in rad (0...2*PI), shifted by 1000 for 3 decimals
+    int twsHstryMax = 1000; // Max value for wind speed (TWS) in m/s, shifted by 10 for 1 decimal
+    // Initialize history buffers with meta data
+    hstryBufList.twdHstry->setMetaData("TWD", "formatCourse", hstryUpdFreq, hstryMinVal, twdHstryMax);
+    hstryBufList.twsHstry->setMetaData("TWS", "formatKnots", hstryUpdFreq, hstryMinVal, twsHstryMax);
+
+    GwApi::BoatValue *twdBVal = boatValues->findValueOrCreate(hstryBufList.twdHstry->getName());
+    GwApi::BoatValue *twsBVal = boatValues->findValueOrCreate(hstryBufList.twsHstry->getName());
+    GwApi::BoatValue *twaBVal = boatValues->findValueOrCreate("TWA");
+}
+
+void handleHstryBuf(GwApi* api, BoatValueList* boatValues, tBoatHstryData hstryBufList) {
+    // Handle history buffers for TWD, TWS
+
+    GwLog *logger = api->getLogger();
+
+    int16_t twdHstryMin = hstryBufList.twdHstry->getMinVal();
+    int16_t twdHstryMax = hstryBufList.twdHstry->getMaxVal();
+    int16_t twsHstryMin = hstryBufList.twsHstry->getMinVal();
+    int16_t twsHstryMax = hstryBufList.twsHstry->getMaxVal();
+    int16_t twdBuf, twsBuf;
+    GwApi::BoatValue *calBVal; // temp variable just for data calibration -> we don't want to calibrate the original data here
+
+    GwApi::BoatValue *twdBVal = boatValues->findValueOrCreate(hstryBufList.twdHstry->getName());
+    GwApi::BoatValue *twsBVal = boatValues->findValueOrCreate(hstryBufList.twsHstry->getName());
+    GwApi::BoatValue *twaBVal = boatValues->findValueOrCreate("TWA");
+
+    api->getLogger()->logDebug(GwLog::DEBUG,"obp60task handleHstryBuf: twdBVal: %.1f, twaBVal: %.1f, twsBVal: %.1f, TWD_isValid? %d", twdBVal->value * RAD_TO_DEG,
+        twaBVal->value * RAD_TO_DEG, twsBVal->value * 3.6 / 1.852, twdBVal->valid);
+    calBVal = new GwApi::BoatValue("TWD"); // temporary solution for calibration of history buffer values
+    calBVal->setFormat(twdBVal->getFormat());
+    if (twdBVal->valid) {
+        calBVal->value = twdBVal->value;
+        calBVal->valid = twdBVal->valid;
+        calibrationData.calibrateInstance(calBVal, logger); // Check if boat data value is to be calibrated
+        twdBuf = static_cast<int16_t>(std::round(calBVal->value * 1000));
+        if (twdBuf >= twdHstryMin && twdBuf <= twdHstryMax) {
+            hstryBufList.twdHstry->add(twdBuf);
+        }
+    }
+    delete calBVal;
+    calBVal = nullptr;
+
+    calBVal = new GwApi::BoatValue("TWS"); // temporary solution for calibration of history buffer values
+    calBVal->setFormat(twsBVal->getFormat());
+    if (twsBVal->valid) {
+        calBVal->value = twsBVal->value;
+        calBVal->valid = twsBVal->valid;
+        calibrationData.calibrateInstance(calBVal, logger); // Check if boat data value is to be calibrated
+        twsBuf = static_cast<int16_t>(std::round(calBVal->value * 10));
+        if (twsBuf >= twsHstryMin && twsBuf <= twsHstryMax) {
+            hstryBufList.twsHstry->add(twsBuf);
+        }
+    }
+    delete calBVal;
+    calBVal = nullptr;
+}
+
 // OBP60 Task
 //####################################################################################
 void OBP60Task(GwApi *api){
@@ -421,7 +500,7 @@ void OBP60Task(GwApi *api){
     #endif
 
     #ifdef DISPLAY_GDEY042T81
-        getdisplay().init(115200, true, 2, false);  // Use this for Waveshare boards with "clever" reset circuit, 2ms reset pulse
+        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
@@ -485,6 +564,11 @@ void OBP60Task(GwApi *api){
     //commonData.distanceformat=config->getString(xxx);
     //add all necessary data to common data
 
+    // Create ring buffers for history storage of some boat data
+    RingBuffer<int16_t> twdHstry(960); // Circular buffer to store wind direction values; store 960 TWD values for 16 minutes history
+    RingBuffer<int16_t> twsHstry(960); // Circular buffer to store wind speed values (TWS)
+    tBoatHstryData hstryBufList = {&twdHstry, &twsHstry};
+
     //fill the page data from config
     numPages=config->getInt(config->visiblePages,1);
     if (numPages < 1) numPages=1;
@@ -523,6 +607,10 @@ void OBP60Task(GwApi *api){
             LOG_DEBUG(GwLog::DEBUG,"added fixed value %s to page %d",value->getName().c_str(),i);
             pages[i].parameters.values.push_back(value); 
        }
+        if (pages[i].description->pageName == "WindPlot") {
+            // Add boat history data to page parameters
+            pages[i].parameters.boatHstry = hstryBufList;
+        }
     }
     // add out of band system page (always available)
     Page *syspage = allPages.pages[0]->creator(commonData);
@@ -530,6 +618,13 @@ void OBP60Task(GwApi *api){
     // Read all calibration data settings from config
     calibrationData.readConfig(config, logger);
 
+    // Check user setting for true wind calculation
+    bool calcTrueWnds = api->getConfig()->getBool(api->getConfig()->calcTrueWnds, false);
+    // bool simulation = api->getConfig()->getBool(api->getConfig()->useSimuData, false);
+
+    // Initialize history buffer for certain boat data
+    initHstryBuf(api, &boatValues, hstryBufList);
+
     // Display screenshot handler for HTTP request
     // http://192.168.15.1/api/user/OBP60Task/screenshot
     api->registerRequestHandler("screenshot", [api, &pageNumber, pages](AsyncWebServerRequest *request) {
@@ -747,12 +842,23 @@ void OBP60Task(GwApi *api){
                 starttime1 = millis();
                 starttime2 = millis();
                 getdisplay().setFullWindow();    // Set full update
-                getdisplay().nextPage();
-                if(fastrefresh == "false"){
+                if(fastrefresh == "true"){
+                    getdisplay().nextPage();                     // Full update
+                }
+                else{
                     getdisplay().fillScreen(commonData.fgcolor); // Clear display
+                    #ifdef DISPLAY_GDEY042T81
+                        getdisplay().hibernate();                  // Set display in hybenate 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
                     getdisplay().nextPage();                     // Full update
-                    getdisplay().fillScreen(commonData.bgcolor); // Clear display
-                    getdisplay().nextPage();                     // 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
                 }
                 delayedDisplayUpdate = false;
             }
@@ -764,12 +870,23 @@ void OBP60Task(GwApi *api){
                 starttime2 = millis();
                 LOG_DEBUG(GwLog::DEBUG,"E-Ink full refresh first 5 min");
                 getdisplay().setFullWindow();    // Set full update
-                getdisplay().nextPage();
-                if(fastrefresh == "false"){
+                if(fastrefresh == "true"){
+                    getdisplay().nextPage();                     // Full update
+                }
+                else{
                     getdisplay().fillScreen(commonData.fgcolor); // Clear display
+                    #ifdef DISPLAY_GDEY042T81
+                        getdisplay().hibernate();                  // Set display in hybenate 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
                     getdisplay().nextPage();                     // Full update
-                    getdisplay().fillScreen(commonData.bgcolor); // Clear display
-                    getdisplay().nextPage();                     // 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
                 }
             }
 
@@ -778,12 +895,23 @@ void OBP60Task(GwApi *api){
                 starttime2 = millis();
                 LOG_DEBUG(GwLog::DEBUG,"E-Ink full refresh");
                 getdisplay().setFullWindow();    // Set full update
-                getdisplay().nextPage();
-                if(fastrefresh == "false"){
+                if(fastrefresh == "true"){
+                    getdisplay().nextPage();                     // Full update
+                }
+                else{
                     getdisplay().fillScreen(commonData.fgcolor); // Clear display
+                    #ifdef DISPLAY_GDEY042T81
+                        getdisplay().hibernate();                  // Set display in hybenate 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
                     getdisplay().nextPage();                     // Full update
-                    getdisplay().fillScreen(commonData.bgcolor); // Clear display
-                    getdisplay().nextPage();                     // 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
                 }
             }        
                 
@@ -802,6 +930,12 @@ void OBP60Task(GwApi *api){
                 api->getBoatDataValues(boatValues.numValues,boatValues.allBoatValues);
                 api->getStatus(commonData.status);
 
+                if (calcTrueWnds) {
+                    addTrueWind(api, &boatValues);
+                }
+                // Handle history buffers for TWD, TWS for wind plot page and other usage
+                 handleHstryBuf(api, &boatValues, hstryBufList);
+
                 // Clear display
                 // getdisplay().fillRect(0, 0, getdisplay().width(), getdisplay().height(), commonData.bgcolor);
                 getdisplay().fillScreen(commonData.bgcolor);  // Clear display

lib/obp60task/platformio.ini

@@ -43,16 +43,17 @@ lib_deps =
     adafruit/Adafruit FRAM I2C@2.0.3
 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 (seral device)
+#    -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 DISPLAY_GDEW042T2            #old E-Ink display from Waveshare, R10 0.47 ohm
-    -D DISPLAY_GDEY042T81           #new E-Ink display from Waveshare, R10 2.2 ohm
-#    -D DISPLAY_GYE042A87            #alternativ E-Ink display from Genyo Optical, R10 2.2 ohm
-#    -D DISPLAY_SE0420NQ04           #alternativ E-Ink display from SID Technology, R10 2.2 ohm
+#    -D DISPLAY_GDEW042T2            #old E-Ink display from GoodDisplay (Waveshare), R10 0.47 ohm - very good
+    -D DISPLAY_GDEY042T81           #new E-Ink display from GoodDisplay (Waveshare), R10 2.2 ohm - good (contast lost by shunshine)
+#    -D DISPLAY_GYE042A87            #alternativ E-Ink display from Genyo Optical, R10 2.2 ohm - medium 
+#    -D DISPLAY_SE0420NQ04           #alternativ E-Ink display from SID Technology, R10 2.2 ohm - bad (burn in effects)
+#    -D DISPLAY_ZJY400300-042CAAMFGN #alternativ E-Ink display from ZZE Technology, R10 2.2 ohm - very good
     ${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
@@ -96,7 +97,8 @@ build_flags=
     -D DISABLE_DIAGNOSTIC_OUTPUT    #Disable diagnostic output for GxEPD2 lib
     -D BOARD_OBP40S3                #Board OBP40 with ESP32S3
     -D HARDWARE_V10                 #OBP40 hardware revision V1.0 SKU:DIE07300S V1.1 (CrowPanel 4.2)
-    -D DISPLAY_GDEY042T81           #new E-Ink display from Waveshare, R10 2.2 ohm
+    -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 VOLTAGE_SENSOR               #Hardware extension, LiPo voltage sensor with two resistors
     ${env.build_flags}