seba/obd2_gauge
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: seba:d614ea633a8dadf014db0a1bc907c9ae29f1e64e
Branches Tags
seba:main
..
compare: seba:4c5967d3c5fe5cedd0c0ca9abaad6eb64a04ce31
Branches Tags
seba:main

No commits in common. "d614ea633a8dadf014db0a1bc907c9ae29f1e64e" and "4c5967d3c5fe5cedd0c0ca9abaad6eb64a04ce31" have entirely different histories.
d614ea633a ... 4c5967d3c5

11 changed files with 579 additions and 2729 deletions
Show stats Expand all files Collapse all files

2
sketch/obd2_gauge/DSEG7_Modern_BoldItalic_44.h
View file

@ -1,5 +1,3 @@
#pragma once
#include <pgmspace.h>
const uint8_t DSEG7_Modern_BoldItalic_44[] PROGMEM = {
0x00, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x2C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x2C,

490
sketch/obd2_gauge/cluster_screen.h
View file

@ -1,490 +0,0 @@
#pragma once
#include <Arduino.h>
#include <TFT_eSPI.h>
#include "gps_module.h"
#include "DSEG7_Modern_BoldItalic_34.h"
#include "DSEG7_Modern_BoldItalic_44.h"
#include "rainbow_text.h"
extern TFT_eSPI tft;
extern uint16_t getThemePrimaryColor();
extern uint16_t getThemeAccentColor();
extern uint16_t getThemeBgColor();
extern bool isRainbowTheme();
extern bool isYapaTheme();
extern int8_t currentScreenPage;
extern int8_t fullScreenCell;
extern float currentRpm;
extern float last_valid_data[];
extern float tempEngineCoolant;
extern void drawPidIcon(int x, int y, const String &pidStr);
extern void drawPidIconToSprite(TFT_eSprite &s, int ix, int iy, const String &pidStr, int y_slice, int slice_h, int global_y);
extern void draw7SegDegreeC(TFT_eSPI &dst, int bx, int by, uint16_t color, uint16_t bgCol, bool rainbow);
// Data extractors
inline float getClusterRpmVal() {
if (currentRpm > 0.0f) return currentRpm;
if (last_valid_data[2] > 0.0f) return last_valid_data[2];
return 0.0f;
}
inline float getClusterSpeedVal() {
if (isGpsSpeedValid()) return gpsSpeedKmph;
if (last_valid_data[1] >= 0.0f) return last_valid_data[1];
return 0.0f;
}
inline bool isClusterSpeedFromGps() {
return isGpsSpeedValid();
}
inline float getClusterCoolantVal() {
if (last_valid_data[0] > -900.0f) return last_valid_data[0];
if (tempEngineCoolant > -900.0f) return tempEngineCoolant;
return -999.0f;
}
inline float getClusterVoltVal() {
if (last_valid_data[3] > 0.0f) return last_valid_data[3];
return -999.0f;
}
// Caching variables for zero-flicker live redraws
static int oldClusterRpm = -999;
static int oldClusterSpd = -999;
static int oldClusterCoolant = -999;
static float oldClusterVolt = -999.0f;
static bool oldClusterGpsLock = false;
static uint32_t lastClusterUpdate = 0;
inline void syncClusterTrackers() {
oldClusterRpm = (int)round(getClusterRpmVal());
oldClusterSpd = (int)round(getClusterSpeedVal());
float c = getClusterCoolantVal();
oldClusterCoolant = (c > -900.0f) ? (int)round(c) : -999;
oldClusterVolt = getClusterVoltVal();
oldClusterGpsLock = isClusterSpeedFromGps();
lastClusterUpdate = millis();
}
// Helper: draw 5 top pagination dots (page 4 active)
inline void drawClusterDots(int x_offset = 0) {
uint16_t actCol = isRainbowTheme() ? getRainbowScreenColor(188, 2) : (isYapaTheme() ? getYapaColor(4) : getThemePrimaryColor());
tft.fillCircle(132 + x_offset, 2, 2, 0x5AEB);
tft.fillCircle(146 + x_offset, 2, 2, 0x5AEB);
tft.fillCircle(160 + x_offset, 2, 2, 0x5AEB);
tft.fillCircle(174 + x_offset, 2, 2, 0x5AEB);
tft.fillCircle(188 + x_offset, 2, 2, actCol);
}
// Draw static framing of all 4 cards
inline void drawClusterBaseCards(int x_offset = 0) {
uint16_t cardBg = 0x10A2;
uint16_t border = 0x2945;
uint16_t priCol = getThemePrimaryColor();
uint16_t accCol = getThemeAccentColor();
uint16_t cRpm = isRainbowTheme() ? getRainbowScreenColor(20, 20) : (isYapaTheme() ? getYapaColor(0) : priCol);
uint16_t cSpd = isRainbowTheme() ? getRainbowScreenColor(20, 70) : (isYapaTheme() ? getYapaColor(1) : accCol);
uint16_t cCool = isRainbowTheme() ? getRainbowScreenColor(20, 150) : (isYapaTheme() ? getYapaColor(2) : priCol);
uint16_t cVolt = isRainbowTheme() ? getRainbowScreenColor(180, 150) : (isYapaTheme() ? getYapaColor(3) : accCol);
// 1. TACHOMETER CARD (x: 8, y: 10, w: 304, h: 42)
tft.fillRoundRect(8 + x_offset, 10, 304, 42, 5, cardBg);
tft.drawRoundRect(8 + x_offset, 10, 304, 42, 5, border);
tft.fillRoundRect(12 + x_offset, 14, 3, 34, 1, cRpm);
drawPidIcon(18 + x_offset, 14, "010C");
tft.setTextColor(0x8410, cardBg);
tft.drawString("RPM", 38 + x_offset, 16, 2);
// Tachometer background track (x: 76 to 216, w: 140, h: 12)
tft.fillRoundRect(76 + x_offset, 16, 140, 12, 3, 0x0841);
// RPM ticks
tft.drawString("1 2 3 4 5 6 7", 86 + x_offset, 31, 1);
// 2. SPEEDOMETER CARD (x: 8, y: 56, w: 304, h: 76)
tft.fillRoundRect(8 + x_offset, 56, 304, 76, 5, cardBg);
tft.drawRoundRect(8 + x_offset, 56, 304, 76, 5, border);
tft.fillRoundRect(12 + x_offset, 60, 3, 68, 1, cSpd);
drawPidIcon(18 + x_offset, 60, "010D");
tft.setTextColor(0x8410, cardBg);
tft.drawString("VELOCIDAD", 38 + x_offset, 62, 2);
// Background speed glow rail
tft.fillRoundRect(18 + x_offset, 124, 284, 3, 1, 0x0841);
// 3. COOLANT TEMP CARD (x: 8, y: 136, w: 148, h: 98)
tft.fillRoundRect(8 + x_offset, 136, 148, 98, 5, cardBg);
tft.drawRoundRect(8 + x_offset, 136, 148, 98, 5, border);
tft.fillRoundRect(12 + x_offset, 140, 3, 90, 1, cCool);
drawPidIcon(18 + x_offset, 140, "0105");
tft.setTextColor(0x8410, cardBg);
tft.drawString("REFRIG.", 38 + x_offset, 142, 2);
// Thermal bar rail (x: 18, y: 196, w: 128, h: 8)
tft.fillRoundRect(18 + x_offset, 196, 128, 8, 3, 0x0841);
tft.drawString("40`C", 18 + x_offset, 210, 1);
tft.drawString("120`C", 112 + x_offset, 210, 1);
// 4. BATTERY VOLTAGE CARD (x: 164, y: 136, w: 148, h: 98)
tft.fillRoundRect(164 + x_offset, 136, 148, 98, 5, cardBg);
tft.drawRoundRect(164 + x_offset, 136, 148, 98, 5, border);
tft.fillRoundRect(168 + x_offset, 140, 3, 90, 1, cVolt);
drawPidIcon(174 + x_offset, 140, "ATRV");
tft.setTextColor(0x8410, cardBg);
tft.drawString("BATERIA", 194 + x_offset, 142, 2);
// Voltage bar rail (x: 174, y: 196, w: 128, h: 8)
tft.fillRoundRect(174 + x_offset, 196, 128, 8, 3, 0x0841);
tft.drawString("10V", 174 + x_offset, 210, 1);
tft.drawString("16V", 272 + x_offset, 210, 1);
}
// Initial direct draw of Page 4
inline void drawClusterScreen(int x_offset = 0) {
tft.fillScreen(TFT_BLACK);
drawClusterDots(x_offset);
drawClusterBaseCards(x_offset);
// Force full initial value render
oldClusterRpm = -999;
oldClusterSpd = -999;
oldClusterCoolant = -999;
oldClusterVolt = -999.0f;
oldClusterGpsLock = false;
void updateClusterScreen(bool forceRedraw = false);
updateClusterScreen(true);
}
// Live zero-flicker non-blocking update of Page 4
inline void updateClusterScreen(bool forceRedraw) {
if (currentScreenPage != 4 || fullScreenCell != -1) return;
uint16_t cardBg = 0x10A2;
uint16_t priCol = getThemePrimaryColor();
uint16_t accCol = getThemeAccentColor();
uint16_t cRpm = isRainbowTheme() ? getRainbowScreenColor(20, 20) : (isYapaTheme() ? getYapaColor(0) : priCol);
uint16_t cSpd = isRainbowTheme() ? getRainbowScreenColor(20, 70) : (isYapaTheme() ? getYapaColor(1) : accCol);
uint16_t cCool = isRainbowTheme() ? getRainbowScreenColor(20, 150) : (isYapaTheme() ? getYapaColor(2) : priCol);
uint16_t cVolt = isRainbowTheme() ? getRainbowScreenColor(180, 150) : (isYapaTheme() ? getYapaColor(3) : accCol);
// -------------------------------------------------------------
// 1. TACHOMETER (RPM)
// -------------------------------------------------------------
float curRpmF = getClusterRpmVal();
int curRpm = (int)round(curRpmF);
if (forceRedraw || abs(curRpm - oldClusterRpm) >= 20 || (curRpm == 0 && oldClusterRpm != 0)) {
oldClusterRpm = curRpm;
// Erase numeric text area
tft.fillRect(222, 14, 84, 26, cardBg);
tft.setTextPadding(0);
if (curRpm > 0) {
uint16_t rpmCol = (curRpm >= 6000) ? TFT_RED : ((curRpm >= 4500) ? 0xFD60 : cRpm);
tft.setTextColor(rpmCol, cardBg);
String rpmStr = String(curRpm);
tft.drawRightString(rpmStr, 302, 16, 4);
} else {
tft.setTextColor(0x632C, cardBg);
tft.drawRightString("---", 302, 16, 4);
}
// Segmented Tachometer Bar (12 segments between x: 78 and 214)
// 0 to 7000 RPM -> ~583 RPM per segment
int activeSegs = map(constrain(curRpm, 0, 7000), 0, 7000, 0, 12);
for (int s = 0; s < 12; s++) {
int sx = 78 + s * 11;
uint16_t segCol;
if (s < activeSegs) {
if (s >= 10) segCol = TFT_RED;
else if (s >= 8) segCol = 0xFD60;
else segCol = isRainbowTheme() ? getRainbowScreenColor(sx, 20) : cRpm;
} else {
segCol = 0x0841; // inactive dark track
}
tft.fillRect(sx, 18, 9, 8, segCol);
}
}
// -------------------------------------------------------------
// 2. SPEEDOMETER (VELOCIDAD)
// -------------------------------------------------------------
float curSpdF = getClusterSpeedVal();
int curSpd = (int)round(curSpdF);
bool isGps = isClusterSpeedFromGps();
if (forceRedraw || curSpd != oldClusterSpd || isGps != oldClusterGpsLock) {
oldClusterSpd = curSpd;
oldClusterGpsLock = isGps;
// Source Pill (GPS / OBD)
tft.fillRect(116, 61, 46, 14, cardBg);
if (isGps) {
tft.fillRoundRect(116, 61, 42, 14, 3, 0x0254);
tft.setTextColor(0x07FF, 0x0254);
tft.drawString("GPS", 125, 63, 1);
} else {
tft.fillRoundRect(116, 61, 42, 14, 3, 0x18C3);
tft.setTextColor(0x8410, 0x18C3);
tft.drawString("OBD", 125, 63, 1);
}
// Giant Speed Display
tft.fillRect(166, 60, 138, 56, cardBg);
String spdStr = String(curSpd);
tft.loadFont(DSEG7_Modern_BoldItalic_44);
uint16_t spdCol = isRainbowTheme() ? getRainbowScreenColor(210, 80) : cSpd;
tft.setTextColor(spdCol, cardBg);
tft.drawRightString(spdStr, 248, 64, 1);
tft.unloadFont();
// Unit "km/h"
tft.setTextColor(0xBDD7, cardBg);
tft.drawString("km/h", 254, 88, 2);
// Dynamic Bottom Speed Rail (w = 284)
int fillSpdW = map(constrain(curSpd, 0, 200), 0, 200, 0, 284);
tft.fillRect(18, 124, 284, 3, 0x0841);
if (fillSpdW > 0) {
if (isRainbowTheme()) {
for (int bx = 0; bx < fillSpdW; bx++) {
tft.drawFastVLine(18 + bx, 124, 3, getRainbowScreenColor(18 + bx, 124));
}
} else {
tft.fillRect(18, 124, fillSpdW, 3, cSpd);
}
}
}
// -------------------------------------------------------------
// 3. COOLANT TEMP (REFRIGERANTE)
// -------------------------------------------------------------
float curCoolF = getClusterCoolantVal();
int curCool = (curCoolF > -900.0f) ? (int)round(curCoolF) : -999;
if (forceRedraw || curCool != oldClusterCoolant) {
oldClusterCoolant = curCool;
tft.fillRect(20, 158, 130, 36, cardBg);
if (curCool > -900) {
uint16_t coolCol = (curCool >= 105) ? TFT_RED : ((curCool < 70) ? 0x05BF : cCool);
tft.setTextColor(coolCol, cardBg);
String valStr = String(curCool);
tft.loadFont(DSEG7_Modern_BoldItalic_34);
tft.drawRightString(valStr, 102, 160, 1);
tft.unloadFont();
draw7SegDegreeC(tft, 106, 164, coolCol, cardBg, isRainbowTheme());
// Progress bar (40 to 120 °C)
int barW = map(constrain(curCool, 40, 120), 40, 120, 0, 128);
tft.fillRect(18, 196, 128, 8, 0x0841);
if (barW > 0) {
tft.fillRoundRect(18, 196, barW, 8, 2, coolCol);
}
} else {
tft.setTextColor(0x632C, cardBg);
tft.drawString("---", 60, 164, 4);
tft.fillRect(18, 196, 128, 8, 0x0841);
}
}
// -------------------------------------------------------------
// 4. BATTERY VOLTAGE (BATERÍA)
// -------------------------------------------------------------
float curVolt = getClusterVoltVal();
if (forceRedraw || abs(curVolt - oldClusterVolt) >= 0.08f) {
oldClusterVolt = curVolt;
tft.fillRect(174, 158, 130, 36, cardBg);
if (curVolt > 0.0f) {
uint16_t voltCol = (curVolt < 11.8f || curVolt > 15.0f) ? TFT_RED : ((curVolt >= 13.5f) ? 0x07E0 : cVolt);
String voltStr = String(curVolt, 1);
tft.loadFont(DSEG7_Modern_BoldItalic_34);
tft.setTextColor(voltCol, cardBg);
tft.drawRightString(voltStr, 268, 160, 1);
tft.unloadFont();
tft.setTextColor(0xBDD7, cardBg);
tft.drawString("V", 274, 172, 2);
// Voltage bar (10.0 to 16.0 V)
int vBarW = map(constrain((int)(curVolt * 10), 100, 160), 100, 160, 0, 128);
tft.fillRect(174, 196, 128, 8, 0x0841);
if (vBarW > 0) {
tft.fillRoundRect(174, 196, vBarW, 8, 2, voltCol);
}
} else {
tft.setTextColor(0x632C, cardBg);
tft.drawString("---", 216, 164, 4);
tft.fillRect(174, 196, 128, 8, 0x0841);
}
}
}
// Render Page 4 slice-by-slice into sprite (for double-buffered transitions)
inline void renderPage4ToSprite(TFT_eSprite &s, int x_offset, int y_slice, int slice_h) {
uint16_t cardBg = 0x10A2;
uint16_t border = 0x2945;
uint16_t priCol = getThemePrimaryColor();
uint16_t accCol = getThemeAccentColor();
uint16_t cRpm = isRainbowTheme() ? getRainbowScreenColor(20, 20) : (isYapaTheme() ? getYapaColor(0) : priCol);
uint16_t cSpd = isRainbowTheme() ? getRainbowScreenColor(20, 70) : (isYapaTheme() ? getYapaColor(1) : accCol);
uint16_t cCool = isRainbowTheme() ? getRainbowScreenColor(20, 150) : (isYapaTheme() ? getYapaColor(2) : priCol);
uint16_t cVolt = isRainbowTheme() ? getRainbowScreenColor(180, 150) : (isYapaTheme() ? getYapaColor(3) : accCol);
// Pagination dots on top slice (page 4 active)
if (y_slice == 0) {
uint16_t actCol = isRainbowTheme() ? getRainbowScreenColor(188, 2) : (isYapaTheme() ? getYapaColor(4) : priCol);
s.fillCircle(132, 2, 2, 0x5AEB);
s.fillCircle(146, 2, 2, 0x5AEB);
s.fillCircle(160, 2, 2, 0x5AEB);
s.fillCircle(174, 2, 2, 0x5AEB);
s.fillCircle(188, 2, 2, actCol);
}
// 1. TACHOMETER CARD (y: 10 to 52)
int c0Y = 10 - y_slice;
if (c0Y < slice_h && c0Y + 42 > 0) {
s.fillRoundRect(8, c0Y, 304, 42, 5, cardBg);
s.drawRoundRect(8, c0Y, 304, 42, 5, border);
s.fillRoundRect(12, c0Y + 4, 3, 34, 1, cRpm);
drawPidIconToSprite(s, 18, c0Y + 4, "010C", y_slice, slice_h, 10);
s.setTextColor(0x8410, cardBg);
s.drawString("RPM", 38, c0Y + 6, 2);
// Tachometer background rail
s.fillRoundRect(76, c0Y + 6, 140, 12, 3, 0x0841);
s.drawString("1 2 3 4 5 6 7", 86, c0Y + 21, 1);
float curRpmF = getClusterRpmVal();
int curRpm = (int)round(curRpmF);
if (curRpm > 0) {
uint16_t rpmCol = (curRpm >= 6000) ? TFT_RED : ((curRpm >= 4500) ? 0xFD60 : cRpm);
s.setTextColor(rpmCol, cardBg);
s.drawRightString(String(curRpm), 302, c0Y + 6, 4);
int activeSegs = map(constrain(curRpm, 0, 7000), 0, 7000, 0, 12);
for (int seg = 0; seg < 12; seg++) {
int sx = 78 + seg * 11;
uint16_t segCol = 0x0841;
if (seg < activeSegs) {
if (seg >= 10) segCol = TFT_RED;
else if (seg >= 8) segCol = 0xFD60;
else segCol = isRainbowTheme() ? getRainbowScreenColor(sx, 20) : cRpm;
}
s.fillRect(sx, c0Y + 8, 9, 8, segCol);
}
} else {
s.setTextColor(0x632C, cardBg);
s.drawRightString("---", 302, c0Y + 6, 4);
}
}
// 2. SPEEDOMETER CARD (y: 56 to 132)
int c1Y = 56 - y_slice;
if (c1Y < slice_h && c1Y + 76 > 0) {
s.fillRoundRect(8, c1Y, 304, 76, 5, cardBg);
s.drawRoundRect(8, c1Y, 304, 76, 5, border);
s.fillRoundRect(12, c1Y + 4, 3, 68, 1, cSpd);
drawPidIconToSprite(s, 18, c1Y + 4, "010D", y_slice, slice_h, 56);
s.setTextColor(0x8410, cardBg);
s.drawString("VELOCIDAD", 38, c1Y + 6, 2);
bool isGps = isClusterSpeedFromGps();
if (isGps) {
s.fillRoundRect(116, c1Y + 5, 42, 14, 3, 0x0254);
s.setTextColor(0x07FF, 0x0254);
s.drawString("GPS", 125, c1Y + 7, 1);
} else {
s.fillRoundRect(116, c1Y + 5, 42, 14, 3, 0x18C3);
s.setTextColor(0x8410, 0x18C3);
s.drawString("OBD", 125, c1Y + 7, 1);
}
int curSpd = (int)round(getClusterSpeedVal());
String spdStr = String(curSpd);
s.loadFont(DSEG7_Modern_BoldItalic_44);
uint16_t spdCol = isRainbowTheme() ? getRainbowScreenColor(210, 80) : cSpd;
s.setTextColor(spdCol, cardBg);
s.drawRightString(spdStr, 248, c1Y + 8, 1);
s.unloadFont();
s.setTextColor(0xBDD7, cardBg);
s.drawString("km/h", 254, c1Y + 32, 2);
int fillSpdW = map(constrain(curSpd, 0, 200), 0, 200, 0, 284);
s.fillRect(18, c1Y + 68, 284, 3, 0x0841);
if (fillSpdW > 0) {
s.fillRect(18, c1Y + 68, fillSpdW, 3, cSpd);
}
}
// 3. COOLANT TEMP CARD (y: 136 to 234)
int c2Y = 136 - y_slice;
if (c2Y < slice_h && c2Y + 98 > 0) {
s.fillRoundRect(8, c2Y, 148, 98, 5, cardBg);
s.drawRoundRect(8, c2Y, 148, 98, 5, border);
s.fillRoundRect(12, c2Y + 4, 3, 90, 1, cCool);
drawPidIconToSprite(s, 18, c2Y + 4, "0105", y_slice, slice_h, 136);
s.setTextColor(0x8410, cardBg);
s.drawString("REFRIG.", 38, c2Y + 6, 2);
s.fillRect(18, c2Y + 60, 128, 8, 0x0841);
s.drawString("40`C", 18, c2Y + 74, 1);
s.drawString("120`C", 112, c2Y + 74, 1);
float curCoolF = getClusterCoolantVal();
int curCool = (curCoolF > -900.0f) ? (int)round(curCoolF) : -999;
if (curCool > -900) {
uint16_t coolCol = (curCool >= 105) ? TFT_RED : ((curCool < 70) ? 0x05BF : cCool);
s.loadFont(DSEG7_Modern_BoldItalic_34);
s.setTextColor(coolCol, cardBg);
s.drawRightString(String(curCool), 102, c2Y + 24, 1);
s.unloadFont();
int barW = map(constrain(curCool, 40, 120), 40, 120, 0, 128);
if (barW > 0) {
s.fillRoundRect(18, c2Y + 60, barW, 8, 2, coolCol);
}
} else {
s.setTextColor(0x632C, cardBg);
s.drawString("---", 60, c2Y + 28, 4);
}
}
// 4. BATTERY VOLTAGE CARD (y: 136 to 234)
int c3Y = 136 - y_slice;
if (c3Y < slice_h && c3Y + 98 > 0) {
s.fillRoundRect(164, c3Y, 148, 98, 5, cardBg);
s.drawRoundRect(164, c3Y, 148, 98, 5, border);
s.fillRoundRect(168, c3Y + 4, 3, 90, 1, cVolt);
drawPidIconToSprite(s, 174, c3Y + 4, "ATRV", y_slice, slice_h, 136);
s.setTextColor(0x8410, cardBg);
s.drawString("BATERIA", 194, c3Y + 6, 2);
s.fillRect(174, c3Y + 60, 128, 8, 0x0841);
s.drawString("10V", 174, c3Y + 74, 1);
s.drawString("16V", 272, c3Y + 74, 1);
float curVolt = getClusterVoltVal();
if (curVolt > 0.0f) {
uint16_t voltCol = (curVolt < 11.8f || curVolt > 15.0f) ? TFT_RED : ((curVolt >= 13.5f) ? 0x07E0 : cVolt);
s.loadFont(DSEG7_Modern_BoldItalic_34);
s.setTextColor(voltCol, cardBg);
s.drawRightString(String(curVolt, 1), 268, c3Y + 24, 1);
s.unloadFont();
s.setTextColor(0xBDD7, cardBg);
s.drawString("V", 274, c3Y + 36, 2);
int vBarW = map(constrain((int)(curVolt * 10), 100, 160), 100, 160, 0, 128);
if (vBarW > 0) {
s.fillRoundRect(174, c3Y + 60, vBarW, 8, 2, voltCol);
}
} else {
s.setTextColor(0x632C, cardBg);
s.drawString("---", 216, c3Y + 28, 4);
}
}
}

1287
sketch/obd2_gauge/config.h
View file

File diff suppressed because it is too large Load diff

650
sketch/obd2_gauge/coords_font.h
View file

@ -1,650 +0,0 @@
#pragma once
#include <Arduino.h>
#include <TFT_eSPI.h>
#include "rainbow_text.h"
// High-definition 8-bit anti-aliased font data for GPS Navigation & Telemetry
// Generates zero heap fragmentation and provides smooth subpixel alpha blending
struct CoordsGlyphAA {
uint8_t w;
uint8_t h;
int8_t xOff;
int8_t yOff;
uint8_t xAdv;
uint16_t offset;
};
// Title Font (13.5pt Bold AA: ALTITUD, RUMBO / BRUJULA, SATELITES GPS, COORDENADAS) - 2583 bytes
static const uint8_t s_navTitleAlpha[2583] PROGMEM = {
0x00, 0x00, 0x00, 0x52, 0xFF, 0xFF, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAC, 0xFD, 0xF5,
0xC2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0xF7, 0xCA, 0xAF, 0xFE, 0x1D, 0x00, 0x00, 0x00, 0x00,
0x60, 0xFF, 0x7A, 0x60, 0xFF, 0x75, 0x00, 0x00, 0x00, 0x00, 0xBA, 0xFF, 0x27, 0x11, 0xFB, 0xCE,
0x00, 0x00, 0x00, 0x17, 0xFC, 0xD5, 0x00, 0x00, 0xBA, 0xFF, 0x28, 0x00, 0x00, 0x6E, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0x82, 0x00, 0x00, 0xC8, 0xFF, 0x94, 0x84, 0x84, 0x88, 0xFE, 0xDB, 0x00,
0x22, 0xFF, 0xDF, 0x00, 0x00, 0x00, 0x00, 0xC5, 0xFF, 0x35, 0x7B, 0xFF, 0x88, 0x00, 0x00, 0x00,
0x00, 0x6C, 0xFF, 0x8F, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0xFA, 0xE1, 0x96, 0x11, 0x00, 0x10, 0xFF,
0xFA, 0x80, 0x80, 0x87, 0xD7, 0xFF, 0xA9, 0x00, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x2D, 0xFF,
0xE0, 0x00, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x06, 0x72, 0xFF, 0xAA, 0x00, 0x10, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xBC, 0x10, 0x00, 0x10, 0xFF, 0xF9, 0x7C, 0x7C, 0x7F, 0xAA, 0xFE, 0xC4, 0x08,
0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xFF, 0x5B, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00,
0x00, 0xAC, 0xFF, 0x63, 0x10, 0xFF, 0xFA, 0x80, 0x80, 0x82, 0xA9, 0xFE, 0xF0, 0x1E, 0x10, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xE9, 0xB4, 0x34, 0x00, 0x00, 0x00, 0x41, 0xB7, 0xEE, 0xF8, 0xDF, 0x96,
0x1B, 0x00, 0x00, 0x5B, 0xFD, 0xFF, 0xC3, 0xA1, 0xD0, 0xFF, 0xE4, 0x17, 0x09, 0xEC, 0xFF, 0x5F,
0x00, 0x00, 0x00, 0x84, 0xD4, 0x4C, 0x44, 0xFF, 0xD5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x64, 0xFF, 0xA9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 0xFF, 0xAC, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x3E, 0xFF, 0xD9, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0xE4,
0xFF, 0x68, 0x00, 0x00, 0x00, 0x6B, 0xD3, 0x56, 0x00, 0x49, 0xFA, 0xFF, 0xC6, 0xA0, 0xC5, 0xFF,
0xEF, 0x29, 0x00, 0x00, 0x35, 0xAF, 0xEB, 0xFA, 0xE2, 0x9D, 0x21, 0x00, 0x10, 0xFF, 0xFF, 0xFF,
0xFC, 0xE8, 0xAD, 0x39, 0x00, 0x00, 0x10, 0xFF, 0xFA, 0x90, 0x97, 0xC3, 0xFF, 0xFC, 0x5C, 0x00,
0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x59, 0xFF, 0xF2, 0x11, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00,
0x00, 0xC0, 0xFF, 0x59, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x00, 0x8F, 0xFF, 0x7B, 0x10, 0xFF,
0xF4, 0x00, 0x00, 0x00, 0x00, 0x94, 0xFF, 0x74, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x00, 0xC7,
0xFF, 0x4D, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x5C, 0xFF, 0xE9, 0x07, 0x10, 0xFF, 0xFA, 0x90,
0x92, 0xBC, 0xFF, 0xFA, 0x4D, 0x00, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0xEC, 0xB2, 0x37, 0x00, 0x00,
0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x84, 0x10, 0xFF, 0xFA, 0x90, 0x90, 0x90, 0x90,
0x90, 0x4A, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xFF, 0xF4, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x18, 0x10, 0xFF, 0xFA,
0x90, 0x90, 0x90, 0x90, 0x90, 0x0D, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
0xFF, 0xF4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xFF, 0xFA, 0x90, 0x90, 0x90, 0x90, 0x90,
0x72, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xCC, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0x0C, 0x10, 0xFF, 0xFA, 0x90, 0x90, 0x90, 0x90, 0x90, 0x06, 0x10, 0xFF, 0xF4, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE0, 0x00, 0x10, 0xFF, 0xFA, 0x90, 0x90, 0x90, 0x90, 0x7E, 0x00,
0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xFF, 0xF4, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0xAF, 0xE9, 0xFA, 0xE6, 0xAB, 0x35, 0x00, 0x00, 0x00,
0x52, 0xFB, 0xFF, 0xC9, 0xA1, 0xC4, 0xFF, 0xF8, 0x3E, 0x00, 0x08, 0xE9, 0xFF, 0x6B, 0x00, 0x00,
0x00, 0x69, 0xD7, 0x68, 0x00, 0x43, 0xFF, 0xD8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x64, 0xFF, 0xAB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 0xFF, 0xAD, 0x00, 0x00,
0x2C, 0xFF, 0xFF, 0xFF, 0xFF, 0x04, 0x3F, 0xFF, 0xDC, 0x02, 0x00, 0x15, 0x7C, 0x7C, 0xE9, 0xFF,
0x04, 0x06, 0xE5, 0xFF, 0x72, 0x00, 0x00, 0x00, 0x09, 0xDF, 0xFF, 0x04, 0x00, 0x4C, 0xFA, 0xFF,
0xC9, 0x9E, 0xB5, 0xED, 0xFF, 0xC4, 0x01, 0x00, 0x00, 0x36, 0xAF, 0xEB, 0xFB, 0xE9, 0xB6, 0x5A,
0x03, 0x00, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x00, 0xD8, 0xFF, 0x2C, 0x10, 0xFF, 0xF4, 0x00,
0x00, 0x00, 0x00, 0xD8, 0xFF, 0x2C, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x00, 0xD8, 0xFF, 0x2C,
0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x00, 0xD8, 0xFF, 0x2C, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0x2C, 0x10, 0xFF, 0xFC, 0xAC, 0xAC, 0xAC, 0xAC, 0xF2, 0xFF, 0x2C, 0x10, 0xFF,
0xF4, 0x00, 0x00, 0x00, 0x00, 0xD8, 0xFF, 0x2C, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x00, 0xD8,
0xFF, 0x2C, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x00, 0xD8, 0xFF, 0x2C, 0x10, 0xFF, 0xF4, 0x00,
0x00, 0x00, 0x00, 0xD8, 0xFF, 0x2C, 0x10, 0xFF, 0xF4, 0x10, 0xFF, 0xF4, 0x10, 0xFF, 0xF4, 0x10,
0xFF, 0xF4, 0x10, 0xFF, 0xF4, 0x10, 0xFF, 0xF4, 0x10, 0xFF, 0xF4, 0x10, 0xFF, 0xF4, 0x10, 0xFF,
0xF4, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x18, 0xFF, 0xFF, 0xFF, 0xD4, 0x00, 0x00, 0x0D, 0x94, 0xA8,
0xFF, 0xD4, 0x00, 0x00, 0x00, 0x00, 0x30, 0xFF, 0xD4, 0x00, 0x00, 0x00, 0x00, 0x30, 0xFF, 0xD4,
0x00, 0x00, 0x00, 0x00, 0x30, 0xFF, 0xD4, 0x00, 0x00, 0x00, 0x00, 0x30, 0xFF, 0xD4, 0x00, 0x00,
0x00, 0x00, 0x30, 0xFF, 0xD2, 0x83, 0xE4, 0x60, 0x00, 0x4F, 0xFF, 0xB5, 0x56, 0xFF, 0xF0, 0x9F,
0xE5, 0xFF, 0x5D, 0x00, 0x70, 0xDB, 0xF7, 0xDB, 0x6F, 0x00, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00,
0x3A, 0xF4, 0xF1, 0x35, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x33, 0xF0, 0xF4, 0x3B, 0x00, 0x10, 0xFF,
0xF4, 0x00, 0x2C, 0xEC, 0xF6, 0x40, 0x00, 0x00, 0x10, 0xFF, 0xF4, 0x26, 0xE8, 0xF8, 0x46, 0x00,
0x00, 0x00, 0x10, 0xFF, 0xF9, 0xE3, 0xFF, 0xC6, 0x02, 0x00, 0x00, 0x00, 0x10, 0xFF, 0xFF, 0xDB,
0xCA, 0xFF, 0x82, 0x00, 0x00, 0x00, 0x10, 0xFF, 0xF8, 0x10, 0x1C, 0xEC, 0xFE, 0x49, 0x00, 0x00,
0x10, 0xFF, 0xF4, 0x00, 0x00, 0x49, 0xFE, 0xED, 0x1F, 0x00, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00,
0x86, 0xFF, 0xCB, 0x07, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x03, 0xC1, 0xFF, 0x99, 0x10, 0xFF,
0xF4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xFF, 0xF4, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xFF, 0xF4,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xFF, 0xFA, 0x90, 0x90, 0x90, 0x90, 0x90, 0x12, 0x10,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x20, 0x10, 0xFF, 0xFF, 0xCA, 0x00, 0x00, 0x00, 0x1B,
0xFF, 0xFF, 0xB8, 0x10, 0xFF, 0xFE, 0xFE, 0x1A, 0x00, 0x00, 0x68, 0xFE, 0xFF, 0xB8, 0x10, 0xFF,
0xD5, 0xFF, 0x68, 0x00, 0x00, 0xB5, 0xD6, 0xFF, 0xB8, 0x10, 0xFF, 0xB8, 0xDE, 0xB6, 0x00, 0x0A,
0xF7, 0x9A, 0xFF, 0xB8, 0x10, 0xFF, 0xBC, 0x95, 0xF8, 0x0C, 0x4F, 0xFF, 0x51, 0xFF, 0xB8, 0x10,
0xFF, 0xBC, 0x46, 0xFF, 0x54, 0x9C, 0xED, 0x14, 0xFF, 0xB8, 0x10, 0xFF, 0xBC, 0x05, 0xF0, 0x9B,
0xE4, 0xA2, 0x10, 0xFF, 0xB8, 0x10, 0xFF, 0xBC, 0x00, 0xA7, 0xF1, 0xFF, 0x52, 0x10, 0xFF, 0xB8,
0x10, 0xFF, 0xBC, 0x00, 0x58, 0xFF, 0xF7, 0x0B, 0x10, 0xFF, 0xB8, 0x10, 0xFF, 0xBC, 0x00, 0x0E,
0xF9, 0xB3, 0x00, 0x10, 0xFF, 0xB8, 0x10, 0xFF, 0xFF, 0x81, 0x00, 0x00, 0x00, 0xA0, 0xFF, 0x2C,
0x10, 0xFF, 0xFF, 0xF4, 0x19, 0x00, 0x00, 0xA0, 0xFF, 0x2C, 0x10, 0xFF, 0xE3, 0xFF, 0x9B, 0x00,
0x00, 0xA0, 0xFF, 0x2C, 0x10, 0xFF, 0xB5, 0xBC, 0xFC, 0x2B, 0x00, 0xA0, 0xFF, 0x2C, 0x10, 0xFF,
0xBB, 0x32, 0xFE, 0xB4, 0x00, 0xA0, 0xFF, 0x2C, 0x10, 0xFF, 0xBC, 0x00, 0xA6, 0xFF, 0x41, 0x9F,
0xFF, 0x2C, 0x10, 0xFF, 0xBC, 0x00, 0x21, 0xF9, 0xCC, 0x96, 0xFF, 0x2C, 0x10, 0xFF, 0xBC, 0x00,
0x00, 0x90, 0xFF, 0xDB, 0xFF, 0x2C, 0x10, 0xFF, 0xBC, 0x00, 0x00, 0x14, 0xF1, 0xFF, 0xFF, 0x2C,
0x10, 0xFF, 0xBC, 0x00, 0x00, 0x00, 0x7A, 0xFF, 0xFF, 0x2C, 0x00, 0x00, 0x34, 0xAD, 0xEA, 0xFA,
0xE4, 0x9F, 0x22, 0x00, 0x00, 0x00, 0x49, 0xF9, 0xFF, 0xC9, 0xA4, 0xD5, 0xFF, 0xEE, 0x2D, 0x00,
0x06, 0xE5, 0xFF, 0x6E, 0x00, 0x00, 0x02, 0x96, 0xFF, 0xC8, 0x00, 0x41, 0xFF, 0xD9, 0x01, 0x00,
0x00, 0x00, 0x0D, 0xF4, 0xFF, 0x1F, 0x63, 0xFF, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCF, 0xFF,
0x42, 0x63, 0xFF, 0xAD, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD2, 0xFF, 0x3D, 0x3C, 0xFF, 0xDE, 0x02,
0x00, 0x00, 0x00, 0x0C, 0xF4, 0xFE, 0x18, 0x04, 0xE0, 0xFF, 0x78, 0x00, 0x00, 0x01, 0x91, 0xFF,
0xB8, 0x00, 0x00, 0x44, 0xF8, 0xFF, 0xCB, 0xA4, 0xD3, 0xFF, 0xE8, 0x22, 0x00, 0x00, 0x00, 0x30,
0xAC, 0xEB, 0xF9, 0xE0, 0x95, 0x19, 0x00, 0x00, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0xF7, 0xD6, 0x72,
0x01, 0x10, 0xFF, 0xFA, 0x90, 0x90, 0x9F, 0xEE, 0xFF, 0x73, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00,
0x4B, 0xFF, 0xC6, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x4F, 0xFF, 0xC7, 0x10, 0xFF, 0xFA, 0x8C,
0x8C, 0x9A, 0xEE, 0xFF, 0x67, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0xFB, 0xD8, 0x6D, 0x00, 0x10, 0xFF,
0xF4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x32, 0xAC, 0xE9, 0xFA, 0xE4, 0x9E, 0x21, 0x00, 0x00, 0x00, 0x47, 0xF8,
0xFF, 0xCA, 0xA4, 0xD5, 0xFF, 0xED, 0x2A, 0x00, 0x05, 0xE3, 0xFF, 0x71, 0x00, 0x00, 0x02, 0x97,
0xFF, 0xC3, 0x00, 0x3F, 0xFF, 0xDB, 0x01, 0x00, 0x00, 0x00, 0x0E, 0xF5, 0xFF, 0x1B, 0x63, 0xFF,
0xAC, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD1, 0xFF, 0x41, 0x64, 0xFF, 0xAC, 0x00, 0x00, 0x00, 0x00,
0x00, 0xD0, 0xFF, 0x3C, 0x40, 0xFF, 0xDB, 0x01, 0x00, 0x00, 0x00, 0x09, 0xF3, 0xFF, 0x19, 0x05,
0xE7, 0xFF, 0x69, 0x00, 0x00, 0x00, 0x84, 0xFF, 0xBF, 0x00, 0x00, 0x50, 0xFC, 0xFF, 0xB7, 0x90,
0xC1, 0xFF, 0xF1, 0x33, 0x00, 0x00, 0x00, 0x3F, 0xBB, 0xF5, 0xFF, 0xFC, 0xB2, 0x30, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x25, 0xFF, 0xE6, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xB5, 0xFF, 0xCB, 0x86, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0xB2, 0xF4, 0xE9, 0x4C,
0x00, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xE8, 0xAF, 0x2A, 0x00, 0x10, 0xFF, 0xFA, 0x90, 0x90,
0x93, 0xC3, 0xFF, 0xE5, 0x0E, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x00, 0xCE, 0xFF, 0x44, 0x10,
0xFF, 0xF4, 0x00, 0x00, 0x00, 0x01, 0xD2, 0xFF, 0x3E, 0x10, 0xFF, 0xFA, 0x90, 0x90, 0x92, 0xC5,
0xFF, 0xCB, 0x02, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x9D, 0x0F, 0x00, 0x10, 0xFF, 0xF4,
0x00, 0x00, 0x69, 0xFF, 0xBE, 0x00, 0x00, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x03, 0xD6, 0xFF, 0x57,
0x00, 0x10, 0xFF, 0xF4, 0x00, 0x00, 0x00, 0x4B, 0xFF, 0xE3, 0x0B, 0x10, 0xFF, 0xF4, 0x00, 0x00,
0x00, 0x00, 0xBB, 0xFF, 0x87, 0x00, 0x18, 0x97, 0xDF, 0xF8, 0xEB, 0xBB, 0x3B, 0x00, 0x00, 0xC9,
0xFF, 0xA7, 0x73, 0x9D, 0xFE, 0xF3, 0x1D, 0x14, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x9A, 0xDC, 0x4F,
0x09, 0xF8, 0xFE, 0x76, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6C, 0xFB, 0xFF, 0xFF, 0xDD, 0x9B,
0x35, 0x00, 0x00, 0x00, 0x1E, 0x6E, 0xAC, 0xE9, 0xFF, 0xFD, 0x49, 0x00, 0x00, 0x00, 0x00, 0x00,
0x02, 0x8D, 0xFF, 0xB2, 0x56, 0xDA, 0x98, 0x00, 0x00, 0x00, 0x47, 0xFF, 0xBE, 0x1D, 0xEC, 0xFF,
0xBA, 0x8A, 0x9A, 0xEC, 0xFF, 0x65, 0x00, 0x28, 0xA3, 0xE2, 0xF9, 0xEA, 0xC2, 0x58, 0x00, 0xD8,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x68, 0x79, 0x90, 0x90, 0xE2, 0xFF, 0xAF, 0x90, 0x90,
0x3A, 0x00, 0x00, 0x00, 0xBC, 0xFF, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xBC, 0xFF, 0x48,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xBC, 0xFF, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xBC,
0xFF, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xBC, 0xFF, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0xBC, 0xFF, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xBC, 0xFF, 0x48, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0xBC, 0xFF, 0x48, 0x00, 0x00, 0x00, 0x28, 0xFF, 0xDC, 0x00, 0x00, 0x00, 0x00,
0xC4, 0xFF, 0x40, 0x28, 0xFF, 0xDC, 0x00, 0x00, 0x00, 0x00, 0xC4, 0xFF, 0x40, 0x28, 0xFF, 0xDC,
0x00, 0x00, 0x00, 0x00, 0xC4, 0xFF, 0x40, 0x28, 0xFF, 0xDC, 0x00, 0x00, 0x00, 0x00, 0xC4, 0xFF,
0x40, 0x28, 0xFF, 0xDC, 0x00, 0x00, 0x00, 0x00, 0xC4, 0xFF, 0x40, 0x28, 0xFF, 0xDC, 0x00, 0x00,
0x00, 0x00, 0xC4, 0xFF, 0x40, 0x21, 0xFF, 0xEB, 0x00, 0x00, 0x00, 0x00, 0xD7, 0xFF, 0x36, 0x05,
0xF2, 0xFF, 0x3E, 0x00, 0x00, 0x34, 0xFD, 0xF7, 0x0C, 0x00, 0x81, 0xFF, 0xF6, 0xA8, 0xA9, 0xF5,
0xFF, 0x7D, 0x00, 0x00, 0x01, 0x5D, 0xCA, 0xF0, 0xF6, 0xCB, 0x61, 0x00, 0x00, 0xBB, 0xFF, 0x5A,
0x00, 0x00, 0x00, 0x09, 0xF5, 0xFC, 0x16, 0x5F, 0xFF, 0xA9, 0x00, 0x00, 0x00, 0x4D, 0xFF, 0xB7,
0x00, 0x0D, 0xF6, 0xF1, 0x06, 0x00, 0x00, 0x9B, 0xFF, 0x5C, 0x00, 0x00, 0xA9, 0xFF, 0x46, 0x00,
0x01, 0xE7, 0xF5, 0x0C, 0x00, 0x00, 0x4E, 0xFF, 0x95, 0x00, 0x37, 0xFF, 0xA6, 0x00, 0x00, 0x00,
0x05, 0xEC, 0xE2, 0x00, 0x85, 0xFF, 0x4C, 0x00, 0x00, 0x00, 0x00, 0x97, 0xFF, 0x30, 0xD1, 0xEC,
0x05, 0x00, 0x00, 0x00, 0x00, 0x3C, 0xFF, 0x8E, 0xFF, 0x96, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0xE0, 0xF7, 0xFF, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0xFF, 0xE0, 0x01, 0x00, 0x00,
0x00, 0xDD, 0xFF, 0x2A, 0x00, 0x00, 0x9D, 0xFF, 0xE0, 0x00, 0x00, 0x01, 0xF1, 0xFE, 0x14, 0x9D,
0xFF, 0x61, 0x00, 0x00, 0xD6, 0xFF, 0xFF, 0x1B, 0x00, 0x27, 0xFF, 0xD4, 0x00, 0x5D, 0xFF, 0x98,
0x00, 0x11, 0xFE, 0xD1, 0xFF, 0x55, 0x00, 0x5C, 0xFF, 0x94, 0x00, 0x1D, 0xFF, 0xCE, 0x00, 0x49,
0xFF, 0x6F, 0xFF, 0x8F, 0x00, 0x91, 0xFF, 0x55, 0x00, 0x00, 0xDE, 0xFB, 0x09, 0x81, 0xFF, 0x1B,
0xE8, 0xC9, 0x00, 0xC6, 0xFF, 0x16, 0x00, 0x00, 0x9F, 0xFF, 0x3C, 0xBA, 0xE2, 0x00, 0xB0, 0xFA,
0x0C, 0xF6, 0xD5, 0x00, 0x00, 0x00, 0x5F, 0xFF, 0x72, 0xEE, 0xA9, 0x00, 0x77, 0xFF, 0x65, 0xFF,
0x96, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xC5, 0xFF, 0x71, 0x00, 0x3E, 0xFF, 0xC7, 0xFF, 0x56, 0x00,
0x00, 0x00, 0x00, 0xE0, 0xFF, 0xFF, 0x38, 0x00, 0x0A, 0xFB, 0xFF, 0xFF, 0x17, 0x00, 0x00, 0x00,
0x00, 0xA0, 0xFF, 0xF9, 0x07, 0x00, 0x00, 0xCC, 0xFF, 0xD7, 0x00, 0x00, 0x00, 0x46, 0xFF, 0xD1,
0x03, 0x00, 0x00, 0x7E, 0xFF, 0xA0, 0x00, 0x00, 0xA1, 0xFF, 0x70, 0x00, 0x21, 0xF7, 0xED, 0x15,
0x00, 0x00, 0x12, 0xE9, 0xF1, 0x19, 0xB4, 0xFF, 0x65, 0x00, 0x00, 0x00, 0x00, 0x57, 0xFF, 0xD4,
0xFF, 0xC5, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xBE, 0xFF, 0xFF, 0x34, 0x00, 0x00, 0x00, 0x00,
0x00, 0x18, 0xEF, 0xFF, 0xFF, 0x7B, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xFF, 0x78, 0xF0, 0xF6,
0x20, 0x00, 0x00, 0x00, 0x4B, 0xFF, 0xC3, 0x01, 0x6D, 0xFF, 0xB2, 0x00, 0x00, 0x0C, 0xE1, 0xFB,
0x2D, 0x00, 0x03, 0xCE, 0xFF, 0x4E, 0x00, 0x8F, 0xFF, 0x8D, 0x00, 0x00, 0x00, 0x37, 0xFE, 0xDF,
0x0A, 0x7B, 0xFF, 0xA4, 0x00, 0x00, 0x00, 0x4B, 0xFF, 0xD0, 0x02, 0x08, 0xDF, 0xFE, 0x38, 0x00,
0x06, 0xDA, 0xFF, 0x40, 0x00, 0x00, 0x56, 0xFF, 0xC9, 0x01, 0x78, 0xFF, 0xAE, 0x00, 0x00, 0x00,
0x00, 0xC2, 0xFF, 0x77, 0xF3, 0xF9, 0x23, 0x00, 0x00, 0x00, 0x00, 0x32, 0xFD, 0xFF, 0xFF, 0x8A,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9D, 0xFF, 0xEA, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x54, 0xFF, 0xB0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0xFF, 0xB0, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x54, 0xFF, 0xB0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0xFF,
0xB0, 0x00, 0x00, 0x00, 0x00, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE0, 0x00, 0x09, 0x94,
0x94, 0x94, 0x94, 0xCD, 0xFF, 0xBC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0xEF, 0xEE, 0x1E, 0x00,
0x00, 0x00, 0x00, 0x05, 0xC8, 0xFF, 0x4F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8C, 0xFF, 0x91, 0x00,
0x00, 0x00, 0x00, 0x00, 0x4B, 0xFE, 0xCC, 0x06, 0x00, 0x00, 0x00, 0x00, 0x1C, 0xEC, 0xF1, 0x23,
0x00, 0x00, 0x00, 0x00, 0x03, 0xC3, 0xFF, 0x57, 0x00, 0x00, 0x00, 0x00, 0x00, 0x74, 0xFF, 0xEB,
0x94, 0x94, 0x94, 0x94, 0x94, 0x17, 0x94, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x28, 0x00,
0x03, 0xF6, 0xA6, 0x00, 0x2C, 0xFF, 0x74, 0x00, 0x5F, 0xFF, 0x42, 0x00, 0x92, 0xFF, 0x11, 0x00,
0xC5, 0xDE, 0x00, 0x02, 0xF4, 0xAC, 0x00, 0x2A, 0xFF, 0x7A, 0x00, 0x5D, 0xFF, 0x48, 0x00, 0x90,
0xFF, 0x16, 0x00, 0xC3, 0xE4, 0x00, 0x00,
};
static const CoordsGlyphAA s_navTitleGlyphs[28] PROGMEM = {
{ 10, 10, 0, 0, 10, 0 }, // 'A'
{ 10, 10, 0, 0, 10, 100 }, // 'B'
{ 10, 10, 0, 0, 10, 200 }, // 'C'
{ 10, 10, 0, 0, 10, 300 }, // 'D'
{ 9, 10, 0, 0, 9, 400 }, // 'E'
{ 9, 10, 0, 0, 8, 490 }, // 'F'
{ 11, 10, 0, 0, 10, 580 }, // 'G'
{ 10, 10, 0, 0, 10, 690 }, // 'H'
{ 3, 10, 0, 0, 4, 790 }, // 'I'
{ 7, 10, 0, 0, 8, 820 }, // 'J'
{ 10, 10, 0, 0, 10, 890 }, // 'K'
{ 9, 10, 0, 0, 8, 990 }, // 'L'
{ 11, 10, 0, 0, 11, 1080 }, // 'M'
{ 10, 10, 0, 0, 10, 1190 }, // 'N'
{ 11, 10, 0, 0, 10, 1290 }, // 'O'
{ 9, 10, 0, 0, 9, 1400 }, // 'P'
{ 11, 13, 0, 0, 10, 1490 }, // 'Q'
{ 10, 10, 0, 0, 10, 1633 }, // 'R'
{ 9, 10, 0, 0, 9, 1733 }, // 'S'
{ 9, 10, 0, 0, 8, 1823 }, // 'T'
{ 10, 10, 0, 0, 10, 1913 }, // 'U'
{ 10, 10, 0, 0, 9, 2013 }, // 'V'
{ 14, 10, 0, 0, 13, 2113 }, // 'W'
{ 10, 10, 0, 0, 9, 2253 }, // 'X'
{ 10, 10, 0, 0, 9, 2353 }, // 'Y'
{ 9, 10, 0, 0, 8, 2453 }, // 'Z'
{ 4, 10, 0, 0, 4, 2543 }, // '/'
{ 0, 0, 0, 0, 4, 2583 }, // ' '
};
// Subword Font (10.5pt Bold AA: LATITUD, LONGITUD, HDOP, MSNM, DIAGS) - 2168 bytes
static const uint8_t s_navSubAlpha[2168] PROGMEM = {
0x00, 0x00, 0x24, 0xFF, 0xFC, 0x16, 0x00, 0x00, 0x00, 0x00, 0x7D, 0xEC, 0xF5, 0x6B, 0x00, 0x00,
0x00, 0x00, 0xD4, 0xA4, 0xB3, 0xC3, 0x00, 0x00, 0x00, 0x2C, 0xFF, 0x57, 0x66, 0xFE, 0x1C, 0x00,
0x00, 0x85, 0xFA, 0x0F, 0x19, 0xFE, 0x73, 0x00, 0x00, 0xDC, 0xFF, 0xFF, 0xFF, 0xFF, 0xCB, 0x00,
0x35, 0xFF, 0x7E, 0x30, 0x30, 0x89, 0xFF, 0x23, 0x8C, 0xF9, 0x12, 0x00, 0x00, 0x1C, 0xFD, 0x7B,
0x44, 0xFF, 0xFF, 0xFF, 0xF7, 0xD1, 0x4B, 0x00, 0x44, 0xFF, 0x71, 0x2C, 0x39, 0xD0, 0xED, 0x00,
0x44, 0xFF, 0x54, 0x00, 0x0C, 0xBD, 0xDB, 0x00, 0x44, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x46, 0x00,
0x44, 0xFF, 0x71, 0x2C, 0x33, 0x9D, 0xF7, 0x26, 0x44, 0xFF, 0x54, 0x00, 0x00, 0x2E, 0xFF, 0x64,
0x44, 0xFF, 0x71, 0x2C, 0x31, 0x9A, 0xFF, 0x38, 0x44, 0xFF, 0xFF, 0xFF, 0xFC, 0xDC, 0x68, 0x00,
0x00, 0x21, 0xAC, 0xEF, 0xF7, 0xD6, 0x6F, 0x01, 0x05, 0xD7, 0xEA, 0x69, 0x4E, 0x85, 0xE8, 0x41,
0x53, 0xFF, 0x56, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7B, 0xFF, 0x1A, 0x00, 0x00, 0x00, 0x00, 0x00,
0x78, 0xFF, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4D, 0xFF, 0x59, 0x00, 0x00, 0x00, 0x00, 0x00,
0x02, 0xCE, 0xEC, 0x6A, 0x4B, 0x83, 0xE5, 0x4D, 0x00, 0x19, 0xA5, 0xED, 0xF9, 0xD9, 0x79, 0x03,
0x44, 0xFF, 0xFF, 0xFD, 0xE4, 0x96, 0x10, 0x00, 0x44, 0xFF, 0x79, 0x3E, 0x77, 0xF5, 0xCA, 0x02,
0x44, 0xFF, 0x54, 0x00, 0x00, 0x6F, 0xFF, 0x46, 0x44, 0xFF, 0x54, 0x00, 0x00, 0x2B, 0xFF, 0x73,
0x44, 0xFF, 0x54, 0x00, 0x00, 0x2F, 0xFF, 0x6D, 0x44, 0xFF, 0x54, 0x00, 0x00, 0x75, 0xFF, 0x38,
0x44, 0xFF, 0x79, 0x3A, 0x71, 0xF6, 0xBC, 0x00, 0x44, 0xFF, 0xFF, 0xFF, 0xE9, 0x96, 0x0D, 0x00,
0x44, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xB0, 0x44, 0xFF, 0x79, 0x38, 0x38, 0x38, 0x26, 0x44, 0xFF,
0x54, 0x00, 0x00, 0x00, 0x00, 0x44, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x5C, 0x44, 0xFF, 0x79, 0x38,
0x38, 0x38, 0x14, 0x44, 0xFF, 0x54, 0x00, 0x00, 0x00, 0x00, 0x44, 0xFF, 0x79, 0x38, 0x38, 0x38,
0x32, 0x44, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE8, 0x44, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x50, 0x44,
0xFF, 0x79, 0x38, 0x38, 0x38, 0x11, 0x44, 0xFF, 0x54, 0x00, 0x00, 0x00, 0x00, 0x44, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0x30, 0x44, 0xFF, 0x79, 0x38, 0x38, 0x38, 0x0A, 0x44, 0xFF, 0x54, 0x00, 0x00,
0x00, 0x00, 0x44, 0xFF, 0x54, 0x00, 0x00, 0x00, 0x00, 0x44, 0xFF, 0x54, 0x00, 0x00, 0x00, 0x00,
0x00, 0x1A, 0xA5, 0xEB, 0xF9, 0xDF, 0x8B, 0x09, 0x03, 0xD0, 0xEE, 0x6E, 0x4B, 0x7C, 0xE6, 0x62,
0x50, 0xFF, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7A, 0xFF, 0x1A, 0x00, 0x00, 0x00, 0x00, 0x00,
0x78, 0xFF, 0x1C, 0x00, 0x6C, 0xFF, 0xFF, 0xE0, 0x4D, 0xFF, 0x5E, 0x00, 0x12, 0x2C, 0xA6, 0xE0,
0x02, 0xD0, 0xEF, 0x6C, 0x46, 0x6D, 0xE0, 0xD2, 0x00, 0x1B, 0xA6, 0xED, 0xF9, 0xDB, 0x8F, 0x18,
0x44, 0xFF, 0x54, 0x00, 0x00, 0x60, 0xFF, 0x34, 0x44, 0xFF, 0x54, 0x00, 0x00, 0x60, 0xFF, 0x34,
0x44, 0xFF, 0x54, 0x00, 0x00, 0x60, 0xFF, 0x34, 0x44, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x34,
0x44, 0xFF, 0x89, 0x50, 0x50, 0x92, 0xFF, 0x34, 0x44, 0xFF, 0x54, 0x00, 0x00, 0x60, 0xFF, 0x34,
0x44, 0xFF, 0x54, 0x00, 0x00, 0x60, 0xFF, 0x34, 0x44, 0xFF, 0x54, 0x00, 0x00, 0x60, 0xFF, 0x34,
0x44, 0xFF, 0x54, 0x44, 0xFF, 0x54, 0x44, 0xFF, 0x54, 0x44, 0xFF, 0x54, 0x44, 0xFF, 0x54, 0x44,
0xFF, 0x54, 0x44, 0xFF, 0x54, 0x44, 0xFF, 0x54, 0x00, 0x00, 0xB8, 0xFF, 0xFF, 0x5C, 0x00, 0x00,
0x2B, 0x66, 0xFF, 0x5C, 0x00, 0x00, 0x00, 0x38, 0xFF, 0x5C, 0x00, 0x00, 0x00, 0x38, 0xFF, 0x5C,
0x00, 0x00, 0x00, 0x38, 0xFF, 0x5C, 0x00, 0x00, 0x00, 0x3C, 0xFF, 0x54, 0x97, 0xE8, 0x54, 0x9F,
0xFC, 0x24, 0x27, 0xC6, 0xF6, 0xE3, 0x65, 0x00, 0x44, 0xFF, 0x54, 0x00, 0x05, 0xB6, 0xED, 0x2C,
0x44, 0xFF, 0x54, 0x02, 0xA9, 0xF1, 0x34, 0x00, 0x44, 0xFF, 0x54, 0x9C, 0xF5, 0x3C, 0x00, 0x00,
0x44, 0xFF, 0xD1, 0xFF, 0x8E, 0x00, 0x00, 0x00, 0x44, 0xFF, 0xDD, 0xB0, 0xF9, 0x35, 0x00, 0x00,
0x44, 0xFF, 0x54, 0x0B, 0xD7, 0xDF, 0x11, 0x00, 0x44, 0xFF, 0x54, 0x00, 0x2D, 0xF7, 0xB2, 0x01,
0x44, 0xFF, 0x54, 0x00, 0x00, 0x67, 0xFF, 0x76, 0x44, 0xFF, 0x54, 0x00, 0x00, 0x00, 0x00, 0x44,
0xFF, 0x54, 0x00, 0x00, 0x00, 0x00, 0x44, 0xFF, 0x54, 0x00, 0x00, 0x00, 0x00, 0x44, 0xFF, 0x54,
0x00, 0x00, 0x00, 0x00, 0x44, 0xFF, 0x54, 0x00, 0x00, 0x00, 0x00, 0x44, 0xFF, 0x54, 0x00, 0x00,
0x00, 0x00, 0x44, 0xFF, 0x79, 0x38, 0x38, 0x38, 0x15, 0x44, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x60,
0x44, 0xFF, 0xF6, 0x09, 0x00, 0x00, 0xD5, 0xFF, 0x6C, 0x44, 0xFF, 0xEB, 0x4A, 0x00, 0x1D, 0xF6,
0xF5, 0x6C, 0x44, 0xFF, 0xB3, 0x93, 0x00, 0x66, 0xBB, 0xF9, 0x6C, 0x44, 0xFF, 0x71, 0xDD, 0x00,
0xAF, 0x74, 0xFC, 0x6C, 0x44, 0xFF, 0x2E, 0xF7, 0x2C, 0xF2, 0x29, 0xFC, 0x6C, 0x44, 0xFF, 0x24,
0xB7, 0xA5, 0xDE, 0x00, 0xFC, 0x6C, 0x44, 0xFF, 0x24, 0x6C, 0xFC, 0x93, 0x00, 0xFC, 0x6C, 0x44,
0xFF, 0x24, 0x21, 0xFF, 0x49, 0x00, 0xFC, 0x6C, 0x44, 0xFF, 0xCE, 0x01, 0x00, 0x34, 0xFF, 0x34,
0x44, 0xFF, 0xFE, 0x5A, 0x00, 0x34, 0xFF, 0x34, 0x44, 0xFF, 0xB4, 0xDD, 0x05, 0x34, 0xFF, 0x34,
0x44, 0xFF, 0x3E, 0xF6, 0x6D, 0x34, 0xFF, 0x34, 0x44, 0xFF, 0x24, 0x88, 0xEA, 0x40, 0xFF, 0x34,
0x44, 0xFF, 0x24, 0x10, 0xEE, 0xA8, 0xFF, 0x34, 0x44, 0xFF, 0x24, 0x00, 0x76, 0xFD, 0xFF, 0x34,
0x44, 0xFF, 0x24, 0x00, 0x08, 0xE3, 0xFF, 0x34, 0x00, 0x19, 0xA4, 0xEC, 0xF9, 0xD3, 0x5F, 0x00,
0x00, 0x02, 0xCE, 0xEF, 0x6D, 0x4E, 0xAA, 0xFF, 0x64, 0x00, 0x4E, 0xFF, 0x5C, 0x00, 0x00, 0x01,
0xD3, 0xDF, 0x00, 0x7A, 0xFF, 0x1B, 0x00, 0x00, 0x00, 0x93, 0xFF, 0x0E, 0x82, 0xFF, 0x1D, 0x00,
0x00, 0x00, 0x95, 0xFF, 0x0A, 0x50, 0xFF, 0x62, 0x00, 0x00, 0x01, 0xD4, 0xD6, 0x00, 0x04, 0xD0,
0xF1, 0x6F, 0x4E, 0xAA, 0xFF, 0x58, 0x00, 0x00, 0x15, 0xA0, 0xEC, 0xF7, 0xCD, 0x55, 0x00, 0x00,
0x44, 0xFF, 0xFF, 0xFF, 0xF3, 0xBB, 0x24, 0x44, 0xFF, 0x7C, 0x3C, 0x57, 0xED, 0xC1, 0x44, 0xFF,
0x54, 0x00, 0x00, 0xAE, 0xEE, 0x44, 0xFF, 0x79, 0x38, 0x54, 0xEF, 0xBA, 0x44, 0xFF, 0xFF, 0xFF,
0xF8, 0xBA, 0x1E, 0x44, 0xFF, 0x54, 0x00, 0x00, 0x00, 0x00, 0x44, 0xFF, 0x54, 0x00, 0x00, 0x00,
0x00, 0x44, 0xFF, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0xA3, 0xEC, 0xF9, 0xD2, 0x5D, 0x00,
0x00, 0x02, 0xCB, 0xF0, 0x6E, 0x4F, 0xAC, 0xFF, 0x60, 0x00, 0x4D, 0xFF, 0x5E, 0x00, 0x00, 0x01,
0xD5, 0xDB, 0x00, 0x79, 0xFF, 0x1C, 0x00, 0x00, 0x00, 0x94, 0xFF, 0x0D, 0x7B, 0xFF, 0x1B, 0x00,
0x00, 0x00, 0x94, 0xFE, 0x09, 0x4F, 0xFF, 0x5D, 0x00, 0x00, 0x00, 0xD0, 0xDB, 0x00, 0x03, 0xD4,
0xEC, 0x60, 0x3E, 0x9D, 0xFF, 0x64, 0x00, 0x00, 0x15, 0xA6, 0xF0, 0xFF, 0xE5, 0x6E, 0x00, 0x00,
0x00, 0x00, 0x00, 0x20, 0xFC, 0xB4, 0x38, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0xE9, 0xF2,
0x4D, 0x00, 0x44, 0xFF, 0xFF, 0xFF, 0xFB, 0xDA, 0x60, 0x00, 0x44, 0xFF, 0x7C, 0x3C, 0x42, 0xB4,
0xFD, 0x26, 0x44, 0xFF, 0x54, 0x00, 0x00, 0x4A, 0xFF, 0x4D, 0x44, 0xFF, 0x7C, 0x3C, 0x42, 0xB9,
0xF8, 0x1A, 0x44, 0xFF, 0xFF, 0xFF, 0xFF, 0xE7, 0x40, 0x00, 0x44, 0xFF, 0x54, 0x00, 0x89, 0xFC,
0x30, 0x00, 0x44, 0xFF, 0x54, 0x00, 0x0C, 0xE5, 0xC8, 0x02, 0x44, 0xFF, 0x54, 0x00, 0x00, 0x5B,
0xFF, 0x68, 0x00, 0x65, 0xD8, 0xF8, 0xED, 0xAC, 0x13, 0x2C, 0xFF, 0x8D, 0x27, 0x54, 0xEF, 0x77,
0x47, 0xFF, 0x73, 0x00, 0x00, 0x00, 0x00, 0x08, 0xCC, 0xFF, 0xE3, 0xA3, 0x51, 0x00, 0x00, 0x03,
0x48, 0x8A, 0xD2, 0xFF, 0x88, 0x00, 0x00, 0x00, 0x00, 0x01, 0xC3, 0xDA, 0x6B, 0xED, 0x68, 0x34,
0x4F, 0xE7, 0xB2, 0x0A, 0x92, 0xE3, 0xF9, 0xE9, 0xA8, 0x1A, 0xE0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0x98, 0x31, 0x38, 0x8F, 0xFF, 0x57, 0x38, 0x21, 0x00, 0x00, 0x70, 0xFF, 0x28, 0x00, 0x00, 0x00,
0x00, 0x70, 0xFF, 0x28, 0x00, 0x00, 0x00, 0x00, 0x70, 0xFF, 0x28, 0x00, 0x00, 0x00, 0x00, 0x70,
0xFF, 0x28, 0x00, 0x00, 0x00, 0x00, 0x70, 0xFF, 0x28, 0x00, 0x00, 0x00, 0x00, 0x70, 0xFF, 0x28,
0x00, 0x00, 0x58, 0xFF, 0x40, 0x00, 0x00, 0x50, 0xFF, 0x44, 0x58, 0xFF, 0x40, 0x00, 0x00, 0x50,
0xFF, 0x44, 0x58, 0xFF, 0x40, 0x00, 0x00, 0x50, 0xFF, 0x44, 0x58, 0xFF, 0x40, 0x00, 0x00, 0x50,
0xFF, 0x44, 0x57, 0xFF, 0x40, 0x00, 0x00, 0x50, 0xFF, 0x43, 0x41, 0xFF, 0x5A, 0x00, 0x00, 0x6F,
0xFF, 0x27, 0x0D, 0xE7, 0xD9, 0x51, 0x5A, 0xE6, 0xCE, 0x02, 0x00, 0x32, 0xBF, 0xF1, 0xE9, 0xA9,
0x1D, 0x00, 0xC0, 0xE1, 0x00, 0x00, 0x00, 0x87, 0xFD, 0x19, 0x66, 0xFF, 0x2F, 0x00, 0x00, 0xD3,
0xBD, 0x00, 0x12, 0xFA, 0x7C, 0x00, 0x1F, 0xFF, 0x64, 0x00, 0x00, 0xB3, 0xC9, 0x00, 0x6C, 0xFA,
0x11, 0x00, 0x00, 0x5A, 0xFE, 0x18, 0xB8, 0xB2, 0x00, 0x00, 0x00, 0x0B, 0xF5, 0x6A, 0xF8, 0x59,
0x00, 0x00, 0x00, 0x00, 0xA7, 0xE0, 0xF5, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x4D, 0xFF, 0xA8, 0x00,
0x00, 0x00, 0xDE, 0xB4, 0x00, 0x00, 0xC7, 0xFF, 0x32, 0x00, 0x55, 0xFF, 0x40, 0xA0, 0xE7, 0x00,
0x05, 0xF7, 0xF7, 0x67, 0x00, 0x85, 0xF9, 0x08, 0x62, 0xFF, 0x1A, 0x31, 0xFC, 0xAE, 0x9D, 0x00,
0xB6, 0xC3, 0x00, 0x24, 0xFF, 0x4C, 0x66, 0xD0, 0x74, 0xD2, 0x00, 0xE7, 0x84, 0x00, 0x00, 0xE5,
0x7F, 0x9A, 0x99, 0x3D, 0xFC, 0x22, 0xFF, 0x46, 0x00, 0x00, 0xA8, 0xB1, 0xCB, 0x62, 0x09, 0xFB,
0x82, 0xFB, 0x0C, 0x00, 0x00, 0x6A, 0xE4, 0xF6, 0x2A, 0x00, 0xCD, 0xDD, 0xC9, 0x00, 0x00, 0x00,
0x2B, 0xFF, 0xF1, 0x02, 0x00, 0x94, 0xFF, 0x8B, 0x00, 0x00, 0x5F, 0xFF, 0x4B, 0x00, 0x0C, 0xE4,
0xB6, 0x00, 0x00, 0xBC, 0xDB, 0x07, 0x89, 0xF7, 0x23, 0x00, 0x00, 0x23, 0xF6, 0x9D, 0xFA, 0x80,
0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xE3, 0x08, 0x00, 0x00, 0x00, 0x00, 0xB8, 0xFA, 0xFA, 0x28,
0x00, 0x00, 0x00, 0x59, 0xFF, 0x4D, 0xE1, 0xBC, 0x00, 0x00, 0x10, 0xE8, 0xA9, 0x00, 0x52, 0xFF,
0x55, 0x00, 0x98, 0xF4, 0x1C, 0x00, 0x00, 0xB8, 0xE3, 0x0B, 0x8B, 0xF8, 0x18, 0x00, 0x00, 0xBC,
0xDD, 0x05, 0x11, 0xEF, 0x85, 0x00, 0x31, 0xFF, 0x59, 0x00, 0x00, 0x76, 0xED, 0x0B, 0xA8, 0xCE,
0x01, 0x00, 0x00, 0x08, 0xE3, 0x8E, 0xFC, 0x46, 0x00, 0x00, 0x00, 0x00, 0x61, 0xFF, 0xBC, 0x00,
0x00, 0x00, 0x00, 0x00, 0x1C, 0xFF, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0xFF, 0x78, 0x00,
0x00, 0x00, 0x00, 0x00, 0x1C, 0xFF, 0x78, 0x00, 0x00, 0x00, 0x44, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0x30, 0x0F, 0x3C, 0x3C, 0x3F, 0xE0, 0xD9, 0x0A, 0x00, 0x00, 0x00, 0x80, 0xF9, 0x32, 0x00, 0x00,
0x00, 0x3C, 0xFC, 0x73, 0x00, 0x00, 0x00, 0x11, 0xE1, 0xB9, 0x01, 0x00, 0x00, 0x00, 0xAC, 0xE9,
0x18, 0x00, 0x00, 0x00, 0x65, 0xFF, 0x84, 0x3C, 0x3C, 0x3C, 0x18, 0xAC, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0x68, 0x00, 0x73, 0xEB, 0xE8, 0x7C, 0x00, 0x2B, 0xFF, 0x78, 0x65, 0xFF, 0x3B, 0x70, 0xFE,
0x07, 0x00, 0xF0, 0x87, 0x89, 0xF3, 0x00, 0x00, 0xDB, 0xA0, 0x85, 0xF2, 0x00, 0x00, 0xDC, 0x9F,
0x6A, 0xFE, 0x07, 0x00, 0xF0, 0x84, 0x1E, 0xFD, 0x78, 0x68, 0xFF, 0x34, 0x00, 0x62, 0xE2, 0xF0,
0x7E, 0x00, 0x0F, 0x82, 0xE9, 0xFF, 0x14, 0x00, 0x3C, 0xB4, 0xA8, 0xFF, 0x14, 0x00, 0x00, 0x00,
0x70, 0xFF, 0x14, 0x00, 0x00, 0x00, 0x70, 0xFF, 0x14, 0x00, 0x00, 0x00, 0x70, 0xFF, 0x14, 0x00,
0x00, 0x00, 0x70, 0xFF, 0x14, 0x00, 0x0A, 0x20, 0x82, 0xFF, 0x31, 0x1A, 0x50, 0xFF, 0xFF, 0xFF,
0xFF, 0xD0, 0x06, 0x9B, 0xEF, 0xEE, 0xA0, 0x06, 0x60, 0xF9, 0x6B, 0x60, 0xFF, 0x69, 0x00, 0x00,
0x00, 0x0B, 0xFE, 0x7E, 0x00, 0x00, 0x01, 0x9F, 0xFC, 0x2F, 0x00, 0x06, 0xA8, 0xFD, 0x63, 0x00,
0x00, 0xAB, 0xF5, 0x4B, 0x00, 0x00, 0x5C, 0xFF, 0x8F, 0x3C, 0x3C, 0x28, 0xA0, 0xFF, 0xFF, 0xFF,
0xFF, 0xAC, 0x09, 0xA0, 0xEF, 0xF0, 0xA9, 0x0B, 0x6F, 0xF7, 0x60, 0x69, 0xFF, 0x71, 0x00, 0x00,
0x01, 0x39, 0xFF, 0x5E, 0x00, 0x00, 0xCC, 0xFE, 0x92, 0x01, 0x00, 0x00, 0x2D, 0x6D, 0xFD, 0x64,
0x00, 0x00, 0x00, 0x00, 0xDE, 0xAD, 0x8D, 0xF0, 0x5A, 0x5E, 0xFC, 0x83, 0x15, 0xAF, 0xF1, 0xEF,
0xA6, 0x0C, 0x00, 0x00, 0x0F, 0xE6, 0xFF, 0x0C, 0x00, 0x00, 0x00, 0x99, 0xE7, 0xFF, 0x0C, 0x00,
0x00, 0x3D, 0xE9, 0x77, 0xFF, 0x0C, 0x00, 0x07, 0xD7, 0x5A, 0x64, 0xFF, 0x0C, 0x00, 0x82, 0xB6,
0x00, 0x64, 0xFF, 0x0C, 0x00, 0xD4, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x10, 0x1A, 0x20, 0x20, 0x77,
0xFF, 0x2A, 0x02, 0x00, 0x00, 0x00, 0x64, 0xFF, 0x0C, 0x00, 0x34, 0xFF, 0xFF, 0xFF, 0xFF, 0x60,
0x42, 0xFF, 0x44, 0x20, 0x20, 0x0C, 0x50, 0xFF, 0x1D, 0x00, 0x00, 0x00, 0x5F, 0xFF, 0xC9, 0xF5,
0xBB, 0x19, 0x4B, 0xB4, 0x68, 0x58, 0xF7, 0x9D, 0x00, 0x00, 0x00, 0x00, 0xC6, 0xC4, 0x75, 0xF4,
0x5F, 0x56, 0xF7, 0x8E, 0x0C, 0xA5, 0xF1, 0xED, 0xA2, 0x0D, 0x00, 0x55, 0xE2, 0xF5, 0xA5, 0x06,
0x1E, 0xF9, 0x91, 0x5A, 0xEE, 0x4D, 0x6D, 0xFA, 0x0B, 0x00, 0x00, 0x00, 0x8F, 0xED, 0xAB, 0xF2,
0xBC, 0x15, 0x8E, 0xFF, 0x5C, 0x3F, 0xF7, 0x8B, 0x72, 0xFF, 0x06, 0x00, 0xD4, 0xAD, 0x22, 0xFD,
0x80, 0x4E, 0xFA, 0x7B, 0x00, 0x5B, 0xDE, 0xF1, 0xA4, 0x0A, 0x88, 0xFF, 0xFF, 0xFF, 0xFF, 0xA4,
0x1F, 0x3C, 0x3C, 0x47, 0xF4, 0x72, 0x00, 0x00, 0x00, 0x8D, 0xDB, 0x06, 0x00, 0x00, 0x25, 0xFB,
0x5C, 0x00, 0x00, 0x00, 0x9A, 0xE1, 0x03, 0x00, 0x00, 0x08, 0xF0, 0x8C, 0x00, 0x00, 0x00, 0x3B,
0xFF, 0x4C, 0x00, 0x00, 0x00, 0x5C, 0xFF, 0x31, 0x00, 0x00, 0x06, 0x9F, 0xEE, 0xF2, 0xB3, 0x12,
0x60, 0xFF, 0x5A, 0x3B, 0xFE, 0x81, 0x4F, 0xFF, 0x4E, 0x23, 0xFD, 0x6F, 0x00, 0xA5, 0xFF, 0xFF,
0xBE, 0x04, 0x5C, 0xFE, 0x44, 0x32, 0xF4, 0x7F, 0x9E, 0xEE, 0x00, 0x00, 0xCF, 0xBE, 0x74, 0xFE,
0x44, 0x2F, 0xF4, 0x93, 0x07, 0x9B, 0xEC, 0xF0, 0xAC, 0x12, 0x04, 0x96, 0xEC, 0xE6, 0x7A, 0x00,
0x68, 0xFF, 0x63, 0x6D, 0xFF, 0x40, 0x96, 0xEF, 0x00, 0x00, 0xEE, 0x8F, 0x70, 0xFF, 0x53, 0x51,
0xFD, 0xA9, 0x0A, 0xAF, 0xF3, 0xC0, 0xDE, 0xAB, 0x00, 0x00, 0x00, 0x02, 0xEC, 0x8A, 0x47, 0xEE,
0x61, 0x80, 0xFF, 0x38, 0x04, 0xA1, 0xF4, 0xE9, 0x6D, 0x00, 0xF0, 0x9C, 0xF0, 0x9C, 0x00, 0x00,
0x00, 0x00, 0xF0, 0x9C, 0xF0, 0x9C, 0x40, 0xFF, 0x4C, 0x40, 0xFF, 0x4C, 0x90, 0xFF, 0xFF, 0x38,
0x2D, 0x50, 0x50, 0x11, 0x1F, 0xC5, 0xD7, 0x68, 0x74, 0x6B, 0x0C, 0xD9, 0x22, 0xCC, 0xD8, 0x69,
0x00, 0x6E, 0xDA, 0x00, 0xA0, 0xA9, 0x00, 0xD2, 0x78, 0x08, 0xFB, 0x47, 0x36, 0xFF, 0x17, 0x68,
0xE5, 0x00, 0x9A, 0xB4, 0x00, 0xCB, 0x84, 0x00,
};
static const CoordsGlyphAA s_navSubGlyphs[42] PROGMEM = {
{ 8, 8, 0, 0, 8, 0 }, // 'A'
{ 8, 8, 0, 0, 8, 64 }, // 'B'
{ 8, 8, 0, 0, 8, 128 }, // 'C'
{ 8, 8, 0, 0, 8, 192 }, // 'D'
{ 7, 8, 0, 0, 7, 256 }, // 'E'
{ 7, 8, 0, 0, 6, 312 }, // 'F'
{ 8, 8, 0, 0, 8, 368 }, // 'G'
{ 8, 8, 0, 0, 8, 432 }, // 'H'
{ 3, 8, 0, 0, 3, 496 }, // 'I'
{ 6, 8, 0, 0, 6, 520 }, // 'J'
{ 8, 8, 0, 0, 8, 568 }, // 'K'
{ 7, 8, 0, 0, 6, 632 }, // 'L'
{ 9, 8, 0, 0, 9, 688 }, // 'M'
{ 8, 8, 0, 0, 8, 760 }, // 'N'
{ 9, 8, 0, 0, 8, 824 }, // 'O'
{ 7, 8, 0, 0, 7, 896 }, // 'P'
{ 9, 10, 0, 0, 8, 952 }, // 'Q'
{ 8, 8, 0, 0, 8, 1042 }, // 'R'
{ 7, 8, 0, 0, 7, 1106 }, // 'S'
{ 7, 8, 0, 0, 6, 1162 }, // 'T'
{ 8, 8, 0, 0, 8, 1218 }, // 'U'
{ 8, 8, 0, 0, 7, 1282 }, // 'V'
{ 11, 8, 0, 0, 10, 1346 }, // 'W'
{ 8, 8, 0, 0, 7, 1434 }, // 'X'
{ 8, 8, 0, 0, 7, 1498 }, // 'Y'
{ 7, 8, 0, 0, 6, 1562 }, // 'Z'
{ 6, 8, 0, 0, 6, 1618 }, // '0'
{ 6, 8, 0, 0, 6, 1666 }, // '1'
{ 6, 8, 0, 0, 6, 1714 }, // '2'
{ 6, 8, 0, 0, 6, 1762 }, // '3'
{ 7, 8, 0, 0, 6, 1810 }, // '4'
{ 6, 8, 0, 0, 6, 1866 }, // '5'
{ 6, 8, 0, 0, 6, 1914 }, // '6'
{ 6, 8, 0, 0, 6, 1962 }, // '7'
{ 6, 8, 0, 0, 6, 2010 }, // '8'
{ 6, 8, 0, 0, 6, 2058 }, // '9'
{ 2, 6, 1, 2, 4, 2106 }, // ':'
{ 3, 2, 0, 6, 3, 2118 }, // '.'
{ 4, 2, 0, 4, 4, 2124 }, // '-'
{ 4, 3, 0, 0, 4, 2132 }, // '°'
{ 3, 8, 0, 0, 3, 2144 }, // '/'
{ 0, 0, 0, 0, 3, 2168 }, // ' '
};
// Coordinates Value Font (20pt Bold AA: Digits, Sign, Dot, Degree) - 1618 bytes
static const uint8_t s_coordsValueAlpha[1618] PROGMEM = {
0x00, 0x00, 0x13, 0x8E, 0xDD, 0xF8, 0xE6, 0x9D, 0x18, 0x00, 0x00, 0x00, 0x0A, 0xCF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xDD, 0x11, 0x00, 0x00, 0x71, 0xFF, 0xFF, 0x8A, 0x32, 0x79, 0xFF, 0xFF, 0x86,
0x00, 0x00, 0xCB, 0xFF, 0xDE, 0x01, 0x00, 0x00, 0xCF, 0xFF, 0xE1, 0x00, 0x07, 0xFA, 0xFF, 0xA8,
0x00, 0x00, 0x00, 0x98, 0xFF, 0xFF, 0x18, 0x1E, 0xFF, 0xFF, 0x92, 0x00, 0x00, 0x00, 0x80, 0xFF,
0xFF, 0x38, 0x2D, 0xFF, 0xFF, 0x8B, 0x00, 0x00, 0x00, 0x78, 0xFF, 0xFF, 0x46, 0x2F, 0xFF, 0xFF,
0x8B, 0x00, 0x00, 0x00, 0x78, 0xFF, 0xFF, 0x45, 0x22, 0xFF, 0xFF, 0x93, 0x00, 0x00, 0x00, 0x81,
0xFF, 0xFF, 0x37, 0x04, 0xFA, 0xFF, 0xAC, 0x00, 0x00, 0x00, 0x9A, 0xFF, 0xFF, 0x14, 0x00, 0xC6,
0xFF, 0xE2, 0x01, 0x00, 0x00, 0xD4, 0xFF, 0xD9, 0x00, 0x00, 0x69, 0xFF, 0xFF, 0x8C, 0x32, 0x82,
0xFF, 0xFF, 0x79, 0x00, 0x00, 0x05, 0xC6, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xCF, 0x0A, 0x00, 0x00,
0x00, 0x0C, 0x8C, 0xE1, 0xF9, 0xE3, 0x91, 0x10, 0x00, 0x00, 0x00, 0x00, 0x4D, 0xD3, 0xFF, 0xFF,
0x68, 0x00, 0x00, 0x00, 0x36, 0xC4, 0xFF, 0xFF, 0xFF, 0xFF, 0x68, 0x00, 0x00, 0x00, 0xA0, 0xFF,
0xE6, 0xAC, 0xFF, 0xFF, 0x68, 0x00, 0x00, 0x00, 0x87, 0x70, 0x08, 0x54, 0xFF, 0xFF, 0x68, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0xFF, 0xFF, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54,
0xFF, 0xFF, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0xFF, 0xFF, 0x68, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x54, 0xFF, 0xFF, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0xFF, 0xFF,
0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0xFF, 0xFF, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x54, 0xFF, 0xFF, 0x68, 0x00, 0x00, 0x00, 0x08, 0x0C, 0x0C, 0x5C, 0xFF, 0xFF, 0x6F, 0x0C,
0x0C, 0x06, 0xBC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x90, 0xBC, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x90, 0x00, 0x00, 0x2A, 0xA6, 0xDD, 0xF9, 0xEB, 0xB6, 0x42, 0x00,
0x00, 0x00, 0x33, 0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0x57, 0x00, 0x00, 0xCB, 0xFF, 0xFF,
0x79, 0x39, 0x72, 0xFE, 0xFF, 0xE0, 0x00, 0x0F, 0xE1, 0xF1, 0xB7, 0x00, 0x00, 0x00, 0xC0, 0xFF,
0xFF, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC8, 0xFF, 0xFE, 0x0A, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x4B, 0xFF, 0xFF, 0xBE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x43, 0xF4, 0xFF,
0xF8, 0x2B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xFA, 0xFF, 0xF9, 0x52, 0x00, 0x00, 0x00, 0x00,
0x00, 0x80, 0xFF, 0xFF, 0xED, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0xFF, 0xFF, 0xD7, 0x22,
0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0xFF, 0xFF, 0xCA, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F,
0xEC, 0xFF, 0xFF, 0x5E, 0x40, 0x40, 0x40, 0x40, 0x40, 0x15, 0x4F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0x54, 0x50, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x54,
0x00, 0x00, 0x37, 0xAF, 0xEA, 0xF9, 0xDE, 0xAA, 0x32, 0x00, 0x00, 0x00, 0x51, 0xFC, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFD, 0x51, 0x00, 0x07, 0xEB, 0xFF, 0xF8, 0x6B, 0x3A, 0x87, 0xFF, 0xFF, 0xDA,
0x00, 0x30, 0xDB, 0xEE, 0x91, 0x00, 0x00, 0x00, 0xD4, 0xFF, 0xFF, 0x04, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0xD6, 0xFF, 0xE7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x32, 0x91, 0xFF, 0xFF,
0x6F, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xC8, 0x57, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0xFF, 0xFF, 0xFF, 0xF5, 0xAE, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x27, 0x62, 0xF1,
0xFF, 0xDF, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xFF, 0x4D, 0x5F, 0xDA,
0xEF, 0x69, 0x00, 0x00, 0x00, 0x87, 0xFF, 0xFF, 0x5D, 0x33, 0xFF, 0xFF, 0xF0, 0x6D, 0x44, 0x6E,
0xF3, 0xFF, 0xFE, 0x26, 0x00, 0x8D, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x91, 0x00, 0x00,
0x00, 0x46, 0xB5, 0xE0, 0xFA, 0xEF, 0xBF, 0x5B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x39,
0xFD, 0xFF, 0xFF, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0xD5, 0xFF, 0xFF, 0xFF, 0x30,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0xFF, 0xF1, 0xFF, 0xFF, 0x30, 0x00, 0x00, 0x00, 0x00,
0x00, 0x2D, 0xFA, 0xF6, 0x89, 0xFF, 0xFF, 0x30, 0x00, 0x00, 0x00, 0x00, 0x03, 0xCA, 0xFF, 0x78,
0x6F, 0xFF, 0xFF, 0x30, 0x00, 0x00, 0x00, 0x00, 0x73, 0xFF, 0xCD, 0x04, 0x70, 0xFF, 0xFF, 0x30,
0x00, 0x00, 0x00, 0x22, 0xF5, 0xFB, 0x30, 0x00, 0x70, 0xFF, 0xFF, 0x30, 0x00, 0x00, 0x00, 0xBD,
0xFF, 0x85, 0x00, 0x00, 0x70, 0xFF, 0xFF, 0x30, 0x00, 0x00, 0x63, 0xFF, 0xD7, 0x07, 0x00, 0x00,
0x70, 0xFF, 0xFF, 0x30, 0x00, 0x00, 0xB4, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0x04, 0xB4, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x04, 0x08, 0x0C,
0x0C, 0x0C, 0x0C, 0x0C, 0x76, 0xFF, 0xFF, 0x39, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x70, 0xFF, 0xFF, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0xFF, 0xFF, 0x30,
0x00, 0x00, 0x00, 0x88, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC4, 0x00, 0x00, 0x97, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC4, 0x00, 0x00, 0xA6, 0xFF, 0xF5, 0x0C, 0x0C, 0x0C, 0x0C,
0x0C, 0x09, 0x00, 0x00, 0xB6, 0xFF, 0xE6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC5,
0xFF, 0xD7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xD4, 0xFF, 0xD4, 0x8D, 0xE0, 0xF8,
0xD6, 0x73, 0x02, 0x00, 0x00, 0xE4, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA0, 0x00, 0x00,
0xF3, 0xFF, 0xFC, 0x86, 0x44, 0x71, 0xF3, 0xFF, 0xFF, 0x35, 0x00, 0x1B, 0x1C, 0x15, 0x00, 0x00,
0x00, 0x77, 0xFF, 0xFF, 0x79, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4A, 0xFF, 0xFF, 0x8A,
0x35, 0xD7, 0xED, 0x8A, 0x00, 0x00, 0x00, 0x78, 0xFF, 0xFF, 0x6D, 0x07, 0xF0, 0xFF, 0xF9, 0x6D,
0x35, 0x69, 0xF2, 0xFF, 0xF9, 0x1E, 0x00, 0x51, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0x69,
0x00, 0x00, 0x00, 0x36, 0xAE, 0xE0, 0xFA, 0xEA, 0xB0, 0x3E, 0x00, 0x00, 0x00, 0x00, 0x02, 0x69,
0xCF, 0xF6, 0xE8, 0xB1, 0x2D, 0x00, 0x00, 0x00, 0x00, 0xA2, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0,
0x23, 0x00, 0x00, 0x51, 0xFF, 0xFF, 0xB3, 0x3A, 0x6F, 0xFF, 0xFF, 0xA3, 0x00, 0x00, 0xBC, 0xFF,
0xE8, 0x09, 0x00, 0x00, 0xB3, 0xD6, 0xA2, 0x00, 0x05, 0xFA, 0xFF, 0x9D, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x28, 0xFF, 0xFF, 0x7C, 0x7D, 0xE0, 0xF9, 0xDB, 0x74, 0x01, 0x00, 0x3A, 0xFF,
0xFF, 0xE5, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x8F, 0x00, 0x40, 0xFF, 0xFF, 0xFE, 0x61, 0x10, 0x43,
0xED, 0xFF, 0xFC, 0x1B, 0x34, 0xFF, 0xFF, 0xB8, 0x00, 0x00, 0x00, 0x83, 0xFF, 0xFF, 0x54, 0x12,
0xFF, 0xFF, 0xA9, 0x00, 0x00, 0x00, 0x64, 0xFF, 0xFF, 0x62, 0x00, 0xD6, 0xFF, 0xE2, 0x04, 0x00,
0x00, 0x8F, 0xFF, 0xFF, 0x48, 0x00, 0x71, 0xFF, 0xFF, 0xA3, 0x34, 0x60, 0xF5, 0xFF, 0xEF, 0x0C,
0x00, 0x05, 0xBE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0x5F, 0x00, 0x00, 0x00, 0x08, 0x7B, 0xD6,
0xF8, 0xF1, 0xBC, 0x45, 0x00, 0x00, 0x24, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0x40, 0x24, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x40, 0x09, 0x40, 0x40, 0x40,
0x40, 0x40, 0x40, 0xA9, 0xFF, 0xF2, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x27, 0xF7, 0xFF,
0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xC3, 0xFF, 0xD1, 0x04, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x63, 0xFF, 0xFF, 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0xEA, 0xFF, 0xC2,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0xFF, 0xFF, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x07, 0xE8, 0xFF, 0xD9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0xFF, 0xFF, 0x84,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA4, 0xFF, 0xFF, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xDF, 0xFF, 0xF4, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0xFF, 0xFF, 0xCF,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0xFF, 0xFF, 0xBF, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x3A, 0xB1, 0xEA, 0xFB, 0xEE, 0xBB, 0x4E, 0x00, 0x00, 0x00, 0x4B, 0xFC, 0xFF, 0xFF,
0xF6, 0xFF, 0xFF, 0xFF, 0x6B, 0x00, 0x00, 0xD5, 0xFF, 0xFD, 0x44, 0x00, 0x2F, 0xF4, 0xFF, 0xF0,
0x05, 0x04, 0xFF, 0xFF, 0xD1, 0x00, 0x00, 0x00, 0xB5, 0xFF, 0xFF, 0x23, 0x00, 0xED, 0xFF, 0xD7,
0x00, 0x00, 0x00, 0xBA, 0xFF, 0xFE, 0x0F, 0x00, 0x85, 0xFF, 0xFF, 0x5C, 0x0A, 0x43, 0xF9, 0xFF,
0xA4, 0x00, 0x00, 0x02, 0x83, 0xEF, 0xFF, 0xFF, 0xFF, 0xF5, 0x94, 0x09, 0x00, 0x00, 0x1E, 0xB2,
0xF9, 0xFF, 0xF5, 0xFF, 0xFE, 0xC9, 0x36, 0x00, 0x06, 0xD9, 0xFF, 0xE4, 0x29, 0x00, 0x1D, 0xCE,
0xFF, 0xF2, 0x1A, 0x40, 0xFF, 0xFF, 0x85, 0x00, 0x00, 0x00, 0x64, 0xFF, 0xFF, 0x69, 0x53, 0xFF,
0xFF, 0x88, 0x00, 0x00, 0x00, 0x69, 0xFF, 0xFF, 0x7A, 0x20, 0xFD, 0xFF, 0xE5, 0x2C, 0x00, 0x1C,
0xD0, 0xFF, 0xFF, 0x44, 0x00, 0x88, 0xFF, 0xFF, 0xFF, 0xF8, 0xFF, 0xFF, 0xFF, 0xAE, 0x00, 0x00,
0x00, 0x54, 0xBA, 0xEC, 0xFC, 0xF1, 0xC5, 0x69, 0x03, 0x00, 0x00, 0x00, 0x37, 0xAF, 0xE9, 0xFA,
0xE3, 0x9A, 0x18, 0x00, 0x00, 0x00, 0x50, 0xFB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE0, 0x17, 0x00,
0x04, 0xE6, 0xFF, 0xFD, 0x74, 0x36, 0x8F, 0xFF, 0xFF, 0x98, 0x00, 0x35, 0xFF, 0xFF, 0xAC, 0x00,
0x00, 0x00, 0xC9, 0xFF, 0xF1, 0x06, 0x4B, 0xFF, 0xFF, 0x84, 0x00, 0x00, 0x00, 0x90, 0xFF, 0xFF,
0x2E, 0x39, 0xFF, 0xFF, 0xA6, 0x00, 0x00, 0x00, 0xA6, 0xFF, 0xFF, 0x4F, 0x09, 0xF1, 0xFF, 0xFA,
0x59, 0x17, 0x5F, 0xFB, 0xFF, 0xFF, 0x5B, 0x00, 0x72, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE3, 0xFF,
0xFF, 0x56, 0x00, 0x00, 0x65, 0xD6, 0xF9, 0xE3, 0x89, 0x68, 0xFF, 0xFF, 0x45, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x87, 0xFF, 0xFF, 0x1D, 0x01, 0xA6, 0xD6, 0xA7, 0x00, 0x00, 0x03, 0xD8,
0xFF, 0xD9, 0x00, 0x00, 0xAC, 0xFF, 0xFD, 0x69, 0x33, 0xA3, 0xFF, 0xFF, 0x6F, 0x00, 0x00, 0x29,
0xF3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xBA, 0x04, 0x00, 0x00, 0x00, 0x30, 0xB2, 0xE8, 0xF8, 0xD6,
0x78, 0x06, 0x00, 0x00, 0xA4, 0xFF, 0xFF, 0x30, 0xA4, 0xFF, 0xFF, 0x30, 0xA4, 0xFF, 0xFF, 0x30,
0x38, 0xFF, 0xFF, 0xFF, 0xFF, 0xDC, 0x38, 0xFF, 0xFF, 0xFF, 0xFF, 0xDC, 0x15, 0x64, 0x64, 0x64,
0x64, 0x55, 0x00, 0x0D, 0x98, 0xEE, 0xE8, 0x94, 0x0C, 0x00, 0x00, 0xAC, 0xF9, 0x93, 0x93, 0xFA,
0xA8, 0x00, 0x0F, 0xFE, 0x86, 0x00, 0x00, 0x8A, 0xFD, 0x0C, 0x0A, 0xFC, 0x86, 0x00, 0x00, 0x8B,
0xFD, 0x0C, 0x00, 0xA6, 0xF9, 0x8F, 0x90, 0xFA, 0xA7, 0x00, 0x00, 0x0C, 0x94, 0xE9, 0xE9, 0x95,
0x0C, 0x00,
};
static const CoordsGlyphAA s_coordsValueGlyphs[14] PROGMEM = {
{ 11, 14, 0, 0, 11, 0 }, // '0'
{ 10, 14, 1, 0, 11, 154 }, // '1'
{ 11, 14, 0, 0, 11, 294 }, // '2'
{ 11, 14, 0, 0, 11, 448 }, // '3'
{ 12, 14, 0, 0, 11, 602 }, // '4'
{ 11, 14, 0, 0, 11, 770 }, // '5'
{ 11, 14, 0, 0, 11, 924 }, // '6'
{ 11, 14, 0, 0, 11, 1078 }, // '7'
{ 11, 14, 0, 0, 11, 1232 }, // '8'
{ 11, 14, 0, 0, 11, 1386 }, // '9'
{ 4, 3, 1, 11, 6, 1540 }, // '.'
{ 6, 3, 0, 8, 7, 1552 }, // '-'
{ 8, 6, 0, 0, 8, 1570 }, // '°'
{ 0, 0, 0, 0, 6, 1618 }, // ' '
};
// Draw single anti-aliased character glyph
template <typename T>
inline void drawCoordsAAChar(T &dst, int x0, int y0, const CoordsGlyphAA &g, const uint8_t *alphaTable, uint16_t color, uint16_t bgCol, int clip_h) {
if (g.w == 0 || g.h == 0) return;
for (uint8_t dy = 0; dy < g.h; dy++) {
int curY = y0 + g.yOff + dy;
if (curY < 0 || curY >= clip_h) continue;
uint32_t rowStart = g.offset + (uint32_t)dy * g.w;
for (uint8_t dx = 0; dx < g.w; dx++) {
int curX = x0 + g.xOff + dx;
if (curX < 0 || curX >= dst.width()) continue;
uint8_t a = pgm_read_byte(&alphaTable[rowStart + dx]);
if (a > 6) {
uint16_t pixCol = (a >= 250) ? color : fastBlend(a, color, bgCol);
dst.drawPixel(curX, curY, pixCol);
}
}
}
}
// 1. Draw 100% anti-aliased Title (ALTITUD, RUMBO / BRUJULA, SATELITES GPS, COORDENADAS)
template <typename T>
inline void drawGpsNavTitle(T &dst, const char *str, int x, int y, uint16_t color, uint16_t bgCol, int clip_h = 240) {
int curX = x;
uint8_t colorIdx = 0;
for (int i = 0; str[i] != '\0'; i++) {
char c = str[i];
int gIdx = -1;
if (c >= 'A' && c <= 'Z') {
gIdx = c - 'A';
} else if (c >= 'a' && c <= 'z') {
gIdx = c - 'a';
} else if (c == '/') {
gIdx = 26;
} else if (c == ' ') {
gIdx = 27;
}
if (gIdx >= 0) {
CoordsGlyphAA g;
memcpy_P(&g, &s_navTitleGlyphs[gIdx], sizeof(CoordsGlyphAA));
uint16_t cCol = isYapaTheme() ? getYapaColor(colorIdx++) : color;
drawCoordsAAChar(dst, curX, y, g, s_navTitleAlpha, cCol, bgCol, clip_h);
curX += g.xAdv;
}
}
}
// 2. Draw 100% anti-aliased Subwords (LATITUD, LONGITUD, HDOP, MSNM, DIAGS)
template <typename T>
inline void drawGpsNavSubword(T &dst, const char *str, int x, int y, uint16_t color, uint16_t bgCol, int clip_h = 240) {
int curX = x;
uint8_t colorIdx = 0;
for (int i = 0; str[i] != '\0'; i++) {
char c = str[i];
int gIdx = -1;
if (c >= 'A' && c <= 'Z') {
gIdx = c - 'A'; // 0..25
} else if (c >= 'a' && c <= 'z') {
gIdx = c - 'a'; // 0..25
} else if (c >= '0' && c <= '9') {
gIdx = 26 + (c - '0'); // 26..35
} else if (c == ':') {
gIdx = 36;
} else if (c == '.') {
gIdx = 37;
} else if (c == '-') {
gIdx = 38;
} else if ((uint8_t)c == 0xC2 && (uint8_t)str[i + 1] == 0xB0) {
gIdx = 39;
i++;
} else if ((uint8_t)c == 0xB0 || c == '`') {
gIdx = 39;
} else if (c == '/') {
gIdx = 40;
} else if (c == ' ') {
gIdx = 41;
}
if (gIdx >= 0) {
CoordsGlyphAA g;
memcpy_P(&g, &s_navSubGlyphs[gIdx], sizeof(CoordsGlyphAA));
uint16_t cCol = isYapaTheme() ? getYapaColor(colorIdx++) : color;
drawCoordsAAChar(dst, curX, y, g, s_navSubAlpha, cCol, bgCol, clip_h);
curX += g.xAdv;
}
}
}
// 3. Draw 100% anti-aliased Coordinate Value (e.g. "-34.60371°" or "--.-----°")
template <typename T>
inline void drawCoordsAAValue(T &dst, const char *str, int x, int y, uint16_t color, uint16_t bgCol, int clip_h = 240) {
int curX = x;
uint8_t colorIdx = 0;
for (int i = 0; str[i] != '\0'; i++) {
char c = str[i];
int gIdx = -1;
if (c >= '0' && c <= '9') {
gIdx = c - '0';
} else if (c == '.') {
gIdx = 10;
} else if (c == '-') {
gIdx = 11;
} else if ((uint8_t)c == 0xC2 && (uint8_t)str[i + 1] == 0xB0) {
gIdx = 12;
i++;
} else if ((uint8_t)c == 0xB0 || c == '`') {
gIdx = 12;
} else if (c == ' ') {
gIdx = 13;
}
if (gIdx >= 0) {
CoordsGlyphAA g;
memcpy_P(&g, &s_coordsValueGlyphs[gIdx], sizeof(CoordsGlyphAA));
uint16_t cCol = isYapaTheme() ? getYapaColor(colorIdx++) : color;
drawCoordsAAChar(dst, curX, y, g, s_coordsValueAlpha, cCol, bgCol, clip_h);
curX += g.xAdv;
}
}
}
// Backward-compatible alias for subword labels
template <typename T>
inline void drawCoordsAALabel(T &dst, const char *str, int x, int y, uint16_t color, uint16_t bgCol, int clip_h = 240) {
drawGpsNavSubword(dst, str, x, y, color, bgCol, clip_h);
}

242
sketch/obd2_gauge/gps_clock.h
View file

@ -33,10 +33,6 @@ static uint16_t oldClockYear = 0;
static TFT_eSprite sprDayTitle(&tft);
static uint8_t sprDayWday = 255;
inline void invalidateGpsClockTitles() {
sprDayWday = 255;
}
inline void updateDayTitleSprite(uint8_t wday) {
if (sprDayWday == wday && sprDayTitle.created()) return;
if (!sprDayTitle.created()) {
@ -47,21 +43,8 @@ inline void updateDayTitleSprite(uint8_t wday) {
sprDayTitle.loadFont(Latin_Sans_Bold_26);
sprDayTitle.setTextPadding(0);
sprDayTitle.fillSprite(cardBg);
if (isYapaTheme()) {
int curX = 0;
char buf[2] = {0, 0};
String dName = SPANISH_DAYS[wday];
for (size_t i = 0; i < dName.length(); i++) {
buf[0] = dName[i];
if (buf[0] == ' ') { curX += sprDayTitle.textWidth(buf); continue; }
sprDayTitle.setTextColor(getYapaColor(i), cardBg);
sprDayTitle.drawString(buf, curX, 0);
curX += sprDayTitle.textWidth(buf);
}
} else {
sprDayTitle.setTextColor(TFT_WHITE, cardBg);
sprDayTitle.drawString(SPANISH_DAYS[wday], 0, 0, 1);
}
sprDayTitle.setTextColor(TFT_WHITE, cardBg);
sprDayTitle.drawString(SPANISH_DAYS[wday], 0, 0, 1);
sprDayTitle.unloadFont();
if (isRainbowTheme()) {
applyRainbowToSprite(sprDayTitle, 4 + 116, 125 + 22, cardBg);
@ -84,20 +67,8 @@ inline void updateYearTitleSprite(uint16_t year, uint16_t priCol) {
sprYearTitle.loadFont(Latin_Sans_Bold_26);
sprYearTitle.setTextPadding(0);
sprYearTitle.fillSprite(cardBg);
if (isYapaTheme()) {
int curX = 0;
char buf[2] = {0, 0};
String yStr = String(year);
for (size_t i = 0; i < yStr.length(); i++) {
buf[0] = yStr[i];
sprYearTitle.setTextColor(getYapaColor(i + 2), cardBg);
sprYearTitle.drawString(buf, curX, 0);
curX += sprYearTitle.textWidth(buf);
}
} else {
sprYearTitle.setTextColor(priCol, cardBg);
sprYearTitle.drawString(String(year).c_str(), 0, 0, 1);
}
sprYearTitle.setTextColor(priCol, cardBg);
sprYearTitle.drawString(String(year).c_str(), 0, 0, 1);
sprYearTitle.unloadFont();
if (isRainbowTheme()) {
applyRainbowToSprite(sprYearTitle, 4 + 116, 125 + 64, cardBg);
@ -141,102 +112,47 @@ inline void drawDateCardContent(int cardX, int cardY, int cardW, int cardH,
tft.drawRoundRect(bx, by, bw, bh, 6, cardBorder);
// Badge top header (Month abbreviated in Accent Color)
if (isYapaTheme()) {
tft.fillRoundRect(bx, by, bw, 24, 6, 0x3A53);
tft.fillRect(bx, by + 18, bw, 6, 0x3A53);
int totalW = tft.textWidth(mShort.c_str(), 2);
int startX = bx + (bw - totalW) / 2;
char buf[2] = {0, 0};
for (size_t i = 0; i < mShort.length(); i++) {
buf[0] = mShort[i];
tft.setTextColor(getYapaColor(i), 0x3A53);
tft.drawString(buf, startX, by + 4, 2);
startX += tft.textWidth(buf, 2);
}
} else {
tft.fillRoundRect(bx, by, bw, 24, 6, accCol);
tft.fillRect(bx, by + 18, bw, 6, accCol); // flatten lower header corners
tft.setTextColor(TFT_BLACK, accCol);
tft.drawCentreString(mShort.c_str(), bx + (bw / 2), by + 4, 2);
}
tft.fillRoundRect(bx, by, bw, 24, 6, accCol);
tft.fillRect(bx, by + 18, bw, 6, accCol); // flatten lower header corners
tft.setTextColor(TFT_BLACK, accCol);
tft.drawCentreString(mShort.c_str(), bx + (bw / 2), by + 4, 2);
// Badge body: Big Day Number in DSEG7 34pt
tft.loadFont(DSEG7_Modern_BoldItalic_34);
tft.setTextColor(TFT_WHITE, 0x18C3);
tft.setTextPadding(0);
if (isYapaTheme()) {
int totalW = tft.textWidth(dayStr.c_str());
int startX = bx + (bw - totalW) / 2;
char buf[2] = {0, 0};
for (size_t i = 0; i < dayStr.length(); i++) {
buf[0] = dayStr[i];
tft.setTextColor(getYapaColor(i), 0x18C3);
tft.drawString(buf, startX, by + 34);
startX += tft.textWidth(buf);
}
} else {
tft.setTextColor(TFT_WHITE, 0x18C3);
tft.drawCentreString(dayStr.c_str(), bx + (bw / 2), by + 34, 1);
}
tft.drawCentreString(dayStr.c_str(), bx + (bw / 2), by + 34, 1);
tft.unloadFont();
// --- DATE DETAILS (Right side) ---
int tx = cardX + 116;
// Day of week in Latin Sans Bold 26 (Smooth antialiased, White, uppercase matching Page 1)
if (isYapaTheme()) {
tft.loadFont(Latin_Sans_Bold_26);
int curX = tx;
char buf[2] = {0, 0};
String dName = SPANISH_DAYS[wday];
for (size_t i = 0; i < dName.length(); i++) {
buf[0] = dName[i];
if (buf[0] == ' ') { curX += tft.textWidth(buf); continue; }
tft.setTextColor(getYapaColor(i), cardBg);
tft.drawString(buf, curX, cardY + 22);
curX += tft.textWidth(buf);
}
tft.unloadFont();
updateDayTitleSprite(wday);
if (sprDayTitle.created()) {
sprDayTitle.pushSprite(tx, cardY + 22);
} else {
updateDayTitleSprite(wday);
if (sprDayTitle.created()) {
sprDayTitle.pushSprite(tx, cardY + 22);
} else {
tft.loadFont(Latin_Sans_Bold_26);
tft.setTextPadding(0);
tft.setTextColor(TFT_WHITE, cardBg);
tft.drawString(SPANISH_DAYS[wday], tx, cardY + 22, 1);
tft.unloadFont();
}
tft.loadFont(Latin_Sans_Bold_26);
tft.setTextPadding(0);
tft.setTextColor(TFT_WHITE, cardBg);
tft.drawString(SPANISH_DAYS[wday], tx, cardY + 22, 1);
tft.unloadFont();
}
// Elegant two-tone horizontal dividing line
tft.drawFastHLine(tx, cardY + 54, 180, cardBorder);
tft.drawFastHLine(tx, cardY + 54, 50, isYapaTheme() ? getYapaColor(0) : accCol);
tft.drawFastHLine(tx, cardY + 54, 50, accCol);
// Year in Latin Sans Bold 26 (Smooth antialiased, Accent color)
if (isYapaTheme()) {
tft.loadFont(Latin_Sans_Bold_26);
int curX = tx;
char buf[2] = {0, 0};
String yStr = String(gpsYear);
for (size_t i = 0; i < yStr.length(); i++) {
buf[0] = yStr[i];
tft.setTextColor(getYapaColor(i + 2), cardBg);
tft.drawString(buf, curX, cardY + 64);
curX += tft.textWidth(buf);
}
tft.unloadFont();
updateYearTitleSprite(gpsYear, yearCol);
if (sprYearTitle.created()) {
sprYearTitle.pushSprite(tx, cardY + 64);
} else {
updateYearTitleSprite(gpsYear, yearCol);
if (sprYearTitle.created()) {
sprYearTitle.pushSprite(tx, cardY + 64);
} else {
tft.loadFont(Latin_Sans_Bold_26);
tft.setTextPadding(0);
tft.setTextColor(yearCol, cardBg);
tft.drawString(String(gpsYear).c_str(), tx, cardY + 64, 1);
tft.unloadFont();
}
tft.loadFont(Latin_Sans_Bold_26);
tft.setTextPadding(0);
tft.setTextColor(yearCol, cardBg);
tft.drawString(String(gpsYear).c_str(), tx, cardY + 64, 1);
tft.unloadFont();
}
}
@ -348,12 +264,12 @@ inline void drawGpsClockScreen(int x_offset = 0) {
uint16_t cardBorder = 0x2945; // Subtle edge border
bool synced = isGpsSynced();
// Center: 5 Pagination Indicator Dots [○ ○ ● ○ ○] (Page 2 of 5 active)
tft.fillCircle(132 + x_offset, 2, 2, 0x5AEB); // Page 0 inactive
tft.fillCircle(146 + x_offset, 2, 2, 0x5AEB); // Page 1 inactive
tft.fillCircle(160 + x_offset, 2, 2, priCol); // Page 2 active
tft.fillCircle(174 + x_offset, 2, 2, 0x5AEB); // Page 3 inactive
tft.fillCircle(188 + x_offset, 2, 2, 0x5AEB); // Page 4 inactive
// 1. TOP BAR (y = 0 to 18)
// Center: 4 Pagination Indicator Dots [○ ○ ● ○] (Page 3 active)
tft.fillCircle(139 + x_offset, 2, 2, 0x5AEB); // Page 1 inactive
tft.fillCircle(153 + x_offset, 2, 2, 0x5AEB); // Page 2 inactive
tft.fillCircle(167 + x_offset, 2, 2, priCol); // Page 3 active
tft.fillCircle(181 + x_offset, 2, 2, 0x5AEB); // Page 4 inactive
// 2. MAIN CLOCK CARD (y = 19 to 121, height = 102, width = 312, x = 4)
int clkX = 4 + x_offset;
@ -373,15 +289,11 @@ inline void drawGpsClockScreen(int x_offset = 0) {
uint8_t m10 = (gpsMinute / 10) % 10;
uint8_t m1 = gpsMinute % 10;
bool rbClk = isRainbowTheme();
uint16_t c_h10 = isYapaTheme() ? getYapaColor(0) : clkAccCol;
uint16_t c_h1 = isYapaTheme() ? getYapaColor(1) : clkAccCol;
uint16_t c_m10 = isYapaTheme() ? getYapaColor(2) : clkAccCol;
uint16_t c_m1 = isYapaTheme() ? getYapaColor(3) : clkAccCol;
drawDseg7Digit80(tft, clkX + 12, clkY + 11, h10, c_h10, cardBg, 240, rbClk);
drawDseg7Digit80(tft, clkX + 77, clkY + 11, h1, c_h1, cardBg, 240, rbClk);
drawDseg7Digit80(tft, clkX + 170, clkY + 11, m10, c_m10, cardBg, 240, rbClk);
drawDseg7Digit80(tft, clkX + 235, clkY + 11, m1, c_m1, cardBg, 240, rbClk);
drawDseg7Digit80(tft, clkX + 12, clkY + 11, h10, clkAccCol, cardBg, 240, rbClk);
drawDseg7Digit80(tft, clkX + 77, clkY + 11, h1, clkAccCol, cardBg, 240, rbClk);
drawDseg7Digit80(tft, clkX + 170, clkY + 11, m10, clkAccCol, cardBg, 240, rbClk);
drawDseg7Digit80(tft, clkX + 235, clkY + 11, m1, clkAccCol, cardBg, 240, rbClk);
// Blinking Colon Dots between HH and MM (italic 7-segment style with
// anti-aliasing)
@ -427,10 +339,8 @@ inline void updateGpsClockScreen(bool forceRedraw = false) {
tft.fillRect(clkX + 166, clkY + 10, 142, 82, cardBg);
uint8_t m10 = (gpsMinute / 10) % 10;
uint8_t m1 = gpsMinute % 10;
uint16_t c_m10 = isYapaTheme() ? getYapaColor(2) : clkAccCol;
uint16_t c_m1 = isYapaTheme() ? getYapaColor(3) : clkAccCol;
drawDseg7Digit80(tft, clkX + 170, clkY + 11, m10, c_m10, cardBg, 240, isRainbowTheme());
drawDseg7Digit80(tft, clkX + 235, clkY + 11, m1, c_m1, cardBg, 240, isRainbowTheme());
drawDseg7Digit80(tft, clkX + 170, clkY + 11, m10, clkAccCol, cardBg, 240, isRainbowTheme());
drawDseg7Digit80(tft, clkX + 235, clkY + 11, m1, clkAccCol, cardBg, 240, isRainbowTheme());
}
// 3. Hours change: update HH digits
@ -439,10 +349,8 @@ inline void updateGpsClockScreen(bool forceRedraw = false) {
tft.fillRect(clkX + 12, clkY + 10, 136, 82, cardBg);
uint8_t h10 = (gpsHour / 10) % 10;
uint8_t h1 = gpsHour % 10;
uint16_t c_h10 = isYapaTheme() ? getYapaColor(0) : clkAccCol;
uint16_t c_h1 = isYapaTheme() ? getYapaColor(1) : clkAccCol;
drawDseg7Digit80(tft, clkX + 12, clkY + 11, h10, c_h10, cardBg, 240, isRainbowTheme());
drawDseg7Digit80(tft, clkX + 77, clkY + 11, h1, c_h1, cardBg, 240, isRainbowTheme());
drawDseg7Digit80(tft, clkX + 12, clkY + 11, h10, clkAccCol, cardBg, 240, isRainbowTheme());
drawDseg7Digit80(tft, clkX + 77, clkY + 11, h1, clkAccCol, cardBg, 240, isRainbowTheme());
}
// 4. Date changed (midnight rollover): redraw full date card
@ -495,15 +403,10 @@ inline void renderPage2ToSprite(TFT_eSprite &s, int x_offset, int y_slice,
uint8_t m10 = (gpsMinute / 10) % 10;
uint8_t m1 = gpsMinute % 10;
uint16_t c_h10 = isYapaTheme() ? getYapaColor(0) : clkAccCol;
uint16_t c_h1 = isYapaTheme() ? getYapaColor(1) : clkAccCol;
uint16_t c_m10 = isYapaTheme() ? getYapaColor(2) : clkAccCol;
uint16_t c_m1 = isYapaTheme() ? getYapaColor(3) : clkAccCol;
drawDseg7Digit80(s, clkX + 12, digitY, h10, c_h10, cardBg, slice_h, isRainbowTheme());
drawDseg7Digit80(s, clkX + 77, digitY, h1, c_h1, cardBg, slice_h, isRainbowTheme());
drawDseg7Digit80(s, clkX + 170, digitY, m10, c_m10, cardBg, slice_h, isRainbowTheme());
drawDseg7Digit80(s, clkX + 235, digitY, m1, c_m1, cardBg, slice_h, isRainbowTheme());
drawDseg7Digit80(s, clkX + 12, digitY, h10, clkAccCol, cardBg, slice_h, isRainbowTheme());
drawDseg7Digit80(s, clkX + 77, digitY, h1, clkAccCol, cardBg, slice_h, isRainbowTheme());
drawDseg7Digit80(s, clkX + 170, digitY, m10, clkAccCol, cardBg, slice_h, isRainbowTheme());
drawDseg7Digit80(s, clkX + 235, digitY, m1, clkAccCol, cardBg, slice_h, isRainbowTheme());
}
}
@ -530,49 +433,20 @@ inline void renderPage2ToSprite(TFT_eSprite &s, int x_offset, int y_slice,
s.fillRoundRect(bx, by, bw, bh, 6, 0x18C3);
s.drawRoundRect(bx, by, bw, bh, 6, cardBorder);
if (isYapaTheme()) {
s.fillRoundRect(bx, by, bw, 24, 6, 0x3A53);
s.fillRect(bx, by + 18, bw, 6, 0x3A53);
uint8_t mIdx = (gpsMonth >= 1 && gpsMonth <= 12) ? (gpsMonth - 1) : 0;
String mShort = SPANISH_MONTHS_SHORT[mIdx];
int totalW = s.textWidth(mShort.c_str(), 2);
int startX = bx + (bw - totalW) / 2;
char buf[2] = {0, 0};
for (size_t i = 0; i < mShort.length(); i++) {
buf[0] = mShort[i];
s.setTextColor(getYapaColor(i), 0x3A53);
s.drawString(buf, startX, by + 4, 2);
startX += s.textWidth(buf, 2);
}
// Header strip
s.fillRoundRect(bx, by, bw, 24, 6, dateAccCol);
s.fillRect(bx, by + 18, bw, 6, dateAccCol);
uint8_t mIdx = (gpsMonth >= 1 && gpsMonth <= 12) ? (gpsMonth - 1) : 0;
s.setTextColor(TFT_BLACK, dateAccCol);
s.drawCentreString(SPANISH_MONTHS_SHORT[mIdx], bx + (bw / 2), by + 4, 2);
// Badge day number in Yapa
String dayStr = (gpsDay < 10) ? "0" + String(gpsDay) : String(gpsDay);
s.loadFont(DSEG7_Modern_BoldItalic_34);
s.setTextPadding(0);
int dayW = s.textWidth(dayStr.c_str());
int dStartX = bx + (bw - dayW) / 2;
for (size_t i = 0; i < dayStr.length(); i++) {
buf[0] = dayStr[i];
s.setTextColor(getYapaColor(i), 0x18C3);
s.drawString(buf, dStartX, by + 34);
dStartX += s.textWidth(buf);
}
s.unloadFont();
} else {
s.fillRoundRect(bx, by, bw, 24, 6, dateAccCol);
s.fillRect(bx, by + 18, bw, 6, dateAccCol);
uint8_t mIdx = (gpsMonth >= 1 && gpsMonth <= 12) ? (gpsMonth - 1) : 0;
s.setTextColor(TFT_BLACK, dateAccCol);
s.drawCentreString(SPANISH_MONTHS_SHORT[mIdx], bx + (bw / 2), by + 4, 2);
// Badge day number
String dayStr = (gpsDay < 10) ? "0" + String(gpsDay) : String(gpsDay);
s.fontLoaded = true;
s.setTextColor(TFT_WHITE, 0x18C3);
s.setTextPadding(0);
s.drawCentreString(dayStr.c_str(), bx + (bw / 2), by + 34, 1);
s.fontLoaded = false;
}
// Badge day number
String dayStr = (gpsDay < 10) ? "0" + String(gpsDay) : String(gpsDay);
s.fontLoaded = true;
s.setTextColor(TFT_WHITE, 0x18C3);
s.setTextPadding(0);
s.drawCentreString(dayStr.c_str(), bx + (bw / 2), by + 34, 1);
s.fontLoaded = false;
}
int tx = dateX + 116;

181
sketch/obd2_gauge/gps_nav.h
View file

@ -5,14 +5,12 @@
#include "gps_module.h"
#include "DSEG7_Modern_BoldItalic_34.h"
#include "rainbow_text.h"
#include "coords_font.h"
extern TFT_eSPI tft;
extern uint16_t getThemePrimaryColor();
extern uint16_t getThemeAccentColor();
extern uint16_t getThemeBgColor();
extern bool isRainbowTheme();
extern bool isYapaTheme();
extern int8_t currentScreenPage;
extern int8_t fullScreenCell;
@ -95,20 +93,20 @@ inline void drawGpsNavScreen(int x_offset = 0) {
uint16_t priCol = getThemePrimaryColor();
uint16_t accCol = getThemeAccentColor();
uint16_t c0Col = isRainbowTheme() ? (uint16_t)0x07FF : (isYapaTheme() ? getYapaColor(0) : priCol);
uint16_t c1Col = isRainbowTheme() ? (uint16_t)0x07E0 : (isYapaTheme() ? getYapaColor(1) : accCol);
uint16_t c2Col = isRainbowTheme() ? (uint16_t)0xFFE0 : (isYapaTheme() ? getYapaColor(2) : priCol);
uint16_t c3Col = isRainbowTheme() ? (uint16_t)0xFD20 : (isYapaTheme() ? getYapaColor(3) : accCol);
uint16_t c0Col = isRainbowTheme() ? (uint16_t)0x07FF : priCol;
uint16_t c1Col = isRainbowTheme() ? (uint16_t)0x07E0 : accCol;
uint16_t c2Col = isRainbowTheme() ? (uint16_t)0xFFE0 : priCol;
uint16_t c3Col = isRainbowTheme() ? (uint16_t)0xFD20 : accCol;
uint16_t cardBg = 0x10A2; // Dark graphite navy
uint16_t cardBorder = 0x2945; // Subtle edge border
bool synced = isGpsSynced();
// Center: 5 Pagination Indicator Dots [○ ○ ○ ● ○] (Page 3 of 5 active)
tft.fillCircle(132 + x_offset, 2, 2, 0x5AEB); // Page 0 inactive
tft.fillCircle(146 + x_offset, 2, 2, 0x5AEB); // Page 1 inactive
tft.fillCircle(160 + x_offset, 2, 2, 0x5AEB); // Page 2 inactive
tft.fillCircle(174 + x_offset, 2, 2, priCol); // Page 3 active
tft.fillCircle(188 + x_offset, 2, 2, 0x5AEB); // Page 4 inactive
// 1. TOP BAR (y = 0 to 18)
// Center: 4 Pagination Indicator Dots [○ ○ ○ ●] (Page 4 active)
tft.fillCircle(139 + x_offset, 2, 2, 0x5AEB); // Page 1 inactive
tft.fillCircle(153 + x_offset, 2, 2, 0x5AEB); // Page 2 inactive
tft.fillCircle(167 + x_offset, 2, 2, 0x5AEB); // Page 3 inactive
tft.fillCircle(181 + x_offset, 2, 2, priCol); // Page 4 active
// 2. CARD 0 (Top Left): ALTITUD (x = 4, y = 19, w = 152, h = 102)
int c0X = 4 + x_offset;
@ -119,8 +117,10 @@ inline void drawGpsNavScreen(int x_offset = 0) {
tft.drawRoundRect(c0X, c0Y, cW, cH1, 6, cardBorder);
tft.fillRoundRect(c0X + 6, c0Y + 8, 4, cH1 - 16, 2, c0Col);
drawGpsNavTitle(tft, "ALTITUD", c0X + 16, c0Y + 8, 0x8410, cardBg, 240);
drawGpsNavSubword(tft, "MSNM", c0X + 96, c0Y + 9, 0x9CD3, cardBg, 240);
tft.setTextColor(0x8410, cardBg);
tft.drawString("ALTITUD", c0X + 16, c0Y + 8, 2);
tft.setTextColor(0x9CD3, cardBg);
tft.drawString("MSNM", c0X + 96, c0Y + 8, 2);
bool altValid = isGpsAltitudeValid();
String altStr = altValid ? String((int)round(gpsAltitudeM)) : "---";
@ -133,7 +133,8 @@ inline void drawGpsNavScreen(int x_offset = 0) {
tft.drawRoundRect(c1X, c1Y, cW, cH1, 6, cardBorder);
tft.fillRoundRect(c1X + 6, c1Y + 8, 4, cH1 - 16, 2, c1Col);
drawGpsNavTitle(tft, "RUMBO / BRUJULA", c1X + 16, c1Y + 8, 0x8410, cardBg, 240);
tft.setTextColor(0x8410, cardBg);
tft.drawString("RUMBO / BRUJULA", c1X + 16, c1Y + 8, 2);
bool hasCourse = synced && isGpsCourseValid();
String crsStr = hasCourse ? String((int)round(gpsCourseDeg)) : "---";
@ -146,7 +147,8 @@ inline void drawGpsNavScreen(int x_offset = 0) {
}
const char* cardDir = hasCourse ? getCompassDirectionFull(gpsCourseDeg) : "---";
drawGpsNavSubword(tft, cardDir, c1X + 16, c1Y + 76, TFT_WHITE, cardBg, 240);
tft.setTextColor(TFT_WHITE, cardBg);
tft.drawString(cardDir, c1X + 16, c1Y + 74, 2);
// 4. CARD 2 (Bottom Left): SATÉLITES GPS EN GRANDE (x = 4, y = 125, w = 152, h = 110)
int c2X = 4 + x_offset;
@ -156,7 +158,8 @@ inline void drawGpsNavScreen(int x_offset = 0) {
tft.drawRoundRect(c2X, c2Y, cW, cH2, 6, cardBorder);
tft.fillRoundRect(c2X + 6, c2Y + 8, 4, cH2 - 16, 2, c2Col);
drawGpsNavTitle(tft, "SATELITES GPS", c2X + 16, c2Y + 8, 0x8410, cardBg, 240);
tft.setTextColor(0x8410, cardBg);
tft.drawString("SATELITES GPS", c2X + 16, c2Y + 8, 2);
// Large Satellite Icon (animated body + waves)
uint8_t waveState = getGpsWaveAnimState();
@ -168,9 +171,11 @@ inline void drawGpsNavScreen(int x_offset = 0) {
// Telemetry details: HDOP precision & live diagnostic status
String hdopStr = "HDOP: " + (synced ? String(gpsHdop, 1) : "---");
drawGpsNavSubword(tft, hdopStr.c_str(), c2X + 16, c2Y + 70, TFT_WHITE, cardBg, 240);
tft.setTextColor(TFT_WHITE, cardBg);
tft.drawString(hdopStr.c_str(), c2X + 16, c2Y + 68, 2);
drawGpsNavSubword(tft, getGpsDiagMessage(), c2X + 16, c2Y + 90, synced ? 0x9CD3 : priCol, cardBg, 240);
tft.setTextColor(synced ? 0x9CD3 : priCol, cardBg);
tft.drawString(getGpsDiagMessage(), c2X + 16, c2Y + 90, 1);
// 5. CARD 3 (Bottom Right): COORDENADAS GPS (x = 164, y = 125, w = 152, h = 110)
int c3X = 164 + x_offset;
@ -179,15 +184,20 @@ inline void drawGpsNavScreen(int x_offset = 0) {
tft.drawRoundRect(c3X, c3Y, cW, cH2, 6, cardBorder);
tft.fillRoundRect(c3X + 6, c3Y + 8, 4, cH2 - 16, 2, c3Col);
drawGpsNavTitle(tft, "COORDENADAS", c3X + 16, c3Y + 8, 0x8410, cardBg, 240);
tft.setTextColor(0x8410, cardBg);
tft.drawString("COORDENADAS", c3X + 16, c3Y + 8, 2);
drawGpsNavSubword(tft, "LATITUD", c3X + 16, c3Y + 24, 0x8410, cardBg, 240);
tft.setTextColor(0x8410, cardBg);
tft.drawString("LAT", c3X + 16, c3Y + 26, 1);
String latStr = gpsLocationValid ? (String(gpsLatitude, 5) + "°") : "--.-----°";
drawCoordsAAValue(tft, latStr.c_str(), c3X + 16, c3Y + 38, c3Col, cardBg, 240);
tft.setTextColor(c3Col, cardBg);
tft.drawString(latStr.c_str(), c3X + 16, c3Y + 38, 2);
drawGpsNavSubword(tft, "LONGITUD", c3X + 16, c3Y + 62, 0x8410, cardBg, 240);
tft.setTextColor(0x8410, cardBg);
tft.drawString("LON", c3X + 16, c3Y + 64, 1);
String lonStr = gpsLocationValid ? (String(gpsLongitude, 5) + "°") : "--.-----°";
drawCoordsAAValue(tft, lonStr.c_str(), c3X + 16, c3Y + 76, c3Col, cardBg, 240);
tft.setTextColor(c3Col, cardBg);
tft.drawString(lonStr.c_str(), c3X + 16, c3Y + 76, 2);
// Sync state trackers
syncGpsNavTrackers();
@ -207,10 +217,10 @@ inline void updateGpsNavScreen(bool forceRedraw = false) {
uint16_t priCol = getThemePrimaryColor();
uint16_t accCol = getThemeAccentColor();
uint16_t c0Col = isRainbowTheme() ? (uint16_t)0x07FF : (isYapaTheme() ? getYapaColor(0) : priCol);
uint16_t c1Col = isRainbowTheme() ? (uint16_t)0x07E0 : (isYapaTheme() ? getYapaColor(1) : accCol);
uint16_t c2Col = isRainbowTheme() ? (uint16_t)0xFFE0 : (isYapaTheme() ? getYapaColor(2) : priCol);
uint16_t c3Col = isRainbowTheme() ? (uint16_t)0xFD20 : (isYapaTheme() ? getYapaColor(3) : accCol);
uint16_t c0Col = isRainbowTheme() ? (uint16_t)0x07FF : priCol;
uint16_t c1Col = isRainbowTheme() ? (uint16_t)0x07E0 : accCol;
uint16_t c2Col = isRainbowTheme() ? (uint16_t)0xFFE0 : priCol;
uint16_t c3Col = isRainbowTheme() ? (uint16_t)0xFD20 : accCol;
uint16_t cardBg = 0x10A2;
bool synced = isGpsSynced();
@ -252,8 +262,10 @@ inline void updateGpsNavScreen(bool forceRedraw = false) {
const char* cardDir = hasCourse ? getCompassDirectionFull(gpsCourseDeg) : "---";
if (forceRedraw || strcmp(cardDir, lastNavCardDir) != 0) {
lastNavCardDir = cardDir;
tft.fillRect(c1X + 16, c1Y + 74, 128, 16, cardBg);
drawGpsNavSubword(tft, cardDir, c1X + 16, c1Y + 76, TFT_WHITE, cardBg, 240);
tft.setTextPadding(128);
tft.setTextColor(TFT_WHITE, cardBg);
tft.drawString(cardDir, c1X + 16, c1Y + 74, 2);
tft.setTextPadding(0);
}
// 3. Card 2: Satellites, HDOP and Diagnostic status
@ -276,8 +288,10 @@ inline void updateGpsNavScreen(bool forceRedraw = false) {
lastNavCardHdop = gpsHdop;
oldNavHdop = gpsHdop;
String hdopStr = "HDOP: " + (synced ? String(gpsHdop, 1) : "---");
tft.fillRect(c2X + 16, c2Y + 68, 130, 16, cardBg);
drawGpsNavSubword(tft, hdopStr.c_str(), c2X + 16, c2Y + 70, TFT_WHITE, cardBg, 240);
tft.setTextPadding(130);
tft.setTextColor(TFT_WHITE, cardBg);
tft.drawString(hdopStr.c_str(), c2X + 16, c2Y + 68, 2);
tft.setTextPadding(0);
}
// 3c. Diagnostic status message ("PRECISION OPTIMA", "SIN SEÑAL GPS", etc.)
@ -287,8 +301,10 @@ inline void updateGpsNavScreen(bool forceRedraw = false) {
strncpy(lastNavCardDiag, curDiag, sizeof(lastNavCardDiag) - 1);
lastNavCardDiag[sizeof(lastNavCardDiag) - 1] = '\0';
lastNavDiagSynced = synced;
tft.fillRect(c2X + 16, c2Y + 88, 130, 16, cardBg);
drawGpsNavSubword(tft, curDiag, c2X + 16, c2Y + 90, synced ? 0x9CD3 : c2Col, cardBg, 240);
tft.setTextPadding(130);
tft.setTextColor(synced ? 0x9CD3 : c2Col, cardBg);
tft.drawString(curDiag, c2X + 16, c2Y + 90, 1);
tft.setTextPadding(0);
}
// 3d. Large Satellite Icon: only redrawn if waveState or sync changes
@ -299,20 +315,20 @@ inline void updateGpsNavScreen(bool forceRedraw = false) {
drawLargeSatelliteIcon(c2X + 16, c2Y + 32, c2Col, curWaveState, cardBg);
}
// 4. Coordinates changed: update Card 3 (clear exact value region and redraw anti-aliased value)
// 4. Coordinates changed: update Card 3 (setTextPadding avoids fillRect flicker)
if (forceRedraw || abs(gpsLatitude - oldNavLat) >= 0.00005 || abs(gpsLongitude - oldNavLon) >= 0.00005) {
oldNavLat = gpsLatitude;
oldNavLon = gpsLongitude;
int c3X = 164;
int c3Y = 125;
String latStr = gpsLocationValid ? (String(gpsLatitude, 5) + "°") : "--.-----°";
tft.setTextPadding(130);
tft.setTextColor(c3Col, cardBg);
tft.drawString(latStr.c_str(), c3X + 16, c3Y + 38, 2);
String lonStr = gpsLocationValid ? (String(gpsLongitude, 5) + "°") : "--.-----°";
tft.fillRect(c3X + 16, c3Y + 38, 130, 20, cardBg);
drawCoordsAAValue(tft, latStr.c_str(), c3X + 16, c3Y + 38, c3Col, cardBg, 240);
tft.fillRect(c3X + 16, c3Y + 76, 130, 20, cardBg);
drawCoordsAAValue(tft, lonStr.c_str(), c3X + 16, c3Y + 76, c3Col, cardBg, 240);
tft.drawString(lonStr.c_str(), c3X + 16, c3Y + 76, 2);
tft.setTextPadding(0);
}
}
@ -320,10 +336,10 @@ inline void updateGpsNavScreen(bool forceRedraw = false) {
inline void renderPage3ToSprite(TFT_eSprite &s, int x_offset, int y_slice, int slice_h) {
uint16_t priCol = getThemePrimaryColor();
uint16_t accCol = getThemeAccentColor();
uint16_t c0Col = isRainbowTheme() ? (uint16_t)0x07FF : (isYapaTheme() ? getYapaColor(0) : priCol);
uint16_t c1Col = isRainbowTheme() ? (uint16_t)0x07E0 : (isYapaTheme() ? getYapaColor(1) : accCol);
uint16_t c2Col = isRainbowTheme() ? (uint16_t)0xFFE0 : (isYapaTheme() ? getYapaColor(2) : priCol);
uint16_t c3Col = isRainbowTheme() ? (uint16_t)0xFD20 : (isYapaTheme() ? getYapaColor(3) : accCol);
uint16_t c0Col = isRainbowTheme() ? (uint16_t)0x07FF : priCol;
uint16_t c1Col = isRainbowTheme() ? (uint16_t)0x07E0 : accCol;
uint16_t c2Col = isRainbowTheme() ? (uint16_t)0xFFE0 : priCol;
uint16_t c3Col = isRainbowTheme() ? (uint16_t)0xFD20 : accCol;
uint16_t cardBg = 0x10A2;
uint16_t cardBorder = 0x2945;
bool synced = isGpsSynced();
@ -338,8 +354,12 @@ inline void renderPage3ToSprite(TFT_eSprite &s, int x_offset, int y_slice, int s
s.drawRoundRect(c0X, c0Y, cW, cH1, 6, cardBorder);
s.fillRoundRect(c0X + 6, c0Y + 8, 4, cH1 - 16, 2, c0Col);
drawGpsNavTitle(s, "ALTITUD", c0X + 16, c0Y + 8, 0x8410, cardBg, slice_h);
drawGpsNavSubword(s, "MSNM", c0X + 96, c0Y + 9, 0x9CD3, cardBg, slice_h);
if (c0Y + 24 > 0 && c0Y + 8 < slice_h) {
s.setTextColor(0x8410, cardBg);
s.drawString("ALTITUD", c0X + 16, c0Y + 8, 2);
s.setTextColor(0x9CD3, cardBg);
s.drawString("MSNM", c0X + 96, c0Y + 8, 2);
}
bool altValid = isGpsAltitudeValid();
String altStr = altValid ? String((int)round(gpsAltitudeM)) : "---";
int valY = c0Y + 28;
@ -356,7 +376,10 @@ inline void renderPage3ToSprite(TFT_eSprite &s, int x_offset, int y_slice, int s
s.drawRoundRect(c1X, c1Y, cW, cH1, 6, cardBorder);
s.fillRoundRect(c1X + 6, c1Y + 8, 4, cH1 - 16, 2, c1Col);
drawGpsNavTitle(s, "RUMBO / BRUJULA", c1X + 16, c1Y + 8, 0x8410, cardBg, slice_h);
if (c1Y + 24 > 0 && c1Y + 8 < slice_h) {
s.setTextColor(0x8410, cardBg);
s.drawString("RUMBO / BRUJULA", c1X + 16, c1Y + 8, 2);
}
bool hasCourse = synced && isGpsCourseValid();
String crsStr = hasCourse ? String((int)round(gpsCourseDeg)) : "---";
int valY = c1Y + 28;
@ -370,8 +393,12 @@ inline void renderPage3ToSprite(TFT_eSprite &s, int x_offset, int y_slice, int s
}
}
}
const char* cardDir = hasCourse ? getCompassDirectionFull(gpsCourseDeg) : "---";
drawGpsNavSubword(s, cardDir, c1X + 16, c1Y + 76, TFT_WHITE, cardBg, slice_h);
int dirY = c1Y + 74;
if (dirY + 16 > 0 && dirY < slice_h) {
const char* cardDir = hasCourse ? getCompassDirectionFull(gpsCourseDeg) : "---";
s.setTextColor(TFT_WHITE, cardBg);
s.drawString(cardDir, c1X + 16, dirY, 2);
}
}
// 4. CARD 2 (Bottom Left): SATÉLITES GPS (y = 125 to 235)
@ -383,7 +410,10 @@ inline void renderPage3ToSprite(TFT_eSprite &s, int x_offset, int y_slice, int s
s.drawRoundRect(c2X, c2Y, cW, cH2, 6, cardBorder);
s.fillRoundRect(c2X + 6, c2Y + 8, 4, cH2 - 16, 2, c2Col);
drawGpsNavTitle(s, "SATELITES GPS", c2X + 16, c2Y + 8, 0x8410, cardBg, slice_h);
if (c2Y + 24 > 0 && c2Y + 8 < slice_h) {
s.setTextColor(0x8410, cardBg);
s.drawString("SATELITES GPS", c2X + 16, c2Y + 8, 2);
}
uint8_t waveState = getGpsWaveAnimState();
int icnY = c2Y + 32;
if (icnY + 28 > 0 && icnY < slice_h) {
@ -394,9 +424,17 @@ inline void renderPage3ToSprite(TFT_eSprite &s, int x_offset, int y_slice, int s
String satStr = isGpsUartLocked() ? String(gpsSats) : "---";
drawDseg7RightString34(s, satStr.c_str(), c2X + 140, satY, c2Col, cardBg, 0, slice_h, isRainbowTheme());
}
String hdopStr = "HDOP: " + (synced ? String(gpsHdop, 1) : "---");
drawGpsNavSubword(s, hdopStr.c_str(), c2X + 16, c2Y + 70, TFT_WHITE, cardBg, slice_h);
drawGpsNavSubword(s, getGpsDiagMessage(), c2X + 16, c2Y + 90, synced ? 0x9CD3 : c2Col, cardBg, slice_h);
int hdopY = c2Y + 68;
if (hdopY < slice_h && hdopY + 16 > 0) {
String hdopStr = "HDOP: " + (synced ? String(gpsHdop, 1) : "---");
s.setTextColor(TFT_WHITE, cardBg);
s.drawString(hdopStr.c_str(), c2X + 16, hdopY, 2);
}
int qualY = c2Y + 90;
if (qualY + 10 > 0 && qualY < slice_h) {
s.setTextColor(synced ? 0x9CD3 : c2Col, cardBg);
s.drawString(getGpsDiagMessage(), c2X + 16, qualY, 1);
}
}
// 5. CARD 3 (Bottom Right): COORDENADAS (y = 125 to 235)
@ -407,14 +445,31 @@ inline void renderPage3ToSprite(TFT_eSprite &s, int x_offset, int y_slice, int s
s.drawRoundRect(c3X, c3Y, cW, cH2, 6, cardBorder);
s.fillRoundRect(c3X + 6, c3Y + 8, 4, cH2 - 16, 2, c3Col);
drawGpsNavTitle(s, "COORDENADAS", c3X + 16, c3Y + 8, 0x8410, cardBg, slice_h);
drawGpsNavSubword(s, "LATITUD", c3X + 16, c3Y + 24, 0x8410, cardBg, slice_h);
String latStr = gpsLocationValid ? (String(gpsLatitude, 5) + "°") : "--.-----°";
drawCoordsAAValue(s, latStr.c_str(), c3X + 16, c3Y + 38, c3Col, cardBg, slice_h);
drawGpsNavSubword(s, "LONGITUD", c3X + 16, c3Y + 62, 0x8410, cardBg, slice_h);
String lonStr = gpsLocationValid ? (String(gpsLongitude, 5) + "°") : "--.-----°";
drawCoordsAAValue(s, lonStr.c_str(), c3X + 16, c3Y + 76, c3Col, cardBg, slice_h);
if (c3Y + 24 > 0 && c3Y + 8 < slice_h) {
s.setTextColor(0x8410, cardBg);
s.drawString("COORDENADAS", c3X + 16, c3Y + 8, 2);
}
int latHdrY = c3Y + 26;
if (latHdrY < slice_h && latHdrY + 10 > 0) {
s.setTextColor(0x8410, cardBg);
s.drawString("LAT", c3X + 16, latHdrY, 1);
}
int latValY = c3Y + 38;
if (latValY < slice_h && latValY + 18 > 0) {
String latStr = gpsLocationValid ? (String(gpsLatitude, 5) + "°") : "--.-----°";
s.setTextColor(c3Col, cardBg);
s.drawString(latStr.c_str(), c3X + 16, latValY, 2);
}
int lonHdrY = c3Y + 64;
if (lonHdrY < slice_h && lonHdrY + 10 > 0) {
s.setTextColor(0x8410, cardBg);
s.drawString("LON", c3X + 16, lonHdrY, 1);
}
int lonValY = c3Y + 76;
if (lonValY < slice_h && lonValY + 18 > 0) {
String lonStr = gpsLocationValid ? (String(gpsLongitude, 5) + "°") : "--.-----°";
s.setTextColor(c3Col, cardBg);
s.drawString(lonStr.c_str(), c3X + 16, lonValY, 2);
}
}
}

243
sketch/obd2_gauge/meter.h
View file

@ -11,9 +11,6 @@ extern bool sprTransAllocated;
extern TFT_eSprite sprFadeB;
extern bool sprFadeBAllocated;
extern uint8_t targetBacklight;
extern float currentBacklight;
const uint16_t screenWidth = tft.height(); // landscape
const uint16_t screenHeight = tft.width();
/*---- METER ------_*
@ -242,14 +239,8 @@ void drawFullScreenTitle(const String &label, uint16_t color) {
tft.drawFastHLine(60, y, 195, bgCol);
}
if (color != 0) {
if (color == TFT_WHITE && isYapaTheme()) {
drawYapaCentreString(label, 175, 12, 4);
} else if (color == TFT_WHITE && isRainbowTheme()) {
drawRainbowCentreString(label.c_str(), 175, 12, 4);
} else {
tft.setTextColor(color);
tft.drawCentreString(label.c_str(), 175, 12, 4);
}
tft.setTextColor(color);
tft.drawCentreString(label.c_str(), 175, 12, 4);
}
}
@ -1301,14 +1292,8 @@ void fullScreenMeter(uint8_t cell, uint8_t pid, bool redrawHeader = true) {
alarmEnabled[pid])
? TFT_RED
: TFT_WHITE;
if (titleCol == TFT_WHITE && isYapaTheme()) {
drawYapaCentreString(label, 175, 12, 4);
} else if (titleCol == TFT_WHITE && isRainbowTheme()) {
drawRainbowCentreString(label.c_str(), 175, 12, 4);
} else {
tft.setTextColor(titleCol);
tft.drawCentreString(label, 175, 12, 4);
}
tft.setTextColor(titleCol);
tft.drawCentreString(label, 175, 12, 4);
if (cell == 1 && isGpsSpeedValid()) {
drawFullscreenGpsIcon(getGpsWaveAnimState(), isGpsSynced());
}
@ -1765,12 +1750,8 @@ inline void renderPage1ToSprite(TFT_eSprite &s, int x_offset, int y_slice,
s.setTextColor(TFT_WHITE, cardBg);
s.drawString(titleStr, cardX + 16, cardY + 5, 4);
}
if (isYapaTheme()) {
drawYapaStringToSprite(s, subStr, cardX + 16, cardY + 32, 1);
} else {
s.setTextColor(0x8410, cardBg);
s.drawString(subStr, cardX + 16, cardY + 32, 1);
}
s.setTextColor(0x8410, cardBg);
s.drawString(subStr, cardX + 16, cardY + 32, 1);
// Progress bar
int barX = cardX + 16;
@ -1798,84 +1779,132 @@ inline void renderPage1ToSprite(TFT_eSprite &s, int x_offset, int y_slice,
int unitY = cardY + 22;
if (unitY < slice_h && unitY + 26 > 0) {
bool rainbowUnit = isRainbowTheme() && (accentCol != TFT_RED);
uint16_t unitCol = rainbowUnit ? getRainbowScreenColor(cardX + 268, unitY) : (isYapaTheme() && accentCol != TFT_RED ? getYapaColor(numStr.length()) : (accentCol == TFT_RED ? TFT_RED : 0xC618));
draw7SegDegreeC(s, cardX + 268, unitY, unitCol, cardBg, rainbowUnit);
draw7SegDegreeC(s, cardX + 268, unitY, 0xC618, cardBg);
}
}
}
// 100% Flicker-Free Backlight Dip / Fade-to-Black Transition
// Fades hardware backlight smoothly to black, renders the new page invisibly
// in the dark with zero tear, and smoothly restores backlight.
inline void animateBlackTransition(int8_t toPage = -1) {
// 100% Flicker-Free Double-Buffered Mobile Slide Transition
// Safe 25KB sprite with pixel-perfect clipping and smooth ease-out pacing
inline void animateSlideTransition(bool swipeLeft, int8_t fromPage = -1,
int8_t toPage = -1) {
if (fromPage < 0)
fromPage = currentScreenPage;
if (toPage < 0)
toPage = (currentScreenPage + 1) % 4;
toPage = (fromPage == 0) ? 1 : 0;
#ifdef SERIAL_DEBUG
Serial.printf(">>> [DB] animateSlideTransition ENTER: fromPage=%d, "
"toPage=%d, swipeLeft=%d\n",
fromPage, toPage, swipeLeft);
#endif
const int slice_h = 40;
const uint8_t numSlices = 240 / slice_h; // exactly 6 slices
if (!sprTransAllocated) {
initScreen(true);
return;
return; // Safety fallback
}
uint8_t startBrightness = (uint8_t)currentBacklight;
if (startBrightness < 20)
startBrightness = 20;
const uint8_t FRAMES = 28;
// High-density sine ease-out deceleration over 28 frames:
// Ultra-fine 10-18px initial steps smoothly tapering to 1-3px for zero
// visible refresh chop
const int16_t step_shifts[FRAMES] = {
18, 36, 54, 71, 89, 106, 122, 139, 155, 170, 185, 200, 213, 226,
239, 250, 261, 271, 280, 288, 296, 302, 307, 312, 315, 318, 319, 320};
// 1. Smoothly fade backlight down to black in ~200ms (quadratic ease for natural eye response)
const uint8_t fadeSteps = 16;
for (int8_t i = fadeSteps - 1; i >= 0; i--) {
float t = (float)i / (float)fadeSteps;
uint8_t b = (uint8_t)(startBrightness * (t * t));
ledcWrite(backlightChannel, b);
delay(12);
}
ledcWrite(backlightChannel, 0);
for (uint8_t f = 0; f < FRAMES; f++) {
int16_t shift = step_shifts[f];
int16_t splitX = swipeLeft ? (320 - shift) : shift;
// 2. Render new screen slice-by-slice while backlight is totally off (100% invisible redraw)
const int slice_h = 40;
const uint8_t numSlices = 240 / slice_h; // exactly 6 slices
for (uint8_t s = 0; s < numSlices; s++) {
int y_slice = s * slice_h;
sprTrans.fillSprite(TFT_BLACK);
for (uint8_t s = 0; s < numSlices; s++) {
int y_slice = s * slice_h;
if (toPage == 0)
renderPage0ToSprite(sprTrans, 0, y_slice, slice_h);
else if (toPage == 1)
renderPage1ToSprite(sprTrans, 0, y_slice, slice_h);
else if (toPage == 2)
renderPage2ToSprite(sprTrans, 0, y_slice, slice_h);
else if (toPage == 3)
renderPage3ToSprite(sprTrans, 0, y_slice, slice_h);
else
renderPage4ToSprite(sprTrans, 0, y_slice, slice_h);
sprTrans.fillSprite(TFT_BLACK);
// Pagination indicator dots on top slice (5 dots for 5 pages)
if (y_slice == 0) {
sprTrans.fillCircle(132, 2, 2,
(toPage == 0) ? getThemePrimaryColor() : 0x5AEB);
sprTrans.fillCircle(146, 2, 2,
(toPage == 1) ? getThemePrimaryColor() : 0x5AEB);
sprTrans.fillCircle(160, 2, 2,
(toPage == 2) ? getThemePrimaryColor() : 0x5AEB);
sprTrans.fillCircle(174, 2, 2,
(toPage == 3) ? getThemePrimaryColor() : 0x5AEB);
sprTrans.fillCircle(188, 2, 2,
(toPage == 4) ? getThemePrimaryColor() : 0x5AEB);
if (swipeLeft) {
// Swipe Left: fromPage on left moving left, toPage on right moving left
if (splitX > 0) {
sprTrans.setViewport(0, 0, splitX, slice_h, false);
if (fromPage == 0)
renderPage0ToSprite(sprTrans, -shift, y_slice, slice_h);
else if (fromPage == 1)
renderPage1ToSprite(sprTrans, -shift, y_slice, slice_h);
else if (fromPage == 2)
renderPage2ToSprite(sprTrans, -shift, y_slice, slice_h);
else
renderPage3ToSprite(sprTrans, -shift, y_slice, slice_h);
}
if (splitX < 320) {
sprTrans.setViewport(splitX, 0, 320 - splitX, slice_h, false);
if (toPage == 0)
renderPage0ToSprite(sprTrans, 320 - shift, y_slice, slice_h);
else if (toPage == 1)
renderPage1ToSprite(sprTrans, 320 - shift, y_slice, slice_h);
else if (toPage == 2)
renderPage2ToSprite(sprTrans, 320 - shift, y_slice, slice_h);
else
renderPage3ToSprite(sprTrans, 320 - shift, y_slice, slice_h);
}
} else {
// Swipe Right: toPage on left moving right, fromPage on right moving
// right
if (splitX > 0) {
sprTrans.setViewport(0, 0, splitX, slice_h, false);
if (toPage == 0)
renderPage0ToSprite(sprTrans, shift - 320, y_slice, slice_h);
else if (toPage == 1)
renderPage1ToSprite(sprTrans, shift - 320, y_slice, slice_h);
else if (toPage == 2)
renderPage2ToSprite(sprTrans, shift - 320, y_slice, slice_h);
else
renderPage3ToSprite(sprTrans, shift - 320, y_slice, slice_h);
}
if (splitX < 320) {
sprTrans.setViewport(splitX, 0, 320 - splitX, slice_h, false);
if (fromPage == 0)
renderPage0ToSprite(sprTrans, shift, y_slice, slice_h);
else if (fromPage == 1)
renderPage1ToSprite(sprTrans, shift, y_slice, slice_h);
else if (fromPage == 2)
renderPage2ToSprite(sprTrans, shift, y_slice, slice_h);
else
renderPage3ToSprite(sprTrans, shift, y_slice, slice_h);
}
}
sprTrans.resetViewport();
// Dividing neon seam line
if (splitX > 0 && splitX < 320) {
sprTrans.drawFastVLine(splitX, 0, slice_h, getThemePrimaryColor());
int16_t whiteLineX = splitX + (swipeLeft ? 1 : -1);
if (whiteLineX >= 0 && whiteLineX < 320) {
sprTrans.drawFastVLine(whiteLineX, 0, slice_h, TFT_WHITE);
}
}
// Pagination indicator dots on top slice (4 dots for 4 pages)
if (y_slice == 0) {
uint8_t activeDot = (shift < 160) ? fromPage : toPage;
sprTrans.fillCircle(139, 2, 2,
(activeDot == 0) ? getThemePrimaryColor() : 0x5AEB);
sprTrans.fillCircle(153, 2, 2,
(activeDot == 1) ? getThemePrimaryColor() : 0x5AEB);
sprTrans.fillCircle(167, 2, 2,
(activeDot == 2) ? getThemePrimaryColor() : 0x5AEB);
sprTrans.fillCircle(181, 2, 2,
(activeDot == 3) ? getThemePrimaryColor() : 0x5AEB);
}
// Direct single SPI push per slice: ZERO visual flicker!
sprTrans.pushSprite(0, y_slice);
yield();
}
sprTrans.pushSprite(0, y_slice);
yield(); // Feed watchdog and let Bluetooth run smoothly on background core
delay(7); // Ultra-smooth high density pacing (~330ms total)
}
// 3. Smoothly fade backlight back up to original level in ~200ms
for (uint8_t i = 1; i <= fadeSteps; i++) {
float t = (float)i / (float)fadeSteps;
uint8_t b = (uint8_t)(startBrightness * (t * t));
ledcWrite(backlightChannel, b);
delay(12);
}
currentBacklight = (float)startBrightness;
ledcWrite(backlightChannel, (uint32_t)targetBacklight);
sprTrans.fontLoaded = false;
}
@ -1920,10 +1949,8 @@ inline void animateFadeTransition(int8_t fromPage = -1, int8_t toPage = -1) {
renderPage1ToSprite(sprTrans, 0, y_slice, slice_h);
else if (fromPage == 2)
renderPage2ToSprite(sprTrans, 0, y_slice, slice_h);
else if (fromPage == 3)
renderPage3ToSprite(sprTrans, 0, y_slice, slice_h);
else
renderPage4ToSprite(sprTrans, 0, y_slice, slice_h);
renderPage3ToSprite(sprTrans, 0, y_slice, slice_h);
if (toPage == 0)
renderPage0ToSprite(sprFadeB, 0, y_slice, slice_h);
@ -1931,10 +1958,8 @@ inline void animateFadeTransition(int8_t fromPage = -1, int8_t toPage = -1) {
renderPage1ToSprite(sprFadeB, 0, y_slice, slice_h);
else if (toPage == 2)
renderPage2ToSprite(sprFadeB, 0, y_slice, slice_h);
else if (toPage == 3)
renderPage3ToSprite(sprFadeB, 0, y_slice, slice_h);
else
renderPage4ToSprite(sprFadeB, 0, y_slice, slice_h);
renderPage3ToSprite(sprFadeB, 0, y_slice, slice_h);
uint16_t *pA = (uint16_t *)sprTrans.getPointer();
uint16_t *pB = (uint16_t *)sprFadeB.getPointer();
@ -1964,19 +1989,17 @@ inline void animateFadeTransition(int8_t fromPage = -1, int8_t toPage = -1) {
}
}
// Pagination indicator dots on top slice (5 dots for 5 pages)
// Pagination indicator dots on top slice (4 dots for 4 pages)
if (y_slice == 0) {
uint8_t activeDot = (alpha < 16) ? fromPage : toPage;
sprTrans.fillCircle(132, 2, 2,
sprTrans.fillCircle(139, 2, 2,
(activeDot == 0) ? getThemePrimaryColor() : 0x5AEB);
sprTrans.fillCircle(146, 2, 2,
sprTrans.fillCircle(153, 2, 2,
(activeDot == 1) ? getThemePrimaryColor() : 0x5AEB);
sprTrans.fillCircle(160, 2, 2,
sprTrans.fillCircle(167, 2, 2,
(activeDot == 2) ? getThemePrimaryColor() : 0x5AEB);
sprTrans.fillCircle(174, 2, 2,
sprTrans.fillCircle(181, 2, 2,
(activeDot == 3) ? getThemePrimaryColor() : 0x5AEB);
sprTrans.fillCircle(188, 2, 2,
(activeDot == 4) ? getThemePrimaryColor() : 0x5AEB);
}
sprTrans.pushSprite(0, y_slice);
@ -1997,11 +2020,11 @@ inline void performScreenTransition(bool swipeLeft, int8_t fromPage = -1,
if (fromPage < 0)
fromPage = currentScreenPage;
if (toPage < 0)
toPage = (fromPage + 1) % 5;
toPage = (fromPage + 1) % 4;
if (transitionType == 1) {
animateFadeTransition(fromPage, toPage);
} else {
animateBlackTransition(toPage);
animateSlideTransition(swipeLeft, fromPage, toPage);
}
}
@ -2036,8 +2059,6 @@ void initScreen(bool redrawTFT) {
syncGpsClockTrackers();
} else if (currentScreenPage == 3) {
syncGpsNavTrackers();
} else if (currentScreenPage == 4) {
syncClusterTrackers();
} else if (currentScreenPage == 0 && fullScreenCell == -1) {
syncPage0Trackers();
}
@ -2072,11 +2093,6 @@ void initScreen(bool redrawTFT) {
Serial.println(">>> [DB] initScreen: drawing drawGpsNavScreen(0)");
#endif
drawGpsNavScreen(0);
} else if (currentScreenPage == 4) {
#ifdef SERIAL_DEBUG
Serial.println(">>> [DB] initScreen: drawing drawClusterScreen(0)");
#endif
drawClusterScreen(0);
} else {
#ifdef SERIAL_DEBUG
Serial.println(">>> [DB] initScreen: drawing Page 0 quadrants");
@ -2087,12 +2103,11 @@ void initScreen(bool redrawTFT) {
arcMeter4(c, pid);
}
drawQuadrantDividers();
// Pagination indicator dots [● ○ ○ ○ ○] (Page 0 active)
tft.fillCircle(132, 2, 2, getThemePrimaryColor());
tft.fillCircle(146, 2, 2, 0x5AEB);
tft.fillCircle(160, 2, 2, 0x5AEB);
tft.fillCircle(174, 2, 2, 0x5AEB);
tft.fillCircle(188, 2, 2, 0x5AEB);
// Pagination indicator dots [● ○ ○ ○] (Page 1 active)
tft.fillCircle(139, 2, 2, getThemePrimaryColor()); // Page 1 active
tft.fillCircle(153, 2, 2, 0x5AEB); // Page 2 inactive
tft.fillCircle(167, 2, 2, 0x5AEB); // Page 3 inactive
tft.fillCircle(181, 2, 2, 0x5AEB); // Page 4 inactive
}
if (currentScreenPage == 0 && fullScreenCell == -1) {
badgeEcoDrawn = false;
@ -2426,8 +2441,6 @@ void updateMeter(uint8_t pidNo, String response) { // update parameter on screen
}
} else if (currentScreenPage == 0) {
plotArc4(pidNo, data, warn, min, max, digit, unit);
} else if (currentScreenPage == 4) {
updateClusterScreen(false);
}
bt_message = ""; // reset
}

78
sketch/obd2_gauge/obd2_gauge.ino
View file

@ -126,7 +126,7 @@ struct GaugeTheme {
uint8_t ledB; // Rear RGB LED Blue (0..255)
};
const GaugeTheme GAUGE_THEMES[9] = {
const GaugeTheme GAUGE_THEMES[6] = {
{"Azul Cian", "Digital Moderno", 0x07FF, 0x03B9, 0x0254, 0x0110, 0x01D3, 0,
180, 255}, // 0: Vivid Electric Cyan
{"Verde Sport", "Cockpit Clasico", 0x07E0, 0x0446, 0x0283, 0x0141, 0x0205,
@ -136,54 +136,47 @@ const GaugeTheme GAUGE_THEMES[9] = {
{"Blanco Puro", "OLED Precision", 0xFFFF, 0x6B6D, 0x4228, 0x18E3, 0x2965,
220, 230, 255}, // 3: Pure Crisp White
{"Naranja Sport", "McLaren Papaya", 0xFD20, 0x9260, 0x5160, 0x20A0, 0x4140,
255, 80, 0}, // 4: Vivid Papaya Orange
255, 80, 0}, // 4: Vivid Papaya Orange (reemplaza rojo)
{"Cyber Violet", "Neon Nightrunner", 0xD1BF, 0x7119, 0x40CE, 0x1846, 0x2869,
200, 0, 255}, // 5: Vivid Electric Violet
{"Rojo Corsa", "Pasion Italiana", 0xF800, 0x8800, 0x5000, 0x2000, 0x3800,
255, 0, 0}, // 6: Vivid Racing Red
{"Ambar BMW", "Cockpit Nocturno", 0xFD60, 0x9380, 0x5240, 0x2100, 0x39A0,
255, 120, 0}, // 7: Warm Golden Amber (BMW classic)
{"Yapa", "Pastillas Pastel", 0xFD79, 0x3A53, 0x52AA, 0x18E5, 0x2168,
255, 190, 220} // 8: Pastillas Yapa Pastel Candies
200, 0, 255} // 5: Vivid Electric Violet
};
uint8_t themeIndex = 0; // Default 0: Azul Cian
uint8_t transitionType =
0; // Default 0: Fundido a Negro (Fade to Black), 1: Desvanecimiento (Fade)
1; // Default 1: Desvanecimiento (Fade), 0: Deslizamiento (Slide)
inline uint16_t getThemePrimaryColor() {
if (themeIndex >= 9)
if (themeIndex >= 6)
return 0x07FF;
return GAUGE_THEMES[themeIndex].primaryColor;
}
inline uint16_t getThemeAccentColor() {
if (themeIndex >= 9)
if (themeIndex >= 6)
return 0x234F;
return GAUGE_THEMES[themeIndex].accentColor;
}
inline uint16_t getThemeDivColor() {
if (themeIndex >= 9)
if (themeIndex >= 6)
return 0x3412;
return GAUGE_THEMES[themeIndex].divColor;
}
inline uint16_t getThemeDarkColor() {
if (themeIndex >= 9)
if (themeIndex >= 6)
return 0x1105;
return GAUGE_THEMES[themeIndex].darkColor;
}
inline uint16_t getThemeBgColor() {
if (themeIndex >= 9)
if (themeIndex >= 6)
return 0x19C8;
return GAUGE_THEMES[themeIndex].bgColor;
}
// Special theme helpers
// Rainbow theme helpers (theme index 2)
inline bool isRainbowTheme() { return themeIndex == 2; }
inline bool isYapaTheme() { return themeIndex == 8; }
// Convert hue (0..359, full saturation/value) to RGB565
inline uint16_t hueToRgb565(uint16_t hue) {
@ -256,10 +249,6 @@ inline uint16_t getThemeCellColor(uint8_t cell) {
if (isRainbowTheme()) {
return getRainbowCellColor(cell);
}
if (isYapaTheme()) {
const uint16_t yapaCell[4] = { 0xFD79, 0x971F, 0xFFF2, 0xA7D7 };
return yapaCell[cell % 4];
}
return getThemePrimaryColor();
}
@ -301,8 +290,8 @@ int8_t currentScreenPage =
inline void setScreenPage(int8_t page) {
if (page < 0)
page = 0;
if (page > 4)
page = 4;
if (page > 3)
page = 3;
currentScreenPage = page;
pref.begin("setting", false);
pref.putChar("scr_page", page);
@ -332,8 +321,8 @@ const uint8_t MAX_TERMINAL_LINES = 13;
String line[MAX_TERMINAL_LINES]; // buffer for each line in terminal function
uint8_t terminalLineCount = 0;
bool dim = false; // back light dim flag
const uint16_t LIGHT_LEVEL =
1000; // Umbral de luz ambiental dia/noche para ADC de 12 bits (0..4095)
const uint8_t LIGHT_LEVEL =
40; // backlight control by light level Higher = darker light
// BLUETOOTH
String bt_message = ""; // bluetooth message buffer
@ -488,7 +477,6 @@ String sendATCommand(const String &cmd, uint32_t timeoutMs = 2000) {
#include "gps_module.h"
#include "gps_clock.h"
#include "gps_nav.h"
#include "cluster_screen.h"
#include "meter.h"
#include "config.h"
@ -705,13 +693,13 @@ recent_client_addr : {0x00,0x00,0x00,0x00,0x00,0x00} array of bytes[6]
if (brightnessIndex > 5)
brightnessIndex = 0;
themeIndex = pref.getUChar("theme_idx", 0);
if (themeIndex > 8)
if (themeIndex > 5)
themeIndex = 0;
transitionType = pref.getUChar("trans_type", 0);
transitionType = pref.getUChar("trans_type", 1);
if (transitionType > 1)
transitionType = 0;
transitionType = 1;
currentScreenPage = pref.getChar("scr_page", 0);
if (currentScreenPage < 0 || currentScreenPage > 4)
if (currentScreenPage < 0 || currentScreenPage > 3)
currentScreenPage = 0;
if (brightnessIndex > 0) {
targetBacklight = BRIGHTNESS_PWM_TABLE[brightnessIndex];
@ -726,7 +714,7 @@ recent_client_addr : {0x00,0x00,0x00,0x00,0x00,0x00} array of bytes[6]
Terminal("[ OK ] Settings: Theme " + String(GAUGE_THEMES[themeIndex].name) +
" (LED RGB)");
Terminal("[ OK ] Settings: Transicion " +
String(transitionType == 0 ? "Fundido a Negro" : "Desvanecimiento"));
String(transitionType == 0 ? "Deslizamiento" : "Desvanecimiento"));
delay(40);
// Initialize persistent transition sprites (pre-allocated once at boot in clean heap)
@ -863,11 +851,6 @@ void loop() {
updateGpsNavScreen(false);
}
// Non-blocking live refresh for resting Page 4 (Cockpit Instrumental Deportivo)
if (currentScreenPage == 4 && fullScreenCell == -1) {
updateClusterScreen(false);
}
if (wokeFromSleep) {
wokeFromSleep = false;
lastActivityTime = millis();
@ -927,10 +910,10 @@ void loop() {
// (disabled in full-screen mode)
if (!longPressHandled) {
if (fullScreenCell == -1 && liveDeltaX < -28 && abs(liveDeltaY) < 85) {
// SWIPE LEFT: Transition to next page (0 -> 1 -> 2 -> 3 -> 4 -> 0)
// SWIPE LEFT: Transition to next page (0 -> 1 -> 2 -> 3 -> 0)
longPressHandled = true;
touchBeep();
uint8_t nextPage = (currentScreenPage + 1) % 5;
uint8_t nextPage = (currentScreenPage + 1) % 4;
performScreenTransition(true, currentScreenPage, nextPage);
setScreenPage(nextPage);
initScreen(false); // Seamless: keep transition frame without blanking
@ -940,11 +923,11 @@ void loop() {
lastActivityTime = millis();
} else if (fullScreenCell == -1 && liveDeltaX > 28 &&
abs(liveDeltaY) < 85) {
// SWIPE RIGHT: Transition to previous page (0 -> 4 -> 3 -> 2 -> 1 -> 0)
// SWIPE RIGHT: Transition to previous page (0 -> 3 -> 2 -> 1 -> 0)
longPressHandled = true;
touchBeep();
uint8_t nextPage =
(currentScreenPage == 0) ? 4 : (currentScreenPage - 1);
(currentScreenPage == 0) ? 3 : (currentScreenPage - 1);
performScreenTransition(false, currentScreenPage, nextPage);
setScreenPage(nextPage);
initScreen(false); // Seamless: keep transition frame without blanking
@ -984,7 +967,7 @@ void loop() {
// SWIPE LEFT
longPressHandled = true;
touchBeep();
uint8_t nextPage = (currentScreenPage + 1) % 5;
uint8_t nextPage = (currentScreenPage + 1) % 4;
performScreenTransition(true, currentScreenPage, nextPage);
setScreenPage(nextPage);
initScreen(false); // Seamless: keep transition frame without blanking
@ -997,7 +980,7 @@ void loop() {
longPressHandled = true;
touchBeep();
uint8_t nextPage =
(currentScreenPage == 0) ? 4 : (currentScreenPage - 1);
(currentScreenPage == 0) ? 3 : (currentScreenPage - 1);
performScreenTransition(false, currentScreenPage, nextPage);
setScreenPage(nextPage);
initScreen(false); // Seamless: keep transition frame without blanking
@ -1029,9 +1012,6 @@ void loop() {
} else if (currentScreenPage == 3) {
// Tap on GPS Navigation screen: immediate telemetry refresh
updateGpsNavScreen(true);
} else if (currentScreenPage == 4) {
// Tap on Cockpit Instrumental: immediate cluster refresh
updateClusterScreen(true);
}
waitForTouchRelease();
lastActivityTime = millis();
@ -1055,14 +1035,6 @@ void loop() {
}
}
// AUTO-DIM BACKLIGHT: Control continuo de brillo en todas las pantallas
// Funciona siempre, este o no conectado el Bluetooth
static uint32_t lastContinuousDimCheck = 0;
if (millis() - lastContinuousDimCheck >= 50) {
lastContinuousDimCheck = millis();
autoDim();
}
#ifndef SKIP_CONNECTION
// Check Bluetooth connection state: if adapter disconnected or lost power,
// switch immediately to GPS Clock Screen (Page 2) and show "---" on OBD

BIN
sketch/obd2_gauge/rainbow_text.h
View file

Binary file not shown.

6
sketch/obd2_gauge/touchscreen.h
View file

@ -49,12 +49,12 @@ inline bool isScreenPressed() {
}
// Wait until both touchscreen and selector button are completely released with
// 30ms continuous debounce and 4000ms maximum hardware safety timeout
inline void waitForTouchRelease(uint32_t maxWaitMs = 4000) {
// 30ms continuous debounce and 250ms maximum hardware safety timeout
inline void waitForTouchRelease() {
uint16_t dummyX, dummyY;
uint8_t releaseCount = 0;
uint32_t startWait = millis();
while (releaseCount < 3 && (millis() - startWait < maxWaitMs)) {
while (releaseCount < 3 && (millis() - startWait < 250)) {
if (getTouch(&dummyX, &dummyY) || (digitalRead(SELECTOR_PIN) == LOW)) {
releaseCount = 0;
} else {

129
sketch/obd2_gauge/tri_temp.h
View file

@ -46,10 +46,6 @@ static uint8_t oldTriDsSensorCount = 255;
static TFT_eSprite sprTriTitle[3] = { TFT_eSprite(&tft), TFT_eSprite(&tft), TFT_eSprite(&tft) };
static bool sprTriTitleReady = false;
inline void invalidateTriTempTitles() {
sprTriTitleReady = false;
}
inline void initTriTempTitles() {
if (sprTriTitleReady) return;
uint16_t cardBg = 0x10A2;
@ -61,20 +57,8 @@ inline void initTriTempTitles() {
sprTriTitle[i].loadFont(Latin_Sans_Bold_26);
sprTriTitle[i].setTextPadding(0);
sprTriTitle[i].fillSprite(cardBg);
if (isYapaTheme()) {
int curX = 0;
char buf[2] = {0, 0};
String t = titles[i];
for (size_t k = 0; k < t.length(); k++) {
buf[0] = t[k];
sprTriTitle[i].setTextColor(getYapaColor(k), cardBg);
sprTriTitle[i].drawString(buf, curX, 0);
curX += sprTriTitle[i].textWidth(buf);
}
} else {
sprTriTitle[i].setTextColor(TFT_WHITE, cardBg);
sprTriTitle[i].drawString(titles[i], 0, 0, 1);
}
sprTriTitle[i].setTextColor(TFT_WHITE, cardBg);
sprTriTitle[i].drawString(titles[i], 0, 0, 1);
sprTriTitle[i].unloadFont();
if (isRainbowTheme()) {
applyRainbowToSprite(sprTriTitle[i], 4 + 16, 19 + i * 74 + 5, cardBg);
@ -157,7 +141,7 @@ const uint8_t s_dsegUnitAlpha[30 * 26] PROGMEM = {
};
// Draw 100% anti-aliased digital 7-segment italic unit "°C" matching DSEG7 typography and color
inline void draw7SegDegreeC(TFT_eSPI &dst, int bx, int by, uint16_t color = 0xC618, uint16_t bgCol = 0x10A2, bool rainbow = false) {
inline void draw7SegDegreeC(TFT_eSPI &dst, int bx, int by, uint16_t color = 0xC618, uint16_t bgCol = 0x10A2) {
for (int j = 0; j < 26; j++) {
int py = by + j;
if (py < 0 || py >= dst.height()) continue;
@ -167,8 +151,7 @@ inline void draw7SegDegreeC(TFT_eSPI &dst, int bx, int by, uint16_t color = 0xC6
if (px < 0 || px >= dst.width()) continue;
uint8_t a = pgm_read_byte(&s_dsegUnitAlpha[rowOffset + i]);
if (a > 8) {
uint16_t curCol = rainbow ? getRainbowScreenColor(px, py) : color;
uint16_t pixCol = (a >= 250) ? curCol : fastBlend(a, curCol, bgCol);
uint16_t pixCol = (a >= 250) ? color : fastBlend(a, color, bgCol);
dst.drawPixel(px, py, pixCol);
}
}
@ -242,7 +225,7 @@ inline void drawTriTempCard(uint8_t cardIdx, float val, int x_offset = 0) {
isInt = true;
float warnT = warningValue[0].toFloat();
if (warnT <= 0) warnT = 110.0f;
if (val < (warnT - 10.0f)) accentCol = isRainbowTheme() ? (uint16_t)0x07FF : (isYapaTheme() ? getYapaColor(0) : getThemePrimaryColor());
if (val < (warnT - 10.0f)) accentCol = isRainbowTheme() ? (uint16_t)0x07FF : getThemePrimaryColor();
else if (val < warnT) accentCol = TFT_YELLOW;
else accentCol = TFT_RED;
} else if (cardIdx == 1) {
@ -250,58 +233,33 @@ inline void drawTriTempCard(uint8_t cardIdx, float val, int x_offset = 0) {
subStr = (dsSensorCount > 0) ? "DS18B20 SENSOR 1 (GPIO 22)" : "DS18B20 SENSOR 1";
minRange = 10.0f;
maxRange = 40.0f;
accentCol = isRainbowTheme() ? (uint16_t)0x07E0 : (isYapaTheme() ? getYapaColor(1) : getThemeAccentColor());
accentCol = isRainbowTheme() ? (uint16_t)0x07E0 : getThemeAccentColor(); // Green in rainbow
} else {
titleStr = "EXTERIOR";
subStr = (dsSensorCount > 1) ? "DS18B20 SENSOR 2 (GPIO 22)" : (dsSensorCount == 1 ? "ESTIMADA (-4.5`C)" : "DS18B20 SENSOR 2");
minRange = -10.0f;
maxRange = 50.0f;
accentCol = isRainbowTheme() ? (uint16_t)0xFD20 : (isYapaTheme() ? getYapaColor(2) : getThemePrimaryColor());
accentCol = isRainbowTheme() ? (uint16_t)0xFD20 : getThemePrimaryColor(); // Orange in rainbow
}
// Left vertical accent bar
tft.fillRoundRect(cardX + 6, cardY + 6, 4, cardH - 12, 2, accentCol);
if (isYapaTheme()) {
tft.loadFont(Latin_Sans_Bold_26);
int curX = cardX + 16;
char buf[2] = {0, 0};
uint8_t cIdx = 0;
for (int i = 0; titleStr[i] != '\0'; i++) {
char c = titleStr[i];
buf[0] = c;
if (c == ' ') { curX += tft.textWidth(buf); continue; }
tft.setTextColor(getYapaColor(cIdx++), cardBg);
tft.drawString(buf, curX, cardY + 5);
curX += tft.textWidth(buf);
}
tft.unloadFont();
int sX = cardX + 16;
for (int i = 0; subStr[i] != '\0'; i++) {
char c = subStr[i];
buf[0] = c;
int cw = tft.textWidth(buf, 1);
if (c == ' ') { sX += cw; continue; }
tft.setTextColor(getYapaColor(cIdx++), cardBg);
tft.drawString(buf, sX, cardY + 32, 1);
sX += cw;
}
// Titles (Smooth anti-aliased font)
if (!sprTriTitleReady) initTriTempTitles();
if (sprTriTitleReady && sprTriTitle[cardIdx].created()) {
sprTriTitle[cardIdx].pushSprite(cardX + 16, cardY + 5);
} else {
if (!sprTriTitleReady) initTriTempTitles();
if (sprTriTitleReady && sprTriTitle[cardIdx].created()) {
sprTriTitle[cardIdx].pushSprite(cardX + 16, cardY + 5);
} else {
tft.loadFont(Latin_Sans_Bold_26);
tft.setTextPadding(0);
tft.setTextColor(TFT_WHITE, cardBg);
tft.drawString(titleStr, cardX + 16, cardY + 5, 1);
tft.unloadFont();
}
tft.setTextColor(0x8410, cardBg); // Soft gray
tft.drawString(subStr, cardX + 16, cardY + 32, 1);
tft.loadFont(Latin_Sans_Bold_26);
tft.setTextPadding(0);
tft.setTextColor(TFT_WHITE, cardBg);
tft.drawString(titleStr, cardX + 16, cardY + 5, 1);
tft.unloadFont();
}
tft.setTextColor(0x8410, cardBg); // Soft gray
tft.drawString(subStr, cardX + 16, cardY + 32, 1);
// 3. Horizontal Progress Gauge Bar
int barX = cardX + 16;
int barY = cardY + 48;
@ -336,9 +294,7 @@ inline void drawTriTempCard(uint8_t cardIdx, float val, int x_offset = 0) {
drawDseg7RightString34(tft, numStr.c_str(), cardX + 262, cardY + 20, accentCol, cardBg, 100, 240, rainbowTxt);
// Unit "°C" in authentic digital 7-segment italic typography matching numbers
bool rainbowUnit = isRainbowTheme() && (accentCol != TFT_RED);
uint16_t unitCol = rainbowUnit ? getRainbowScreenColor(cardX + 268, cardY + 22) : (isYapaTheme() && accentCol != TFT_RED ? getYapaColor(numStr.length()) : (accentCol == TFT_RED ? TFT_RED : 0xC618));
draw7SegDegreeC(tft, cardX + 268, cardY + 22, unitCol, cardBg, rainbowUnit);
draw7SegDegreeC(tft, cardX + 268, cardY + 22, isRainbowTheme() ? getRainbowScreenColor(cardX + 268, cardY + 22) : 0xC618, cardBg);
}
// Flicker-free dynamic value update for a single temperature card
@ -374,42 +330,24 @@ inline void updateTriTempCardValue(uint8_t cardIdx, float val, float oldVal) {
oldTriIgnition = ignitionOn;
const char* subStr = ignitionOn ? "ECU OBD-II (PID 0105)" : "ECU OBD-II (STANDBY)";
tft.fillRect(cardX + 16, cardY + 32, 130, 10, cardBg);
if (isYapaTheme()) {
char buf[2] = {0, 0};
int sX = cardX + 16;
uint8_t cIdx = 4;
for (int i = 0; subStr[i] != '\0'; i++) {
char c = subStr[i];
buf[0] = c;
int cw = tft.textWidth(buf, 1);
if (c == ' ') { sX += cw; continue; }
tft.setTextColor(getYapaColor(cIdx++), cardBg);
tft.drawString(buf, sX, cardY + 32, 1);
sX += cw;
}
} else {
tft.setTextColor(0x8410, cardBg);
tft.drawString(subStr, cardX + 16, cardY + 32, 1);
}
tft.setTextColor(0x8410, cardBg);
tft.drawString(subStr, cardX + 16, cardY + 32, 1);
}
} else if (cardIdx == 1) {
minRange = 10.0f;
maxRange = 40.0f;
accentCol = isRainbowTheme() ? (uint16_t)0x07E0 : (isYapaTheme() ? getYapaColor(1) : getThemeAccentColor());
accentCol = isRainbowTheme() ? (uint16_t)0x07E0 : getThemeAccentColor();
oldAccentCol = accentCol;
} else {
minRange = -10.0f;
maxRange = 50.0f;
accentCol = isRainbowTheme() ? (uint16_t)0xFD20 : (isYapaTheme() ? getYapaColor(2) : getThemePrimaryColor());
accentCol = isRainbowTheme() ? (uint16_t)0xFD20 : getThemePrimaryColor();
oldAccentCol = accentCol;
}
// 1. Accent color changed: update vertical accent bar and unit "°C"
// 1. Accent color changed: update vertical accent bar
if (accentCol != oldAccentCol) {
tft.fillRoundRect(cardX + 6, cardY + 6, 4, cardH - 12, 2, accentCol);
bool rainbowUnit = isRainbowTheme() && (accentCol != TFT_RED);
uint16_t unitCol = rainbowUnit ? getRainbowScreenColor(cardX + 268, cardY + 22) : (isYapaTheme() && accentCol != TFT_RED ? getYapaColor(3) : (accentCol == TFT_RED ? TFT_RED : 0xC618));
draw7SegDegreeC(tft, cardX + 268, cardY + 22, unitCol, cardBg, rainbowUnit);
}
// 2. Horizontal Progress Gauge Bar update (only redraw when pixel fill changes or accent changes)
@ -455,9 +393,9 @@ inline void syncTriTempTrackers() {
float minR[3] = { 60.0f, 10.0f, -10.0f };
float maxR[3] = { 120.0f, 40.0f, 50.0f };
uint16_t defAcc[3] = {
isRainbowTheme() ? (uint16_t)0x07FF : (isYapaTheme() ? getYapaColor(0) : getThemePrimaryColor()),
isRainbowTheme() ? (uint16_t)0x07E0 : (isYapaTheme() ? getYapaColor(1) : getThemeAccentColor()),
isRainbowTheme() ? (uint16_t)0xFD20 : (isYapaTheme() ? getYapaColor(2) : getThemePrimaryColor())
isRainbowTheme() ? (uint16_t)0x07FF : getThemePrimaryColor(),
isRainbowTheme() ? (uint16_t)0x07E0 : getThemeAccentColor(),
isRainbowTheme() ? (uint16_t)0xFD20 : getThemePrimaryColor()
};
for (int i = 0; i < 3; i++) {
float ratio = (vals[i] - minR[i]) / (maxR[i] - minR[i]);
@ -492,12 +430,11 @@ inline void drawTriTempScreen(int x_offset = 0) {
syncTriTempTrackers();
// Draw Page Indicator: [○ ● ○ ○ ○] (Page 2 of 5 active)
tft.fillCircle(132 + x_offset, 2, 2, 0x5AEB); // Page 0 inactive
tft.fillCircle(146 + x_offset, 2, 2, getThemePrimaryColor()); // Page 1 active
tft.fillCircle(160 + x_offset, 2, 2, 0x5AEB); // Page 2 inactive
tft.fillCircle(174 + x_offset, 2, 2, 0x5AEB); // Page 3 inactive
tft.fillCircle(188 + x_offset, 2, 2, 0x5AEB); // Page 4 inactive
// Draw Page Indicator: [○ ● ○ ○] (Page 2 of 4 active)
tft.fillCircle(139 + x_offset, 2, 2, 0x5AEB); // Page 1 inactive
tft.fillCircle(153 + x_offset, 2, 2, getThemePrimaryColor()); // Page 2 active
tft.fillCircle(167 + x_offset, 2, 2, 0x5AEB); // Page 3 inactive
tft.fillCircle(181 + x_offset, 2, 2, 0x5AEB); // Page 4 inactive
}
// Update coolant reading dynamically without redrawing entire screen