thooge
/
esp32-nmea2000-obp60
mirror of https://github.com/thooge/esp32-nmea2000-obp60.git
1
0
Fork 0
Code Releases Activity

Merge branch 'norbert-walter:master' into PageWindPlot

This commit is contained in:
Scorgan01 2025-08-17 23:47:38 +02:00 committed by GitHub
parent 8faead0a1a e19bd0898d
commit c8a7f14773
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
24 changed files with 859 additions and 622 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
lib/obp60task/OBP60Extensions.cpp
View File

@ -64,6 +64,12 @@ PCF8574 pcf8574_Out(PCF8574_I2C_ADDR1); // First digital output modul PCF8574 fr
Adafruit_FRAM_I2C fram; Adafruit_FRAM_I2C fram;
bool hasFRAM = false; bool hasFRAM = false;
// SD Card
#ifdef BOARD_OBP40S3
sdmmc_card_t *sdcard;
#endif
bool hasSDCard = false;
// Global vars // Global vars
bool blinkingLED = false; // Enable / disable blinking flash LED bool blinkingLED = false; // Enable / disable blinking flash LED
bool statusLED = false; // Actual status of flash LED on/off bool statusLED = false; // Actual status of flash LED on/off
@ -78,6 +84,9 @@ LedTaskData *ledTaskData=nullptr;
void hardwareInit(GwApi *api) void hardwareInit(GwApi *api)
{ {
GwLog *logger = api->getLogger();
GwConfigHandler *config = api->getConfig();
Wire.begin(); Wire.begin();
// Init PCF8574 digital outputs // Init PCF8574 digital outputs
Wire.setClock(I2C_SPEED); // Set I2C clock on 10 kHz Wire.setClock(I2C_SPEED); // Set I2C clock on 10 kHz
@ -87,7 +96,7 @@ void hardwareInit(GwApi *api)
fram = Adafruit_FRAM_I2C(); fram = Adafruit_FRAM_I2C();
if (esp_reset_reason() == ESP_RST_POWERON) { if (esp_reset_reason() == ESP_RST_POWERON) {
// help initialize FRAM // 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); delay(250);
} }
// FRAM (e.g. MB85RC256V) // FRAM (e.g. MB85RC256V)
@ -99,11 +108,88 @@ void hardwareInit(GwApi *api)
// Boot counter // Boot counter
uint8_t framcounter = fram.read(0x0000); uint8_t framcounter = fram.read(0x0000);
fram.write(0x0000, framcounter+1); 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 { else {
hasFRAM = false; 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
} }
} }

12
lib/obp60task/OBP60Extensions.h
View File

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

457
lib/obp60task/OBP60Formater.cpp → lib/obp60task/OBP60Formatter.cpp
View File

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

10
lib/obp60task/OBP60Hardware.h
View File

@ -82,7 +82,7 @@
// Direction pin for RS485 NMEA0183 // Direction pin for RS485 NMEA0183
#define OBP_DIRECTION_PIN 8 #define OBP_DIRECTION_PIN 8
// I2C // 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_SDA 21
#define OBP_I2C_SCL 38 #define OBP_I2C_SCL 38
// DS1388 RTC // DS1388 RTC
@ -120,10 +120,10 @@
#define SHOW_TIME 6000 // Show time in [ms] for logo and WiFi QR code #define SHOW_TIME 6000 // Show time in [ms] for logo and WiFi QR code
#define FULL_REFRESH_TIME 600 // Refresh cycle time in [s][600...3600] for full display update (very important healcy function) #define FULL_REFRESH_TIME 600 // Refresh cycle time in [s][600...3600] for full display update (very important healcy function)
// SPI SD-Card // SPI SD-Card
#define SD_SPI_CS 10 #define SD_SPI_CS GPIO_NUM_10
#define SD_SPI_MOSI 40 #define SD_SPI_MOSI GPIO_NUM_40
#define SD_SPI_CLK 39 #define SD_SPI_CLK GPIO_NUM_39
#define SD_SPI_MISO 13 #define SD_SPI_MISO GPIO_NUM_13
// GPS (NEO-6M, NEO-M8N, ATGM336H) // GPS (NEO-6M, NEO-M8N, ATGM336H)
#define OBP_GPS_RX 19 #define OBP_GPS_RX 19

2
lib/obp60task/PageBattery.cpp
View File

@ -5,7 +5,7 @@
class PageBattery : public Page class PageBattery : public Page
{ {
int average = 0; // Average type [0...3], 0=off, 1=10s, 2=60s, 3=300s int average = 0; // Average type [0...3], 0=off, 1=10s, 2=60s, 3=300s
public: public:
PageBattery(CommonData &common){ PageBattery(CommonData &common){

2
lib/obp60task/PageClock.cpp
View File

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

2
lib/obp60task/PageCompass.cpp
View File

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

8
lib/obp60task/PageFourValues.cpp
View File

@ -53,7 +53,7 @@ class PageFourValues : public Page
String unit1 = formatValue(bvalue1, *commonData).unit; // Unit of value String unit1 = formatValue(bvalue1, *commonData).unit; // Unit of value
// Get boat values #2 // 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 String name2 = xdrDelete(bvalue2->getName()); // Value name
name2 = name2.substring(0, 6); // String length limit for 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 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 String unit2 = formatValue(bvalue2, *commonData).unit; // Unit of value
// Get boat values #3 // 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 String name3 = xdrDelete(bvalue3->getName()); // Value name
name3 = name3.substring(0, 6); // String length limit for 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 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 String unit3 = formatValue(bvalue3, *commonData).unit; // Unit of value
// Get boat values #4 // 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 String name4 = xdrDelete(bvalue4->getName()); // Value name
name4 = name4.substring(0, 6); // String length limit for 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 calibrationData.calibrateInstance(bvalue4, logger); // Check if boat data value is to be calibrated
@ -301,7 +301,7 @@ static Page *createPage(CommonData &common){
* this will be number of BoatValue pointers in pageData.values * this will be number of BoatValue pointers in pageData.values
*/ */
PageDescription registerPageFourValues( PageDescription registerPageFourValues(
"FourValues", // Page name "FourValues", // Page name
createPage, // Action createPage, // Action
4, // Number of bus values depends on selection in Web configuration 4, // Number of bus values depends on selection in Web configuration
true // Show display header on/off true // Show display header on/off

29
lib/obp60task/PageKeelPosition.cpp
View File

@ -86,21 +86,20 @@ public:
float x = 200 + (rInstrument-30)*sin(i/180.0*pi); // x-coordinate dots 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 float y = 150 - (rInstrument-30)*cos(i/180.0*pi); // y-coordinate cots
const char *ii = " "; const char *ii = " ";
switch (i) switch (i) {
{ case 0: ii=" "; break; // Use a blank for a empty scale value
case 0: ii=" "; break; // Use a blank for a empty scale value case 30 : ii=" "; break;
case 30 : ii=" "; break; case 60 : ii=" "; break;
case 60 : ii=" "; break; case 90 : ii="45"; break;
case 90 : ii="45"; break; case 120 : ii="30"; break;
case 120 : ii="30"; break; case 150 : ii="15"; break;
case 150 : ii="15"; break; case 180 : ii="0"; break;
case 180 : ii="0"; break; case 210 : ii="15"; break;
case 210 : ii="15"; break; case 240 : ii="30"; break;
case 240 : ii="30"; break; case 270 : ii="45"; break;
case 270 : ii="45"; break; case 300 : ii=" "; break;
case 300 : ii=" "; break; case 330 : ii=" "; break;
case 330 : ii=" "; break; default: break;
default: break;
} }
// Print text centered on position x, y // Print text centered on position x, y

67
lib/obp60task/PageRollPitch.cpp
View File

@ -41,9 +41,9 @@ public:
String backlightMode = config->getString(config->backlight); String backlightMode = config->getString(config->backlight);
int rolllimit = config->getInt(config->rollLimit); int rolllimit = config->getInt(config->rollLimit);
String roffset = config->getString(config->rollOffset); 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); 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 // Get boat values for roll
GwApi::BoatValue *bvalue1 = pageData.values[0]; // First element in list (xdrRoll) GwApi::BoatValue *bvalue1 = pageData.values[0]; // First element in list (xdrRoll)
@ -55,17 +55,17 @@ public:
} }
else{ else{
if(simulation == true){ 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{ else{
value1 = 0; value1 = 0;
} }
} }
if(value1/(2*PI)*360 > -10 && value1/(2*PI)*360 < 10){ if(value1/(2*M_PI)*360 > -10 && value1/(2*M_PI)*360 < 10){
svalue1 = String(value1/(2*PI)*360,1); // Convert raw value to string svalue1 = String(value1/(2*M_PI)*360,1); // Convert raw value to string
} }
else{ else{
svalue1 = String(value1/(2*PI)*360,0); svalue1 = String(value1/(2*M_PI)*360,0);
} }
if(valid1 == true){ if(valid1 == true){
svalue1old = svalue1; // Save the old value svalue1old = svalue1; // Save the old value
@ -80,17 +80,17 @@ public:
} }
else{ else{
if(simulation == true){ if(simulation == true){
value2 = (float(random(-5, 5)))/360*2*PI; value2 = (float(random(-5, 5)))/360*2*M_PI;
} }
else{ else{
value2 = 0; value2 = 0;
} }
} }
if(value2/(2*PI)*360 > -10 && value2/(2*PI)*360 < 10){ if(value2/(2*PI)*360 > -10 && value2/(2*M_PI)*360 < 10){
svalue2 = String(value2/(2*PI)*360,1); // Convert raw value to string svalue2 = String(value2/(2*M_PI)*360,1); // Convert raw value to string
} }
else{ else{
svalue2 = String(value2/(2*PI)*360,0); svalue2 = String(value2/(2*M_PI)*360,0);
} }
if(valid2 == true){ if(valid2 == true){
svalue2old = svalue2; // Save the old value svalue2old = svalue2; // Save the old value
@ -99,7 +99,7 @@ public:
// Optical warning by limit violation // Optical warning by limit violation
if(String(flashLED) == "Limit Violation"){ if(String(flashLED) == "Limit Violation"){
// Limits for roll // 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); setBlinkingLED(false);
setFlashLED(false); setFlashLED(false);
} }
@ -132,7 +132,7 @@ public:
getdisplay().setFont(&Ubuntu_Bold8pt8b); getdisplay().setFont(&Ubuntu_Bold8pt8b);
getdisplay().setCursor(10, 115); getdisplay().setCursor(10, 115);
getdisplay().print("DEG"); getdisplay().print("DEG");
// Horizintal separator left // Horizintal separator left
getdisplay().fillRect(0, 149, 60, 3, commonData->fgcolor); getdisplay().fillRect(0, 149, 60, 3, commonData->fgcolor);
@ -164,7 +164,7 @@ public:
getdisplay().print("Deg"); getdisplay().print("Deg");
//******************************************************************************************* //*******************************************************************************************
// Draw instrument // Draw instrument
int rInstrument = 100; // Radius of instrument int rInstrument = 100; // Radius of instrument
float pi = 3.141592; float pi = 3.141592;
@ -177,19 +177,18 @@ public:
// Only scaling +/- 60 degrees // Only scaling +/- 60 degrees
if((i >= 0 && i <= 60) || (i >= 300 && i <= 360)){ if((i >= 0 && i <= 60) || (i >= 300 && i <= 360)){
// Scaling values // Scaling values
float x = 200 + (rInstrument+25)*sin(i/180.0*pi); // x-coordinate dots float x = 200 + (rInstrument+25)*sin(i/180.0*M_PI); // x-coordinate dots
float y = 150 - (rInstrument+25)*cos(i/180.0*pi); // y-coordinate cots float y = 150 - (rInstrument+25)*cos(i/180.0*M_PI); // y-coordinate cots
const char *ii = ""; const char *ii = "";
switch (i) switch (i) {
{ case 0: ii="0"; break;
case 0: ii="0"; break; case 20 : ii="20"; break;
case 20 : ii="20"; break; case 40 : ii="40"; break;
case 40 : ii="40"; break; case 60 : ii="60"; break;
case 60 : ii="60"; break; case 300 : ii="60"; break;
case 300 : ii="60"; break; case 320 : ii="40"; break;
case 320 : ii="40"; break; case 340 : ii="20"; break;
case 340 : ii="20"; break; default: break;
default: break;
} }
// Print text centered on position x, y // Print text centered on position x, y
@ -203,11 +202,11 @@ public:
} }
// Draw sub scale with dots // Draw sub scale with dots
float x1c = 200 + rInstrument*sin(i/180.0*pi); float x1c = 200 + rInstrument*sin(i/180.0*M_PI);
float y1c = 150 - rInstrument*cos(i/180.0*pi); float y1c = 150 - rInstrument*cos(i/180.0*M_PI);
getdisplay().fillCircle((int)x1c, (int)y1c, 2, commonData->fgcolor); getdisplay().fillCircle((int)x1c, (int)y1c, 2, commonData->fgcolor);
float sinx=sin(i/180.0*pi); float sinx=sin(i/180.0*M_PI);
float cosx=cos(i/180.0*pi); float cosx=cos(i/180.0*M_PI);
// Draw sub scale with lines (two triangles) // Draw sub scale with lines (two triangles)
if(i % 20 == 0){ if(i % 20 == 0){
@ -229,17 +228,17 @@ public:
// Draw mast position pointer // Draw mast position pointer
float startwidth = 8; // Start width of 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){ if(valid1 == true || holdvalues == true || simulation == true){
float sinx=sin(value1 + pi); float sinx=sin(value1 + M_PI);
float cosx=cos(value1 + pi); float cosx=cos(value1 + M_PI);
// Normal pointer // Normal pointer
// Pointer as triangle with center base 2*width // Pointer as triangle with center base 2*width
float xx1 = -startwidth; float xx1 = -startwidth;
float xx2 = startwidth; float xx2 = startwidth;
float yy1 = -startwidth; float yy1 = -startwidth;
float yy2 = -(rInstrument * 0.7); float yy2 = -(rInstrument * 0.7);
getdisplay().fillTriangle(200+(int)(cosx*xx1-sinx*yy1),150+(int)(sinx*xx1+cosx*yy1), getdisplay().fillTriangle(200+(int)(cosx*xx1-sinx*yy1),150+(int)(sinx*xx1+cosx*yy1),
200+(int)(cosx*xx2-sinx*yy1),150+(int)(sinx*xx2+cosx*yy1), 200+(int)(cosx*xx2-sinx*yy1),150+(int)(sinx*xx2+cosx*yy1),
200+(int)(cosx*0-sinx*yy2),150+(int)(sinx*0+cosx*yy2),commonData->fgcolor); 200+(int)(cosx*0-sinx*yy2),150+(int)(sinx*0+cosx*yy2),commonData->fgcolor);
@ -283,7 +282,7 @@ public:
float xx1 = -startwidth; float xx1 = -startwidth;
float xx2 = startwidth; float xx2 = startwidth;
float yy1 = -startwidth; float yy1 = -startwidth;
float yy2 = -(rInstrument - 15); float yy2 = -(rInstrument - 15);
getdisplay().fillTriangle(200+(int)(cosx*xx1-sinx*yy1),150+(int)(sinx*xx1+cosx*yy1), getdisplay().fillTriangle(200+(int)(cosx*xx1-sinx*yy1),150+(int)(sinx*xx1+cosx*yy1),
200+(int)(cosx*xx2-sinx*yy1),150+(int)(sinx*xx2+cosx*yy1), 200+(int)(cosx*xx2-sinx*yy1),150+(int)(sinx*xx2+cosx*yy1),
200+(int)(cosx*0-sinx*yy2),150+(int)(sinx*0+cosx*yy2),commonData->fgcolor); 200+(int)(cosx*0-sinx*yy2),150+(int)(sinx*0+cosx*yy2),commonData->fgcolor);

152
lib/obp60task/PageSystem.cpp
View File

@ -1,5 +1,15 @@
#if defined BOARD_OBP60S3 || defined BOARD_OBP40S3 #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 "Pagedata.h"
#include "OBP60Extensions.h" #include "OBP60Extensions.h"
#include "images/logo64.xbm" #include "images/logo64.xbm"
@ -7,8 +17,7 @@
#include "qrcode.h" #include "qrcode.h"
#ifdef BOARD_OBP40S3 #ifdef BOARD_OBP40S3
#include <SD.h> #include "dirent.h"
#include <FS.h>
#endif #endif
#define STRINGIZE_IMPL(x) #x #define STRINGIZE_IMPL(x) #x
@ -19,35 +28,27 @@
#define DISPLAYINFO STRINGIZE(EPDTYPE) #define DISPLAYINFO STRINGIZE(EPDTYPE)
#define GXEPD2INFO STRINGIZE(GXEPD2VERS) #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 class PageSystem : public Page
{ {
uint64_t chipid; private:
bool simulation; uint64_t chipid;
bool sdcard; bool simulation;
String buzzer_mode; bool use_sdcard;
uint8_t buzzer_power; String buzzer_mode;
String cpuspeed; uint8_t buzzer_power;
String rtc_module; String cpuspeed;
String gps_module; String rtc_module;
String env_module; String gps_module;
String env_module;
String batt_sensor; String batt_sensor;
String solar_sensor; String solar_sensor;
String gen_sensor; String gen_sensor;
String rot_sensor; String rot_sensor;
double homelat; double homelat;
double homelon; 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: public:
PageSystem(CommonData &common){ PageSystem(CommonData &common){
@ -55,11 +56,12 @@ public:
common.logger->logDebug(GwLog::LOG,"Instantiate PageSystem"); common.logger->logDebug(GwLog::LOG,"Instantiate PageSystem");
if (hasFRAM) { if (hasFRAM) {
mode = fram.read(FRAM_SYSTEM_MODE); mode = fram.read(FRAM_SYSTEM_MODE);
common.logger->logDebug(GwLog::DEBUG, "Loaded mode '%c' from FRAM", mode);
} }
chipid = ESP.getEfuseMac(); chipid = ESP.getEfuseMac();
simulation = common.config->getBool(common.config->useSimuData); simulation = common.config->getBool(common.config->useSimuData);
#ifdef BOARD_OBP40S3 #ifdef BOARD_OBP40S3
sdcard = common.config->getBool(common.config->useSDCard); use_sdcard = common.config->getBool(common.config->useSDCard);
#endif #endif
buzzer_mode = common.config->getString(common.config->buzzerMode); buzzer_mode = common.config->getString(common.config->buzzerMode);
buzzer_mode.toLowerCase(); buzzer_mode.toLowerCase();
@ -76,7 +78,7 @@ public:
homelon = common.config->getString(common.config->homeLON).toDouble(); homelon = common.config->getString(common.config->homeLON).toDouble();
} }
virtual void setupKeys(){ void setupKeys() {
commonData->keydata[0].label = "EXIT"; commonData->keydata[0].label = "EXIT";
commonData->keydata[1].label = "MODE"; commonData->keydata[1].label = "MODE";
commonData->keydata[2].label = ""; commonData->keydata[2].label = "";
@ -85,7 +87,7 @@ public:
commonData->keydata[5].label = "ILUM"; 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 // do *NOT* handle key #1 this handled by obp60task as exit
// Switch display mode // Switch display mode
commonData->logger->logDebug(GwLog::LOG, "System keyboard handler"); commonData->logger->logDebug(GwLog::LOG, "System keyboard handler");
@ -95,7 +97,7 @@ public:
} else if (mode == 'S') { } else if (mode == 'S') {
mode = 'D'; mode = 'D';
} else if (mode == 'D') { } else if (mode == 'D') {
if (sdcard) { if (hasSDCard) {
mode = 'C'; mode = 'C';
} else { } else {
mode = 'N'; mode = 'N';
@ -117,7 +119,8 @@ public:
} }
// standby / deep sleep // standby / deep sleep
if (key == 5) { if (key == 5) {
deepSleep(*commonData); commonData->logger->logDebug(GwLog::LOG, "System going into deep sleep mode...");
deepSleep(*commonData);
} }
// Code for keylock // Code for keylock
if (key == 11) { if (key == 11) {
@ -132,6 +135,7 @@ public:
} }
// standby / deep sleep // standby / deep sleep
if (key == 12) { if (key == 12) {
commonData->logger->logDebug(GwLog::LOG, "System going into deep sleep mode...");
deepSleep(*commonData); deepSleep(*commonData);
} }
#endif #endif
@ -178,7 +182,7 @@ public:
} }
// Logging boat values // Logging boat values
LOG_DEBUG(GwLog::LOG,"Drawing at PageSystem"); logger->logDebug(GwLog::LOG, "Drawing at PageSystem, Mode=%c", mode);
// Draw page // Draw page
//*********************************************************** //***********************************************************
@ -257,14 +261,37 @@ public:
getdisplay().setCursor(8, y0 + 48); getdisplay().setCursor(8, y0 + 48);
getdisplay().print("SD-Card:"); getdisplay().print("SD-Card:");
getdisplay().setCursor(90, y0 + 48); getdisplay().setCursor(90, y0 + 48);
if (sdcard) { if (hasSDCard) {
uint64_t cardsize = SD.cardSize() / (1024 * 1024); uint64_t cardsize = ((uint64_t) sdcard->csd.capacity) * sdcard->csd.sector_size / (1024 * 1024);
getdisplay().print(String(cardsize) + String(" MB")); getdisplay().printf("%llu MB", cardsize);
} else { } else {
getdisplay().print("off"); getdisplay().print("off");
} }
#endif #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 // CPU speed config / active
getdisplay().setCursor(202, y0); getdisplay().setCursor(202, y0);
getdisplay().print("CPU speed:"); getdisplay().print("CPU speed:");
@ -371,8 +398,61 @@ public:
x0 = 20; x0 = 20;
y0 = 72; y0 = 72;
getdisplay().setCursor(x0, y0); 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..."); 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 { } else {
// NMEA2000 device list // NMEA2000 device list

4
lib/obp60task/PageThreeValues.cpp
View File

@ -51,7 +51,7 @@ class PageThreeValues : public Page
String unit1 = formatValue(bvalue1, *commonData).unit; // Unit of value String unit1 = formatValue(bvalue1, *commonData).unit; // Unit of value
// Get boat values #2 // 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 String name2 = xdrDelete(bvalue2->getName()); // Value name
name2 = name2.substring(0, 6); // String length limit for 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 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 String unit2 = formatValue(bvalue2, *commonData).unit; // Unit of value
// Get boat values #3 // 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 String name3 = xdrDelete(bvalue3->getName()); // Value name
name3 = name3.substring(0, 6); // String length limit for 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 calibrationData.calibrateInstance(bvalue3, logger); // Check if boat data value is to be calibrated

2
lib/obp60task/PageTwoValues.cpp
View File

@ -49,7 +49,7 @@ class PageTwoValues : public Page
String unit1 = formatValue(bvalue1, *commonData).unit; // Unit of value String unit1 = formatValue(bvalue1, *commonData).unit; // Unit of value
// Get boat values #2 // 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 String name2 = xdrDelete(bvalue2->getName()); // Value name
name2 = name2.substring(0, 6); // String length limit for 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 calibrationData.calibrateInstance(bvalue2, logger); // Check if boat data value is to be calibrated

10
lib/obp60task/PageVoltage.cpp
View File

@ -398,11 +398,11 @@ static Page *createPage(CommonData &common){
* and will will provide the names of the fixed values we need * and will will provide the names of the fixed values we need
*/ */
PageDescription registerPageVoltage( PageDescription registerPageVoltage(
"Voltage", // Name of page "Voltage", // Name of page
createPage, // Action createPage, // Action
0, // Number of bus values depends on selection in Web configuration 0, // Number of bus values depends on selection in Web configuration
{}, // Names of bus values undepends on selection in Web configuration (refer GwBoatData.h) {}, // Names of bus values undepends on selection in Web configuration (refer GwBoatData.h)
true // Show display header on/off true // Show display header on/off
); );
#endif #endif

8
lib/obp60task/PageWind.cpp
View File

@ -633,11 +633,11 @@ static Page *createPage(CommonData &common){
* and will will provide the names of the fixed values we need * and will will provide the names of the fixed values we need
*/ */
PageDescription registerPageWind( PageDescription registerPageWind(
"Wind", // Page name "Wind", // Page name
createPage, // Action createPage, // Action
0, // Number of bus values depends on selection in Web configuration 0, // Number of bus values depends on selection in Web configuration
{"AWS","AWA", "TWS", "TWA"}, // Bus values we need in the page {"AWS","AWA", "TWS", "TWA"}, // Bus values we need in the page
true // Show display header on/off true // Show display header on/off
); );
#endif #endif

38
lib/obp60task/PageWindRose.cpp
View File

@ -48,7 +48,7 @@ public:
String flashLED = config->getString(config->flashLED); String flashLED = config->getString(config->flashLED);
String backlightMode = config->getString(config->backlight); 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) GwApi::BoatValue *bvalue1 = pageData.values[0]; // First element in list (only one value by PageOneValue)
String name1 = xdrDelete(bvalue1->getName()); // Value name String name1 = xdrDelete(bvalue1->getName()); // Value name
name1 = name1.substring(0, 6); // String length limit for value name name1 = name1.substring(0, 6); // String length limit for value name
@ -63,8 +63,8 @@ public:
unit1old = unit1; // Save old unit unit1old = unit1; // Save old unit
} }
// Get boat values for AWS // Get boat value for AWS
GwApi::BoatValue *bvalue2 = pageData.values[1]; // First 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 String name2 = xdrDelete(bvalue2->getName()); // Value name
name2 = name2.substring(0, 6); // String length limit for 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 calibrationData.calibrateInstance(bvalue2, logger); // Check if boat data value is to be calibrated
@ -77,8 +77,8 @@ public:
unit2old = unit2; // Save old unit unit2old = unit2; // Save old unit
} }
// Get boat values TWD // Get boat value for TWD
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 String name3 = xdrDelete(bvalue3->getName()); // Value name
name3 = name3.substring(0, 6); // String length limit for 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 calibrationData.calibrateInstance(bvalue3, logger); // Check if boat data value is to be calibrated
@ -91,9 +91,9 @@ public:
unit3old = unit3; // Save old unit unit3old = unit3; // Save old unit
} }
// Get boat values TWS // Get boat value for TWS
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 String name4 = xdrDelete(bvalue4->getName()); // Value name
name4 = name4.substring(0, 6); // String length limit for 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 calibrationData.calibrateInstance(bvalue4, logger); // Check if boat data value is to be calibrated
double value4 = bvalue4->value; // Value as double in SI unit double value4 = bvalue4->value; // Value as double in SI unit
@ -105,9 +105,9 @@ public:
unit4old = unit4; // Save old unit unit4old = unit4; // Save old unit
} }
// Get boat values DBT // Get boat value for DBT
GwApi::BoatValue *bvalue5 = pageData.values[4]; // Second element in list (only one value by PageOneValue) GwApi::BoatValue *bvalue5 = pageData.values[4]; // Fifth element in list
String name5 = xdrDelete(bvalue5->getName()); // Value name String name5 = xdrDelete(bvalue5->getName()); // Value name
name5 = name5.substring(0, 6); // String length limit for 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 calibrationData.calibrateInstance(bvalue5, logger); // Check if boat data value is to be calibrated
double value5 = bvalue5->value; // Value as double in SI unit double value5 = bvalue5->value; // Value as double in SI unit
@ -119,9 +119,9 @@ public:
unit5old = unit5; // Save old unit unit5old = unit5; // Save old unit
} }
// Get boat values STW // Get boat value for STW
GwApi::BoatValue *bvalue6 = pageData.values[5]; // Second element in list (only one value by PageOneValue) GwApi::BoatValue *bvalue6 = pageData.values[5]; // Sixth element in list
String name6 = xdrDelete(bvalue6->getName()); // Value name String name6 = xdrDelete(bvalue6->getName()); // Value name
name6 = name6.substring(0, 6); // String length limit for 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 calibrationData.calibrateInstance(bvalue6, logger); // Check if boat data value is to be calibrated
double value6 = bvalue6->value; // Value as double in SI unit double value6 = bvalue6->value; // Value as double in SI unit
@ -248,7 +248,7 @@ public:
float y = 150 - (rInstrument-30)*cos(i/180.0*pi); // y-coordinate cots float y = 150 - (rInstrument-30)*cos(i/180.0*pi); // y-coordinate cots
const char *ii = ""; const char *ii = "";
switch (i) switch (i)
{ {
case 0: ii="0"; break; case 0: ii="0"; break;
case 30 : ii="30"; break; case 30 : ii="30"; break;
case 60 : ii="60"; break; case 60 : ii="60"; break;
@ -372,11 +372,11 @@ static Page *createPage(CommonData &common){
* and will will provide the names of the fixed values we need * and will will provide the names of the fixed values we need
*/ */
PageDescription registerPageWindRose( PageDescription registerPageWindRose(
"WindRose", // Page name "WindRose", // Page name
createPage, // Action createPage, // Action
0, // Number of bus values depends on selection in Web configuration 0, // Number of bus values depends on selection in Web configuration
{"AWA", "AWS", "TWD", "TWS", "DBT", "STW"}, // Bus values we need in the page {"AWA", "AWS", "TWD", "TWS", "DBT", "STW"}, // Bus values we need in the page
true // Show display header on/off true // Show display header on/off
); );
#endif #endif

151
lib/obp60task/PageWindRoseFlex.cpp
View File

@ -48,7 +48,7 @@ public:
String flashLED = config->getString(config->flashLED); String flashLED = config->getString(config->flashLED);
String backlightMode = config->getString(config->backlight); 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) GwApi::BoatValue *bvalue1 = pageData.values[0]; // First element in list (only one value by PageOneValue)
String name1 = xdrDelete(bvalue1->getName()); // Value name String name1 = xdrDelete(bvalue1->getName()); // Value name
name1 = name1.substring(0, 6); // String length limit for value name name1 = name1.substring(0, 6); // String length limit for value name
@ -63,13 +63,13 @@ public:
unit1old = unit1; // Save old unit unit1old = unit1; // Save old unit
} }
// Get boat values for AWS // Get boat values #2
GwApi::BoatValue *bvalue2 = pageData.values[1]; // First 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 String name2 = xdrDelete(bvalue2->getName()); // Value name
name2 = name2.substring(0, 6); // String length limit for 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 calibrationData.calibrateInstance(bvalue2, logger); // Check if boat data value is to be calibrated
double value2 = bvalue2->value; // Value as double in SI unit double value2 = bvalue2->value; // Value as double in SI unit
bool valid2 = bvalue2->valid; // Valid information bool valid2 = bvalue2->valid; // Valid information
String svalue2 = formatValue(bvalue2, *commonData).svalue; // Formatted value as string including unit conversion and switching decimal places String svalue2 = formatValue(bvalue2, *commonData).svalue; // Formatted value as string including unit conversion and switching decimal places
String unit2 = formatValue(bvalue2, *commonData).unit; // Unit of value String unit2 = formatValue(bvalue2, *commonData).unit; // Unit of value
if(valid2 == true){ if(valid2 == true){
@ -77,13 +77,13 @@ public:
unit2old = unit2; // Save old unit unit2old = unit2; // Save old unit
} }
// Get boat values TWD // 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 String name3 = xdrDelete(bvalue3->getName()); // Value name
name3 = name3.substring(0, 6); // String length limit for 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 calibrationData.calibrateInstance(bvalue3, logger); // Check if boat data value is to be calibrated
double value3 = bvalue3->value; // Value as double in SI unit double value3 = bvalue3->value; // Value as double in SI unit
bool valid3 = bvalue3->valid; // Valid information bool valid3 = bvalue3->valid; // Valid information
String svalue3 = formatValue(bvalue3, *commonData).svalue; // Formatted value as string including unit conversion and switching decimal places String svalue3 = formatValue(bvalue3, *commonData).svalue; // Formatted value as string including unit conversion and switching decimal places
String unit3 = formatValue(bvalue3, *commonData).unit; // Unit of value String unit3 = formatValue(bvalue3, *commonData).unit; // Unit of value
if(valid3 == true){ if(valid3 == true){
@ -91,13 +91,13 @@ public:
unit3old = unit3; // Save old unit unit3old = unit3; // Save old unit
} }
// Get boat values TWS // 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 String name4 = xdrDelete(bvalue4->getName()); // Value name
name4 = name4.substring(0, 6); // String length limit for 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 calibrationData.calibrateInstance(bvalue4, logger); // Check if boat data value is to be calibrated
double value4 = bvalue4->value; // Value as double in SI unit double value4 = bvalue4->value; // Value as double in SI unit
bool valid4 = bvalue4->valid; // Valid information bool valid4 = bvalue4->valid; // Valid information
String svalue4 = formatValue(bvalue4, *commonData).svalue; // Formatted value as string including unit conversion and switching decimal places String svalue4 = formatValue(bvalue4, *commonData).svalue; // Formatted value as string including unit conversion and switching decimal places
String unit4 = formatValue(bvalue4, *commonData).unit; // Unit of value String unit4 = formatValue(bvalue4, *commonData).unit; // Unit of value
if(valid4 == true){ if(valid4 == true){
@ -105,13 +105,13 @@ public:
unit4old = unit4; // Save old unit unit4old = unit4; // Save old unit
} }
// Get boat values DBT // Get boat values #5
GwApi::BoatValue *bvalue5 = pageData.values[4]; // Second element in list (only one value by PageOneValue) GwApi::BoatValue *bvalue5 = pageData.values[4]; // Fifth element in list
String name5 = xdrDelete(bvalue5->getName()); // Value name String name5 = xdrDelete(bvalue5->getName()); // Value name
name5 = name5.substring(0, 6); // String length limit for 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 calibrationData.calibrateInstance(bvalue5, logger); // Check if boat data value is to be calibrated
double value5 = bvalue5->value; // Value as double in SI unit double value5 = bvalue5->value; // Value as double in SI unit
bool valid5 = bvalue5->valid; // Valid information bool valid5 = bvalue5->valid; // Valid information
String svalue5 = formatValue(bvalue5, *commonData).svalue; // Formatted value as string including unit conversion and switching decimal places String svalue5 = formatValue(bvalue5, *commonData).svalue; // Formatted value as string including unit conversion and switching decimal places
String unit5 = formatValue(bvalue5, *commonData).unit; // Unit of value String unit5 = formatValue(bvalue5, *commonData).unit; // Unit of value
if(valid5 == true){ if(valid5 == true){
@ -119,13 +119,13 @@ public:
unit5old = unit5; // Save old unit unit5old = unit5; // Save old unit
} }
// Get boat values STW // Get boat values #5
GwApi::BoatValue *bvalue6 = pageData.values[5]; // Second element in list (only one value by PageOneValue) GwApi::BoatValue *bvalue6 = pageData.values[5]; // Sixth element in list
String name6 = xdrDelete(bvalue6->getName()); // Value name String name6 = xdrDelete(bvalue6->getName()); // Value name
name6 = name6.substring(0, 6); // String length limit for 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 calibrationData.calibrateInstance(bvalue6, logger); // Check if boat data value is to be calibrated
double value6 = bvalue6->value; // Value as double in SI unit double value6 = bvalue6->value; // Value as double in SI unit
bool valid6 = bvalue6->valid; // Valid information bool valid6 = bvalue6->valid; // Valid information
String svalue6 = formatValue(bvalue6, *commonData).svalue; // Formatted value as string including unit conversion and switching decimal places String svalue6 = formatValue(bvalue6, *commonData).svalue; // Formatted value as string including unit conversion and switching decimal places
String unit6 = formatValue(bvalue6, *commonData).unit; // Unit of value String unit6 = formatValue(bvalue6, *commonData).unit; // Unit of value
if(valid6 == true){ if(valid6 == true){
@ -136,7 +136,7 @@ public:
// Optical warning by limit violation (unused) // Optical warning by limit violation (unused)
if(String(flashLED) == "Limit Violation"){ if(String(flashLED) == "Limit Violation"){
setBlinkingLED(false); setBlinkingLED(false);
setFlashLED(false); setFlashLED(false);
} }
// Logging boat values // Logging boat values
@ -192,7 +192,7 @@ public:
getdisplay().setFont(&DSEG7Classic_BoldItalic20pt7b); getdisplay().setFont(&DSEG7Classic_BoldItalic20pt7b);
getdisplay().setCursor(295, 65); getdisplay().setCursor(295, 65);
if(valid3 == true){ if(valid3 == true){
// getdisplay().print(abs(value3 * 180 / PI), 0); // Value // getdisplay().print(abs(value3 * 180 / M_PI), 0); // Value
getdisplay().print(svalue4); // Value getdisplay().print(svalue4); // Value
} }
else{ else{
@ -227,16 +227,15 @@ public:
if(holdvalues == false){ if(holdvalues == false){
getdisplay().print(unit5); // Unit getdisplay().print(unit5); // Unit
} }
else{ else{
getdisplay().print(unit5old); // Unit getdisplay().print(unit5old); // Unit
} }
//******************************************************************************************* //*******************************************************************************************
// Draw wind rose // Draw wind rose
int rInstrument = 110; // Radius of grafic instrument 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 + 10, commonData->fgcolor); // Outer circle
getdisplay().fillCircle(200, 150, rInstrument + 7, commonData->bgcolor); // Outer circle getdisplay().fillCircle(200, 150, rInstrument + 7, commonData->bgcolor); // Outer circle
@ -246,24 +245,23 @@ public:
for(int i=0; i<360; i=i+10) for(int i=0; i<360; i=i+10)
{ {
// Scaling values // Scaling values
float x = 200 + (rInstrument-30)*sin(i/180.0*pi); // x-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*pi); // y-coordinate dots float y = 150 - (rInstrument-30)*cos(i/180.0*M_PI); // y-coordinate dots
const char *ii = ""; const char *ii = "";
switch (i) switch (i) {
{ case 0: ii="0"; break;
case 0: ii="0"; break; case 30 : ii="30"; break;
case 30 : ii="30"; break; case 60 : ii="60"; break;
case 60 : ii="60"; break; case 90 : ii="90"; break;
case 90 : ii="90"; break; case 120 : ii="120"; break;
case 120 : ii="120"; break; case 150 : ii="150"; break;
case 150 : ii="150"; break; case 180 : ii="180"; break;
case 180 : ii="180"; break; case 210 : ii="210"; break;
case 210 : ii="210"; break; case 240 : ii="240"; break;
case 240 : ii="240"; break; case 270 : ii="270"; break;
case 270 : ii="270"; break; case 300 : ii="300"; break;
case 300 : ii="300"; break; case 330 : ii="330"; break;
case 330 : ii="330"; break; default: break;
default: break;
} }
// Print text centered on position x, y // Print text centered on position x, y
@ -277,11 +275,11 @@ public:
} }
// Draw sub scale with dots // Draw sub scale with dots
float x1c = 200 + rInstrument*sin(i/180.0*pi); float x1c = 200 + rInstrument*sin(i/180.0*M_PI);
float y1c = 150 - rInstrument*cos(i/180.0*pi); float y1c = 150 - rInstrument*cos(i/180.0*M_PI);
getdisplay().fillCircle((int)x1c, (int)y1c, 2, commonData->fgcolor); getdisplay().fillCircle((int)x1c, (int)y1c, 2, commonData->fgcolor);
float sinx=sin(i/180.0*pi); float sinx=sin(i/180.0*M_PI);
float cosx=cos(i/180.0*pi); float cosx=cos(i/180.0*M_PI);
// Draw sub scale with lines (two triangles) // Draw sub scale with lines (two triangles)
if(i % 30 == 0){ if(i % 30 == 0){
@ -309,7 +307,7 @@ public:
float xx1 = -startwidth; float xx1 = -startwidth;
float xx2 = startwidth; float xx2 = startwidth;
float yy1 = -startwidth; float yy1 = -startwidth;
float yy2 = -(rInstrument-15); float yy2 = -(rInstrument-15);
getdisplay().fillTriangle(200+(int)(cosx*xx1-sinx*yy1),150+(int)(sinx*xx1+cosx*yy1), getdisplay().fillTriangle(200+(int)(cosx*xx1-sinx*yy1),150+(int)(sinx*xx1+cosx*yy1),
200+(int)(cosx*xx2-sinx*yy1),150+(int)(sinx*xx2+cosx*yy1), 200+(int)(cosx*xx2-sinx*yy1),150+(int)(sinx*xx2+cosx*yy1),
200+(int)(cosx*0-sinx*yy2),150+(int)(sinx*0+cosx*yy2),commonData->fgcolor); 200+(int)(cosx*0-sinx*yy2),150+(int)(sinx*0+cosx*yy2),commonData->fgcolor);
@ -331,36 +329,26 @@ public:
//******************************************************************************************* //*******************************************************************************************
// Show value6, so that it does not collide with the wind pointer // Show value6, so that it does not collide with the wind pointer
if ( cos(value1) > 0){ getdisplay().setFont(&DSEG7Classic_BoldItalic16pt7b);
getdisplay().setFont(&DSEG7Classic_BoldItalic16pt7b); if (cos(value1) > 0){
getdisplay().setCursor(160, 200); getdisplay().setCursor(160, 200);
getdisplay().print(svalue6); // Value getdisplay().print(svalue6); // Value
getdisplay().setFont(&Ubuntu_Bold8pt8b); getdisplay().setFont(&Ubuntu_Bold8pt8b);
getdisplay().setCursor(190, 215); getdisplay().setCursor(190, 215);
getdisplay().print(" "); } else{
if(holdvalues == false){ getdisplay().setCursor(160, 130);
getdisplay().print(unit6); // Unit getdisplay().print(svalue6); // Value
} getdisplay().setFont(&Ubuntu_Bold8pt8b);
else{ getdisplay().setCursor(190, 90);
getdisplay().print(unit6old); // Unit }
} getdisplay().print(" ");
} if(holdvalues == false){
else{ getdisplay().print(unit6); // Unit
getdisplay().setFont(&DSEG7Classic_BoldItalic16pt7b); }
getdisplay().setCursor(160, 130); else{
getdisplay().print(svalue6); // Value getdisplay().print(unit6old); // Unit
getdisplay().setFont(&Ubuntu_Bold8pt8b); }
getdisplay().setCursor(190, 90);
getdisplay().print(" ");
if(holdvalues == false){
getdisplay().print(unit6); // Unit
}
else{
getdisplay().print(unit6old); // Unit
}
}
return PAGE_UPDATE; return PAGE_UPDATE;
}; };
@ -377,11 +365,10 @@ static Page *createPage(CommonData &common){
* and will will provide the names of the fixed values we need * and will will provide the names of the fixed values we need
*/ */
PageDescription registerPageWindRoseFlex( PageDescription registerPageWindRoseFlex(
"WindRoseFlex", // Page name "WindRoseFlex", // Page name
createPage, // Action createPage, // Action
6, // Number of bus values depends on selection in Web configuration; was zero 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
true // Show display header on/off
); );
#endif #endif

8
lib/obp60task/PageXTETrack.cpp
View File

@ -223,11 +223,11 @@ static Page* createPage(CommonData &common){
* this will be number of BoatValue pointers in pageData.values * this will be number of BoatValue pointers in pageData.values
*/ */
PageDescription registerPageXTETrack( PageDescription registerPageXTETrack(
"XTETrack", // Page name "XTETrack", // Page name
createPage, // Action createPage, // Action
0, // Number of bus values depends on selection in Web configuration 0, // Number of bus values depends on selection in Web configuration
{"XTE", "COG", "DTW", "BTW"}, // Bus values we need in the page {"XTE", "COG", "DTW", "BTW"}, // Bus values we need in the page
true // Show display header on/off true // Show display header on/off
); );
#endif #endif

5
lib/obp60task/Pagedata.h
View File

@ -123,6 +123,7 @@ class Page{
int refreshtime = 1000; int refreshtime = 1000;
virtual int displayPage(PageData &pageData)=0; virtual int displayPage(PageData &pageData)=0;
virtual void displayNew(PageData &pageData){} virtual void displayNew(PageData &pageData){}
virtual void leavePage(PageData &pageData){}
virtual void setupKeys() { virtual void setupKeys() {
#ifdef HARDWARE_V21 #ifdef HARDWARE_V21
commonData->keydata[0].label = ""; commonData->keydata[0].label = "";
@ -197,7 +198,7 @@ typedef struct{
double value; double value;
String svalue; String svalue;
String unit; String unit;
} FormatedData; } FormattedData;
// Formatter for boat values // Formatter for boat values
FormatedData formatValue(GwApi::BoatValue *value, CommonData &commondata); FormattedData formatValue(GwApi::BoatValue *value, CommonData &commondata);

15
lib/obp60task/config.json
View File

@ -1117,6 +1117,21 @@
"obp60":"true" "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", "name": "backlight",
"label": "Backlight Mode", "label": "Backlight Mode",

15
lib/obp60task/config_obp40.json
View File

@ -1129,6 +1129,21 @@
"obp40": "true" "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", "name": "backlight",
"label": "Backlight Mode", "label": "Backlight Mode",

289
lib/obp60task/gen_set.py
View File

@ -1,132 +1,179 @@
#!/usr/bin/env python3 #!/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 import json
# List of all pages and the number of parameters they expect. __version__ = "0.2"
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,
"WindPlot": 0,
"WindRose": 0,
"WindRoseFlex": 6,
}
# No changes needed beyond this point def detect_pages(filename):
# max number of pages supported by OBP60 # returns a dictionary with page name and the number of gui fields
no_of_pages = 10 pagefiles = []
# Default selection for each page with open(filename, 'r') as fh:
default_pages = [ pattern = r'extern PageDescription\s*register(Page[^;\s]*)'
"Voltage", for line in fh:
"WindRose", if "extern PageDescription" in line:
"OneValue", match = re.search(pattern, line)
"TwoValues", if match:
"ThreeValues", pagefiles.append(match.group(1))
"FourValues", try:
"FourValues2", pagefiles.remove('PageSystem')
"Clock", except ValueError:
"RollPitch", pass
"Battery2", pagedata = {}
] for pf in pagefiles:
numbers = [ filename = pf + ".cpp"
"one", with open(filename, 'r') as fh:
"two", content = fh.read()
"three", pattern = r'PageDescription\s*?register' + pf + r'\s*\(\s*"([^"]+)".*?\n\s*(\d+)'
"four", match = re.search(pattern, content, re.DOTALL)
"five", if match:
"six", pagedata[match.group(1)] = int(match.group(2))
"seven", return pagedata
"eight",
"nine",
"ten",
]
pages = sorted(no_of_fields_per_page.keys())
max_no_of_fields_per_page = max(no_of_fields_per_page.values())
output = [] def get_default_page(pageno):
# Default selection for each page
default_pages = (
"Voltage",
"WindRose",
"OneValue",
"TwoValues",
"ThreeValues",
"FourValues",
"FourValues2",
"Clock",
"RollPitch",
"Battery2"
)
if pageno > len(default_pages):
return "OneValue"
return default_pages[pageno - 1]
for page_no in range(1, no_of_pages + 1): def number_to_text(number):
page_data = { if number < 0 or number > 99:
"name": f"page{page_no}type", raise ValueError("Only numbers from 0 to 99 are allowed.")
"label": "Type", numbers = ("zero", "one", "two", "three", "four", "five", "six", "seven",
"type": "list", "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen",
"default": default_pages[page_no - 1], "fifteen", "sixteen", "seventeen", "eighteen", "nineteen")
"description": f"Type of page for page {page_no}", tens = ("", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy",
"list": pages, "eighty", "ninety")
"category": f"OBP60 Page {page_no}", if number < 20:
"capabilities": {"obp60": "true"}, return numbers[number]
"condition": [{"visiblePages": vp} for vp in range(page_no, no_of_pages + 1)], else:
#"fields": [], q, r = divmod(number, 10)
} return tens[q] + numbers[r]
output.append(page_data)
for field_no in range(1, max_no_of_fields_per_page + 1): def create_json(device, no_of_pages, pagedata):
field_data = {
"name": f"page{page_no}value{field_no}", pages = sorted(pagedata.keys())
"label": f"Field {field_no}", max_no_of_fields_per_page = max(pagedata.values())
"type": "boatData",
"default": "", output = []
"description": f"The display for field {numbers[field_no - 1]}",
"category": f"OBP60 Page {page_no}", for page_no in range(1, no_of_pages + 1):
"capabilities": {"obp60": "true"}, page_data = {
"condition": [ "name": f"page{page_no}type",
{f"page{page_no}type": page} "label": "Type",
for page in pages "type": "list",
if no_of_fields_per_page[page] >= field_no "default": get_default_page(page_no),
], "description": f"Type of page for page {page_no}",
"list": pages,
"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": [],
} }
output.append(field_data) output.append(page_data)
fluid_data ={ for field_no in range(1, max_no_of_fields_per_page + 1):
"name": f"page{page_no}fluid", field_data = {
"label": "Fluid type", "name": f"page{page_no}value{field_no}",
"type": "list", "label": f"Field {field_no}",
"default": "0", "type": "boatData",
"list": [ "default": "",
{"l":"Fuel (0)","v":"0"}, "description": "The display for field {}".format(number_to_text(field_no)),
{"l":"Water (1)","v":"1"}, "category": f"{device.upper()} Page {page_no}",
{"l":"Gray Water (2)","v":"2"}, "capabilities": {device.lower(): "true"},
{"l":"Live Well (3)","v":"3"}, "condition": [
{"l":"Oil (4)","v":"4"}, {f"page{page_no}type": page}
{"l":"Black Water (5)","v":"5"}, for page in pages
{"l":"Fuel Gasoline (6)","v":"6"} if pagedata[page] >= field_no
], ],
"description": "Fluid type in tank", }
"category": f"OBP60 Page {page_no}", output.append(field_data)
"capabilities": {
"obp60":"true"
},
"condition":[{f"page{page_no}type":"Fluid"}]
}
output.append(fluid_data)
json_output = json.dumps(output, indent=4) fluid_data ={
# print omitting first and last line containing [ ] of JSON array "name": f"page{page_no}fluid",
#print(json_output[1:-1]) "label": "Fluid type",
# print omitting first line containing [ of JSON array "type": "list",
print(json_output[1:]) "default": "0",
# print(",") "list": [
{"l":"Fuel (0)","v":"0"},
{"l":"Water (1)","v":"1"},
{"l":"Gray Water (2)","v":"2"},
{"l":"Live Well (3)","v":"3"},
{"l":"Oil (4)","v":"4"},
{"l":"Black Water (5)","v":"5"},
{"l":"Fuel Gasoline (6)","v":"6"}
],
"description": "Fluid type in tank",
"category": f"{device.upper()} Page {page_no}",
"capabilities": {
device.lower(): "true"
},
"condition":[{f"page{page_no}type":"Fluid"}]
}
output.append(fluid_data)
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:])

12
lib/obp60task/index.js Normal file
View File

@ -0,0 +1,12 @@
(function(){
const api=window.esp32nmea2k;
if (! api) return;
const tabName="OBP60";
api.registerListener((id, data) => {
// if (!data.testboard) return; //do nothing if we are not active
let page = api.addTabPage(tabName, "OBP60");
api.addEl('button', '', page, 'Screenshot').addEventListener('click', function (ev) {
window.open('/api/user/OBP60Task/screenshot', 'screenshot');
})
}, api.EVENTS.init);
})();

91
lib/obp60task/obp60task.cpp
View File

@ -18,8 +18,6 @@
#ifdef BOARD_OBP40S3 #ifdef BOARD_OBP40S3
#include "driver/rtc_io.h" // Needs for weakup from deep sleep #include "driver/rtc_io.h" // Needs for weakup from deep sleep
#include <FS.h> // SD-Card access
#include <SD.h>
#include <SPI.h> #include <SPI.h>
#endif #endif
@ -34,7 +32,6 @@
#include "OBP60QRWiFi.h" // Functions lib for WiFi QR code #include "OBP60QRWiFi.h" // Functions lib for WiFi QR code
#include "OBPSensorTask.h" // Functions lib for sensor data #include "OBPSensorTask.h" // Functions lib for sensor data
// Global vars // Global vars
bool initComplete = false; // Initialization complete bool initComplete = false; // Initialization complete
int taskRunCounter = 0; // Task couter for loop section int taskRunCounter = 0; // Task couter for loop section
@ -47,63 +44,23 @@ void OBP60Init(GwApi *api){
GwConfigHandler *config = api->getConfig(); GwConfigHandler *config = api->getConfig();
// Set a new device name and hidden the original name in the main config // Set a new device name and hidden the original name in the main config
String devicename = api->getConfig()->getConfigItem(api->getConfig()->deviceName,true)->asString(); String devicename = config->getConfigItem(config->deviceName, true)->asString();
api->getConfig()->setValue(GwConfigDefinitions::systemName, devicename, GwConfigInterface::ConfigType::HIDDEN); config->setValue(GwConfigDefinitions::systemName, devicename, GwConfigInterface::ConfigType::HIDDEN);
logger->prefix = devicename + ":";
logger->logDebug(GwLog::LOG,"obp60init running");
api->getLogger()->logDebug(GwLog::LOG,"obp60init running");
// Check I2C devices // 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 // Init hardware
hardwareInit(api); hardwareInit(api);
// Init power rail 5.0V #ifdef BOARD_OBP40S3
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);
}
}
// Deep sleep wakeup configuration // Deep sleep wakeup configuration
esp_sleep_enable_ext0_wakeup(OBP_WAKEWUP_PIN, 0); // 1 = High, 0 = Low esp_sleep_enable_ext0_wakeup(OBP_WAKEWUP_PIN, 0); // 1 = High, 0 = Low
rtc_gpio_pullup_en(OBP_WAKEWUP_PIN); // Activate pullup resistor rtc_gpio_pullup_en(OBP_WAKEWUP_PIN); // Activate pullup resistor
@ -112,7 +69,7 @@ void OBP60Init(GwApi *api){
// Settings for e-paper display // Settings for e-paper display
String fastrefresh = api->getConfig()->getConfigItem(api->getConfig()->fastRefresh,true)->asString(); 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 #ifdef DISPLAY_GDEY042T81
if(fastrefresh == "true"){ if(fastrefresh == "true"){
static const bool useFastFullUpdate = true; // Enable fast full display update only for GDEY042T81 static const bool useFastFullUpdate = true; // Enable fast full display update only for GDEY042T81
@ -131,11 +88,11 @@ void OBP60Init(GwApi *api){
// Get CPU speed // Get CPU speed
int freq = getCpuFrequencyMhz(); 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 // Settings for backlight
String backlightMode = api->getConfig()->getConfigItem(api->getConfig()->backlight,true)->asString(); 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()); uint brightness = uint(api->getConfig()->getConfigItem(api->getConfig()->blBrightness,true)->asInt());
String backlightColor = api->getConfig()->getConfigItem(api->getConfig()->blColor,true)->asString(); String backlightColor = api->getConfig()->getConfigItem(api->getConfig()->blColor,true)->asString();
if(String(backlightMode) == "On"){ if(String(backlightMode) == "On"){
@ -150,7 +107,7 @@ void OBP60Init(GwApi *api){
// Settings flash LED mode // Settings flash LED mode
String ledMode = api->getConfig()->getConfigItem(api->getConfig()->flashLED,true)->asString(); 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"){ if(String(ledMode) == "Off"){
setBlinkingLED(false); setBlinkingLED(false);
} }
@ -282,7 +239,7 @@ void registerAllPages(PageList &list){
extern PageDescription registerPageWindRose; extern PageDescription registerPageWindRose;
list.add(&registerPageWindRose); list.add(&registerPageWindRose);
extern PageDescription registerPageWindRoseFlex; extern PageDescription registerPageWindRoseFlex;
list.add(&registerPageWindRoseFlex); // list.add(&registerPageWindRoseFlex);
extern PageDescription registerPageVoltage; extern PageDescription registerPageVoltage;
list.add(&registerPageVoltage); list.add(&registerPageVoltage);
extern PageDescription registerPageDST810; extern PageDescription registerPageDST810;
@ -718,7 +675,7 @@ void OBP60Task(GwApi *api){
double homelon = commonData.config->getString(commonData.config->homeLON).toDouble(); double homelon = commonData.config->getString(commonData.config->homeLON).toDouble();
bool homevalid = homelat >= -180.0 and homelat <= 180 and homelon >= -90.0 and homelon <= 90.0; bool homevalid = homelat >= -180.0 and homelat <= 180 and homelon >= -90.0 and homelon <= 90.0;
if (homevalid) { if (homevalid) {
LOG_DEBUG(GwLog::LOG, "Home location set to %f : %f", homelat, homelon); LOG_DEBUG(GwLog::LOG, "Home location set to lat=%f, lon=%f", homelat, homelon);
} else { } else {
LOG_DEBUG(GwLog::LOG, "No valid home location found"); LOG_DEBUG(GwLog::LOG, "No valid home location found");
} }
@ -752,6 +709,7 @@ void OBP60Task(GwApi *api){
//#################################################################################### //####################################################################################
bool systemPage = false; bool systemPage = false;
bool systemPageNew = false;
Page *currentPage; Page *currentPage;
while (true){ while (true){
delay(100); // Delay 100ms (loop time) delay(100); // Delay 100ms (loop time)
@ -804,6 +762,7 @@ void OBP60Task(GwApi *api){
systemPage = true; // System page is out of band systemPage = true; // System page is out of band
syspage->setupKeys(); syspage->setupKeys();
keyboardMessage = 0; keyboardMessage = 0;
systemPageNew = true;
} }
else { else {
currentPage = pages[pageNumber].page; currentPage = pages[pageNumber].page;
@ -900,6 +859,7 @@ void OBP60Task(GwApi *api){
else{ else{
getdisplay().fillScreen(commonData.fgcolor); // Clear display getdisplay().fillScreen(commonData.fgcolor); // Clear display
#ifdef DISPLAY_GDEY042T81 #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 getdisplay().init(115200, true, 2, false); // Init for Waveshare boards with "clever" reset circuit, 2ms reset pulse
#else #else
getdisplay().init(115200); // Init for normal displays getdisplay().init(115200); // Init for normal displays
@ -927,6 +887,7 @@ void OBP60Task(GwApi *api){
else{ else{
getdisplay().fillScreen(commonData.fgcolor); // Clear display getdisplay().fillScreen(commonData.fgcolor); // Clear display
#ifdef DISPLAY_GDEY042T81 #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 getdisplay().init(115200, true, 2, false); // Init for Waveshare boards with "clever" reset circuit, 2ms reset pulse
#else #else
getdisplay().init(115200); // Init for normal displays getdisplay().init(115200); // Init for normal displays
@ -951,6 +912,7 @@ void OBP60Task(GwApi *api){
else{ else{
getdisplay().fillScreen(commonData.fgcolor); // Clear display getdisplay().fillScreen(commonData.fgcolor); // Clear display
#ifdef DISPLAY_GDEY042T81 #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 getdisplay().init(115200, true, 2, false); // Init for Waveshare boards with "clever" reset circuit, 2ms reset pulse
#else #else
getdisplay().init(115200); // Init for normal displays getdisplay().init(115200); // Init for normal displays
@ -999,6 +961,10 @@ void OBP60Task(GwApi *api){
if (systemPage) { if (systemPage) {
displayFooter(commonData); displayFooter(commonData);
PageData sysparams; // empty PageData sysparams; // empty
if (systemPageNew) {
syspage->displayNew(sysparams);
systemPageNew = false;
}
syspage->displayPage(sysparams); syspage->displayPage(sysparams);
} }
else { else {
@ -1015,10 +981,11 @@ void OBP60Task(GwApi *api){
} }
else{ else{
if (lastPage != pageNumber){ if (lastPage != pageNumber){
if (hasFRAM) fram.write(FRAM_PAGE_NO, pageNumber); // remember page for device restart pages[lastPage].page->leavePage(pages[lastPage].parameters); // call page cleanup code
if (hasFRAM) fram.write(FRAM_PAGE_NO, pageNumber); // remember new page for device restart
currentPage->setupKeys(); currentPage->setupKeys();
currentPage->displayNew(pages[pageNumber].parameters); currentPage->displayNew(pages[pageNumber].parameters);
lastPage=pageNumber; lastPage = pageNumber;
} }
//call the page code //call the page code
LOG_DEBUG(GwLog::DEBUG,"calling page %d",pageNumber); LOG_DEBUG(GwLog::DEBUG,"calling page %d",pageNumber);