2189 lines
76 KiB
C
2189 lines
76 KiB
C
// All Meters display function
|
|
#include "DSEG7_Modern_BoldItalic_80.h"
|
|
#include "DSEG7_Modern_BoldItalic_44.h"
|
|
#include "DSEG7_Modern_BoldItalic_34.h"
|
|
#include "DSEG7_Modern_BoldItalic_24.h"
|
|
|
|
const uint16_t screenWidth = tft.height(); // landscape
|
|
const uint16_t screenHeight = tft.width();
|
|
/*---- METER ------_*
|
|
Type 0:numericMeter
|
|
Type 1:arcMeters
|
|
Type 2:vBarMeter
|
|
coordinate for each cell (numieric meter & arc meter)
|
|
1 , 4 , 7
|
|
2 , 5 , 8
|
|
3 , 6 , 9 */
|
|
const uint16_t cell1_x[9] = {
|
|
0, 0, 0, 80, 80, 80, 160, 160, 160}; // cell type 1 x origin cooridate
|
|
const uint16_t cell1_y[9] = {
|
|
0, 80, 160, 0, 80, 160, 0, 80, 160}; // cell type 1 y origin coordiate
|
|
/*coordinate for each cell type 2 (Vertical bar meter)
|
|
1 , 2 , 3 , 4 */
|
|
const uint16_t cell2_x[4] = {0, 80, 160,
|
|
240}; // vertical bar cell x origin coordinate
|
|
const uint16_t cell4_x[4] = {
|
|
0, 160, 0, 160}; // 4 quadrant x: top-left, top-right, bot-left, bot-right
|
|
const uint16_t cell4_y[4] = {
|
|
0, 0, 120, 120}; // 4 quadrant y: top-left, top-right, bot-left, bot-right
|
|
bool blinkCell[9] = {false, false, false, false, false,
|
|
false, false, false, false}; // flag for blinking
|
|
|
|
String pidList[maxpidIndex] =
|
|
{}; //{"0104","0105","010C","010B","010C","0142","015C"}
|
|
uint8_t pidReadSkip[maxpidIndex] = {}; // skip reading 0 - 3; 3 = max delay read
|
|
uint8_t pidCurrentSkip[maxpidIndex] = {}; // current skip counter
|
|
uint8_t engine_off_count = 0; // counter to indicate engine is off then sleep
|
|
float old_data[maxpidIndex] = {-999, -999, -999, -999, -999}; // keep old data
|
|
float last_valid_data[maxpidIndex] = {-999, -999, -999, -999, -999}; // keep last valid data for instant redraw
|
|
float currentRpm = 0.0f; // Current engine RPM for sleep/inactivity tracking
|
|
float currentEngineLoad = 0.0f; // Current Engine Load % (PID 0104)
|
|
bool isEcoOptimal = false; // Flag: RPM 1900-2550 & Load 45-82%
|
|
bool badgeEcoDrawn = false; // Tracking rendered status on display
|
|
extern uint32_t lastActivityTime; // Activity timestamp for auto-sleep
|
|
bool ignitionOn = true; // True if ECU is actively communicating (contacto puesto)
|
|
uint8_t consecutiveEcuFails = 0; // Counter for consecutive ECU communication failures
|
|
|
|
// Arc warning flash (blinking alarm when gauge is in TFT_RED)
|
|
bool arcFlashVisible = true;
|
|
uint32_t lastArcFlashTime = 0;
|
|
bool wasInRedAlarm[4] = { false, false, false, false };
|
|
|
|
// Color for inactive meter blocks (medium-dark graphite grey, lighter than 0x2124 but darker than 0x7BEF)
|
|
const uint16_t METER_INACTIVE_COLOR = 0x39E7; // RGB ~ (58, 60, 58)
|
|
|
|
// backlight variable average counter
|
|
uint8_t low_count = 0;
|
|
uint8_t high_count = 0;
|
|
|
|
const float factoryECUOff = 12.5; // default off voltage
|
|
float ecu_off_volt = factoryECUOff; // turn engine off if voltage lower
|
|
// than 12.4
|
|
|
|
// Cache theme gradients to ensure 100% bit-for-bit identical background restoration
|
|
uint16_t cachedThemeColor = 0xFFFF;
|
|
uint16_t themeGradQuad[82];
|
|
uint16_t themeGradHeader[145];
|
|
|
|
void checkUpdateThemeGradients() {
|
|
uint16_t currentTheme = getThemeBgColor();
|
|
if (currentTheme == cachedThemeColor) return;
|
|
cachedThemeColor = currentTheme;
|
|
|
|
float delta = -255.0f / 82.0f;
|
|
float alpha = 255.0f;
|
|
uint16_t col = currentTheme;
|
|
for (int i = 0; i < 82; i++) {
|
|
themeGradQuad[i] = col;
|
|
alpha += delta;
|
|
col = fastBlend((uint8_t)alpha, currentTheme, (uint16_t)TFT_BLACK);
|
|
}
|
|
|
|
delta = -255.0f / 145.0f;
|
|
alpha = 255.0f;
|
|
col = currentTheme;
|
|
for (int i = 0; i < 145; i++) {
|
|
themeGradHeader[i] = col;
|
|
alpha += delta;
|
|
col = fastBlend((uint8_t)alpha, currentTheme, (uint16_t)TFT_BLACK);
|
|
}
|
|
}
|
|
|
|
inline uint16_t getInstrumentBgColor(int y, bool isQuad, int ry = 0) {
|
|
checkUpdateThemeGradients();
|
|
if (isQuad) {
|
|
int k = y - ry;
|
|
if (k < 0) return themeGradQuad[0];
|
|
if (k >= 82) return TFT_BLACK;
|
|
return themeGradQuad[k];
|
|
} else {
|
|
if (y < 0) return themeGradHeader[0];
|
|
if (y >= 145) return TFT_BLACK;
|
|
return themeGradHeader[y];
|
|
}
|
|
}
|
|
|
|
// Shared line/block buffer for fast SPI push (up to 64x64 max icon size, ~8KB static RAM)
|
|
static uint16_t s_iconRenderBuf[64 * 64];
|
|
|
|
// Draw icon with true 8-bit alpha channel blended dynamically against current instrument background
|
|
void drawIconWithAlpha(int x, int y, int w, int h, const unsigned short *colors, const unsigned char *alphas, bool isQuad, int ry = 0) {
|
|
if (w * h > 64 * 64) return;
|
|
|
|
for (int j = 0; j < h; j++) {
|
|
int curY = y + j;
|
|
uint16_t bgCol = getInstrumentBgColor(curY, isQuad, ry);
|
|
int rowOffset = j * w;
|
|
for (int i = 0; i < w; i++) {
|
|
uint8_t a = pgm_read_byte(&alphas[rowOffset + i]);
|
|
if (a == 0) {
|
|
s_iconRenderBuf[rowOffset + i] = bgCol;
|
|
} else if (a >= 250) {
|
|
s_iconRenderBuf[rowOffset + i] = pgm_read_word(&colors[rowOffset + i]);
|
|
} else {
|
|
uint16_t fg = pgm_read_word(&colors[rowOffset + i]);
|
|
s_iconRenderBuf[rowOffset + i] = fastBlend(a, fg, bgCol);
|
|
}
|
|
}
|
|
}
|
|
tft.setSwapBytes(true);
|
|
tft.pushImage(x, y, w, h, s_iconRenderBuf);
|
|
}
|
|
|
|
// Draw parameter icon for 4-quadrant view with true alpha channel
|
|
void drawPidIcon(int x, int y, const String &pidStr) {
|
|
int ry = (y >= 120) ? 121 : 0;
|
|
if (pidStr == "0105") {
|
|
drawIconWithAlpha(x, y, 38, 37, icon_temp_quad, icon_temp_quad_alpha, true, ry);
|
|
} else if (pidStr == "010D") {
|
|
drawIconWithAlpha(x, y, 42, 42, icon_speed_quad, icon_speed_quad_alpha, true, ry);
|
|
} else if (pidStr == "010C") {
|
|
drawIconWithAlpha(x, y, 42, 43, icon_rpm_quad, icon_rpm_quad_alpha, true, ry);
|
|
} else if (pidStr == "0142" || pidStr == "ATRV") {
|
|
drawIconWithAlpha(x, y, 46, 35, icon_battery_quad, icon_battery_quad_alpha, true, ry);
|
|
}
|
|
}
|
|
|
|
// Clear parameter icon for 4-quadrant view by restoring exact background lines (100% invisible restoration)
|
|
void clearPidIcon(int x, int y, const String &pidStr) {
|
|
int w = 42;
|
|
int h = 42;
|
|
if (pidStr == "0105") {
|
|
w = 38;
|
|
h = 37;
|
|
} else if (pidStr == "010D") {
|
|
w = 42;
|
|
h = 42;
|
|
} else if (pidStr == "010C") {
|
|
w = 42;
|
|
h = 43;
|
|
} else if (pidStr == "0142" || pidStr == "ATRV") {
|
|
w = 46;
|
|
h = 35;
|
|
}
|
|
|
|
int ry = (y >= 120) ? 121 : 0;
|
|
for (int j = 0; j < h; j++) {
|
|
int curY = y + j;
|
|
uint16_t bgCol = getInstrumentBgColor(curY, true, ry);
|
|
int rowOffset = j * w;
|
|
for (int i = 0; i < w; i++) {
|
|
s_iconRenderBuf[rowOffset + i] = bgCol;
|
|
}
|
|
}
|
|
tft.setSwapBytes(true);
|
|
tft.pushImage(x, y, w, h, s_iconRenderBuf);
|
|
}
|
|
|
|
// Draw header icon for full screen mode with true alpha channel
|
|
void drawPidIconHeader(int x, int y, const String &pidStr) {
|
|
if (pidStr == "0105") {
|
|
drawIconWithAlpha(8, 2, 48, 48, icon_temp_48, icon_temp_48_alpha, false);
|
|
} else if (pidStr == "010D") {
|
|
drawIconWithAlpha(8, 2, 48, 48, icon_speed_48, icon_speed_48_alpha, false);
|
|
} else if (pidStr == "010C") {
|
|
drawIconWithAlpha(11, 4, 42, 43, icon_rpm_quad, icon_rpm_quad_alpha, false);
|
|
} else if (pidStr == "0142" || pidStr == "ATRV") {
|
|
drawIconWithAlpha(8, 2, 48, 48, icon_battery_48, icon_battery_48_alpha, false);
|
|
}
|
|
}
|
|
|
|
// Restore ambient vignette background over the header icon area during alarm blink OFF phase (100% invisible)
|
|
void clearPidIconHeader(int x = 8, int y = 2, int w = 50, int h = 52) {
|
|
for (int j = 0; j < h; j++) {
|
|
int curY = y + j;
|
|
uint16_t bgCol = getInstrumentBgColor(curY, false);
|
|
int rowOffset = j * w;
|
|
for (int i = 0; i < w; i++) {
|
|
s_iconRenderBuf[rowOffset + i] = bgCol;
|
|
}
|
|
}
|
|
tft.setSwapBytes(true);
|
|
tft.pushImage(x, y, w, h, s_iconRenderBuf);
|
|
}
|
|
|
|
// Draw or clear full screen instrument title during normal display and alarm blinking
|
|
void drawFullScreenTitle(const String &label, uint16_t color) {
|
|
checkUpdateThemeGradients();
|
|
for (int y = 10; y <= 40; y++) {
|
|
uint16_t bgCol = getInstrumentBgColor(y, false);
|
|
tft.drawFastHLine(60, y, 195, bgCol);
|
|
}
|
|
if (color != 0) {
|
|
tft.setTextColor(color);
|
|
tft.drawCentreString(label.c_str(), 175, 12, 4);
|
|
}
|
|
}
|
|
|
|
// Tactical ECO / OPT Badge (Ford Ka Endura 1.3 Sweet Spot: 1900 - 2550 RPM & 45% - 82% Load)
|
|
void updateEcoBadge(bool forceRedraw = false) {
|
|
bool newEco = (ignitionOn && currentRpm >= 1900.0f && currentRpm <= 2550.0f &&
|
|
currentEngineLoad >= 45.0f && currentEngineLoad <= 82.0f);
|
|
isEcoOptimal = newEco;
|
|
|
|
if (forceRedraw) {
|
|
badgeEcoDrawn = !newEco; // Force redraw/re-erase
|
|
}
|
|
|
|
if (newEco == badgeEcoDrawn) {
|
|
return;
|
|
}
|
|
|
|
bool isQuad = (fullScreenCell < 0 || fullScreenCell >= 4);
|
|
int bx = 0, by = 0, bw = 0, bh = 0;
|
|
|
|
if (isQuad) {
|
|
// 4-Quadrant View: Positioned in top-right of RPM Quadrant (Cell 2)
|
|
int rpmCell = 2;
|
|
for (int c = 0; c < 4; c++) {
|
|
if (pidConfig[pidInCell[c]][3].toInt() == 3) {
|
|
rpmCell = c;
|
|
break;
|
|
}
|
|
}
|
|
bx = cell4_x[rpmCell] + 100;
|
|
by = cell4_y[rpmCell] + 4;
|
|
bw = 48;
|
|
bh = 18;
|
|
} else {
|
|
// Full-Screen View: Positioned in top-right header band
|
|
bx = 260;
|
|
by = 11;
|
|
bw = 50;
|
|
bh = 20;
|
|
}
|
|
|
|
if (newEco) {
|
|
// Elegant tactical pill badge [ ECO ]
|
|
const uint16_t bgFill = 0x0202; // Deep dark forest emerald green
|
|
const uint16_t borderCol = 0x07E0; // Vibrant emerald neon green
|
|
tft.fillRoundRect(bx, by, bw, bh, 4, bgFill);
|
|
tft.drawRoundRect(bx, by, bw, bh, 4, borderCol);
|
|
tft.setTextColor(TFT_WHITE, bgFill);
|
|
if (isQuad) {
|
|
tft.drawCentreString("ECO", bx + (bw / 2), by + 1, 2);
|
|
} else {
|
|
tft.drawCentreString("ECO", bx + (bw / 2), by + 2, 2);
|
|
}
|
|
} else {
|
|
// Cleanly restore background gradient lines with zero visual trace
|
|
int ry = (isQuad && by >= 120) ? 121 : 0;
|
|
for (int y = by; y < by + bh; y++) {
|
|
uint16_t bgCol = getInstrumentBgColor(y, isQuad, ry);
|
|
tft.drawFastHLine(bx, y, bw, bgCol);
|
|
}
|
|
}
|
|
|
|
badgeEcoDrawn = newEco;
|
|
}
|
|
|
|
// Full Screen Exponential Segmented Block Bar Graph (20 blocks: 3mm width x 4mm height, 0.5mm gap, Anti-Aliased)
|
|
const uint8_t NUM_BAR_BLOCKS = 20;
|
|
const int16_t blockMinX[20] PROGMEM = { 0, 5, 11, 17, 25, 34, 46, 59, 76, 95, 114, 134, 154, 174, 193, 213, 232, 251, 271, 290 };
|
|
const int16_t blockMaxX[20] PROGMEM = { 28, 34, 40, 47, 55, 65, 76, 89, 104, 121, 138, 157, 175, 194, 214, 233, 252, 271, 290, 310 };
|
|
const int16_t blockMinY[20] PROGMEM = { 202, 183, 164, 146, 127, 110, 94, 80, 70, 63, 59, 56, 54, 53, 52, 52, 52, 52, 52, 52 };
|
|
const int16_t blockMaxY[20] PROGMEM = { 226, 208, 190, 172, 155, 139, 124, 111, 100, 92, 87, 83, 80, 79, 78, 77, 77, 77, 77, 77 };
|
|
|
|
const float blockNx[20][4] PROGMEM = {
|
|
{ 0.96709f, -0.26991f, -0.96711f, 0.24260f },
|
|
{ 0.95775f, -0.30696f, -0.95776f, 0.26991f },
|
|
{ 0.94416f, -0.35424f, -0.94418f, 0.30696f },
|
|
{ 0.92359f, -0.41544f, -0.92365f, 0.35424f },
|
|
{ 0.89126f, -0.49508f, -0.89141f, 0.41544f },
|
|
{ 0.83905f, -0.59638f, -0.83936f, 0.49508f },
|
|
{ 0.75533f, -0.71496f, -0.75581f, 0.59638f },
|
|
{ 0.63154f, -0.83065f, -0.63179f, 0.71496f },
|
|
{ 0.47873f, -0.91631f, -0.47824f, 0.83065f },
|
|
{ 0.33039f, -0.96398f, -0.32962f, 0.91631f },
|
|
{ 0.21408f, -0.98563f, -0.21356f, 0.96398f },
|
|
{ 0.13436f, -0.99446f, -0.13412f, 0.98563f },
|
|
{ 0.08319f, -0.99789f, -0.08309f, 0.99446f },
|
|
{ 0.05123f, -0.99920f, -0.05120f, 0.99789f },
|
|
{ 0.03149f, -0.99970f, -0.03148f, 0.99920f },
|
|
{ 0.01934f, -0.99989f, -0.01934f, 0.99970f },
|
|
{ 0.01188f, -0.99996f, -0.01187f, 0.99989f },
|
|
{ 0.00729f, -0.99998f, -0.00729f, 0.99996f },
|
|
{ 0.00448f, -0.99999f, -0.00448f, 0.99998f },
|
|
{ 0.00275f, -1.00000f, -0.00275f, 0.99999f },
|
|
};
|
|
|
|
const float blockNy[20][4] PROGMEM = {
|
|
{ 0.25444f, 0.96289f, -0.25437f, -0.97013f },
|
|
{ 0.28762f, 0.95172f, -0.28757f, -0.96289f },
|
|
{ 0.32950f, 0.93516f, -0.32942f, -0.95172f },
|
|
{ 0.38338f, 0.90962f, -0.38323f, -0.93516f },
|
|
{ 0.45348f, 0.86885f, -0.45320f, -0.90962f },
|
|
{ 0.54405f, 0.80270f, -0.54358f, -0.86885f },
|
|
{ 0.65535f, 0.69916f, -0.65480f, -0.80270f },
|
|
{ 0.77534f, 0.55679f, -0.77514f, -0.69916f },
|
|
{ 0.87796f, 0.40047f, -0.87823f, -0.55679f },
|
|
{ 0.94384f, 0.26596f, -0.94412f, -0.40047f },
|
|
{ 0.97682f, 0.16890f, -0.97693f, -0.26596f },
|
|
{ 0.99093f, 0.10510f, -0.99097f, -0.16890f },
|
|
{ 0.99653f, 0.06486f, -0.99654f, -0.10510f },
|
|
{ 0.99869f, 0.03990f, -0.99869f, -0.06486f },
|
|
{ 0.99950f, 0.02452f, -0.99950f, -0.03990f },
|
|
{ 0.99981f, 0.01506f, -0.99981f, -0.02452f },
|
|
{ 0.99993f, 0.00924f, -0.99993f, -0.01506f },
|
|
{ 0.99997f, 0.00568f, -0.99997f, -0.00924f },
|
|
{ 0.99999f, 0.00348f, -0.99999f, -0.00568f },
|
|
{ 1.00000f, 0.00223f, -1.00000f, -0.00348f },
|
|
};
|
|
|
|
const float blockC[20][4] PROGMEM = {
|
|
{ -57.0917f, -194.0217f, 79.0747f, 212.4570f },
|
|
{ -63.7256f, -171.8745f, 85.7128f, 191.2717f },
|
|
{ -71.2233f, -148.4987f, 93.2024f, 169.1245f },
|
|
{ -79.6909f, -123.2275f, 101.6563f, 145.7487f },
|
|
{ -89.0635f, -95.0180f, 111.0070f, 120.4775f },
|
|
{ -98.7898f, -62.4921f, 120.7056f, 92.2680f },
|
|
{ -107.1996f, -24.6792f, 129.0998f, 59.7421f },
|
|
{ -111.1224f, 16.8839f, 133.0287f, 21.9292f },
|
|
{ -107.7811f, 57.2365f, 129.6718f, -19.6339f },
|
|
{ -98.3836f, 92.0853f, 120.2644f, -59.9865f },
|
|
{ -87.1827f, 121.1162f, 109.0982f, -94.8353f },
|
|
{ -77.3181f, 146.0701f, 99.2734f, -123.8662f },
|
|
{ -69.7527f, 168.5916f, 91.7322f, -148.8201f },
|
|
{ -64.3207f, 189.7308f, 86.3119f, -171.3416f },
|
|
{ -60.5502f, 210.0867f, 82.5466f, -192.4808f },
|
|
{ -57.9834f, 229.9930f, 79.9819f, -212.8367f },
|
|
{ -56.2577f, 249.6371f, 78.2571f, -232.7430f },
|
|
{ -55.1079f, 269.1261f, 77.1076f, -252.3871f },
|
|
{ -54.3470f, 288.5222f, 76.3469f, -271.8761f },
|
|
{ -53.8454f, 307.8565f, 75.8453f, -291.2722f },
|
|
};
|
|
|
|
// Draw an individual solid rectangular block with smooth subpixel anti-aliasing
|
|
inline void drawBarBlock(uint8_t i, uint16_t color) {
|
|
int16_t minX = pgm_read_word(&blockMinX[i]);
|
|
int16_t maxX = pgm_read_word(&blockMaxX[i]);
|
|
int16_t minY = pgm_read_word(&blockMinY[i]);
|
|
int16_t maxY = pgm_read_word(&blockMaxY[i]);
|
|
|
|
float nx[4], ny[4], c[4];
|
|
for (uint8_t k = 0; k < 4; k++) {
|
|
nx[k] = pgm_read_float(&blockNx[i][k]);
|
|
ny[k] = pgm_read_float(&blockNy[i][k]);
|
|
c[k] = pgm_read_float(&blockC[i][k]);
|
|
}
|
|
|
|
tft.startWrite();
|
|
for (int16_t y = minY; y <= maxY; y++) {
|
|
float py = (float)y + 0.5f;
|
|
for (int16_t x = minX; x <= maxX; x++) {
|
|
float px = (float)x + 0.5f;
|
|
float min_d = 999.0f;
|
|
for (uint8_t k = 0; k < 4; k++) {
|
|
float d = px * nx[k] + py * ny[k] + c[k];
|
|
if (d < min_d) min_d = d;
|
|
}
|
|
if (min_d <= -0.5f) continue;
|
|
if (color == TFT_BLACK) {
|
|
tft.drawPixel(x, y, TFT_BLACK);
|
|
} else {
|
|
if (min_d >= 0.5f) {
|
|
tft.drawPixel(x, y, color);
|
|
} else {
|
|
uint8_t alpha = (uint8_t)((min_d + 0.5f) * 255.0f);
|
|
tft.drawPixel(x, y, color, alpha, TFT_BLACK);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
tft.endWrite();
|
|
}
|
|
|
|
// 4-Quadrant Exponential Segmented Block Bar Graph (20 blocks per 160x120 quadrant, Anti-Aliased)
|
|
const int16_t quadBlockMinX[20] PROGMEM = { 5, 8, 12, 15, 20, 24, 30, 37, 45, 53, 62, 71, 80, 89, 98, 107, 117, 126, 135, 144 };
|
|
const int16_t quadBlockMaxX[20] PROGMEM = { 18, 21, 24, 28, 33, 38, 44, 50, 58, 65, 74, 82, 91, 100, 109, 118, 127, 136, 145, 154 };
|
|
const int16_t quadBlockMinY[20] PROGMEM = { 100, 91, 83, 74, 66, 59, 51, 45, 40, 36, 33, 31, 30, 29, 28, 28, 27, 27, 27, 27 };
|
|
const int16_t quadBlockMaxY[20] PROGMEM = { 112, 103, 95, 87, 79, 72, 65, 59, 53, 49, 46, 43, 41, 40, 39, 38, 38, 37, 37, 37 };
|
|
|
|
const float quadBlockNx[20][4] PROGMEM = {
|
|
{ -0.94779f, -0.31891f, 0.94779f, 0.31891f },
|
|
{ -0.93472f, -0.35539f, 0.93472f, 0.35539f },
|
|
{ -0.91662f, -0.39976f, 0.91662f, 0.39976f },
|
|
{ -0.89115f, -0.45372f, 0.89115f, 0.45372f },
|
|
{ -0.85466f, -0.51919f, 0.85466f, 0.51919f },
|
|
{ -0.80234f, -0.59687f, 0.80234f, 0.59687f },
|
|
{ -0.72909f, -0.68442f, 0.72909f, 0.68442f },
|
|
{ -0.63267f, -0.77442f, 0.63267f, 0.77442f },
|
|
{ -0.51899f, -0.85478f, 0.51899f, 0.85478f },
|
|
{ -0.40261f, -0.91537f, 0.40261f, 0.91537f },
|
|
{ -0.29860f, -0.95438f, 0.29860f, 0.95438f },
|
|
{ -0.21498f, -0.97662f, 0.21498f, 0.97662f },
|
|
{ -0.15215f, -0.98836f, 0.15215f, 0.98836f },
|
|
{ -0.10673f, -0.99429f, 0.10673f, 0.99429f },
|
|
{ -0.07452f, -0.99722f, 0.07452f, 0.99722f },
|
|
{ -0.05192f, -0.99865f, 0.05192f, 0.99865f },
|
|
{ -0.03612f, -0.99935f, 0.03612f, 0.99935f },
|
|
{ -0.02513f, -0.99968f, 0.02513f, 0.99968f },
|
|
{ -0.01747f, -0.99985f, 0.01747f, 0.99985f },
|
|
{ -0.01214f, -0.99993f, 0.01214f, 0.99993f },
|
|
};
|
|
|
|
const float quadBlockNy[20][4] PROGMEM = {
|
|
{ -0.31891f, 0.94779f, 0.31891f, -0.94779f },
|
|
{ -0.35539f, 0.93472f, 0.35539f, -0.93472f },
|
|
{ -0.39976f, 0.91662f, 0.39976f, -0.91662f },
|
|
{ -0.45372f, 0.89115f, 0.45372f, -0.89115f },
|
|
{ -0.51919f, 0.85466f, 0.51919f, -0.85466f },
|
|
{ -0.59687f, 0.80234f, 0.59687f, -0.80234f },
|
|
{ -0.68442f, 0.72909f, 0.68442f, -0.72909f },
|
|
{ -0.77442f, 0.63267f, 0.77442f, -0.63267f },
|
|
{ -0.85478f, 0.51899f, 0.85478f, -0.51899f },
|
|
{ -0.91537f, 0.40261f, 0.91537f, -0.40261f },
|
|
{ -0.95438f, 0.29860f, 0.95438f, -0.29860f },
|
|
{ -0.97662f, 0.21498f, 0.97662f, -0.21498f },
|
|
{ -0.98836f, 0.15215f, 0.98836f, -0.15215f },
|
|
{ -0.99429f, 0.10673f, 0.99429f, -0.10673f },
|
|
{ -0.99722f, 0.07452f, 0.99722f, -0.07452f },
|
|
{ -0.99865f, 0.05192f, 0.99865f, -0.05192f },
|
|
{ -0.99935f, 0.03612f, 0.99935f, -0.03612f },
|
|
{ -0.99968f, 0.02513f, 0.99968f, -0.02513f },
|
|
{ -0.99985f, 0.01747f, 0.99985f, -0.01747f },
|
|
{ -0.99993f, 0.01214f, 0.99993f, -0.01214f },
|
|
};
|
|
|
|
const float quadBlockC[20][4] PROGMEM = {
|
|
{ 49.3731f, -92.9228f, -41.1731f, 100.9228f },
|
|
{ 52.9126f, -82.0215f, -44.7126f, 90.0215f },
|
|
{ 56.7515f, -70.4863f, -48.5515f, 78.4863f },
|
|
{ 60.8192f, -58.1314f, -52.6192f, 66.1314f },
|
|
{ 64.9598f, -44.6227f, -56.7598f, 52.6227f },
|
|
{ 68.8007f, -29.6371f, -60.6007f, 37.6371f },
|
|
{ 71.6789f, -12.9798f, -63.4789f, 20.9798f },
|
|
{ 72.7161f, 5.1281f, -64.5161f, 2.8719f },
|
|
{ 71.2620f, 23.7112f, -63.0620f, -15.7112f },
|
|
{ 67.5191f, 41.3967f, -59.3191f, -33.3967f },
|
|
{ 62.4933f, 57.2743f, -54.2933f, -49.2743f },
|
|
{ 57.2945f, 71.2057f, -49.0945f, -63.2057f },
|
|
{ 52.6178f, 83.5542f, -44.4178f, -75.5542f },
|
|
{ 48.7270f, 94.7806f, -40.5270f, -86.7806f },
|
|
{ 45.6295f, 105.2669f, -37.4295f, -97.2669f },
|
|
{ 43.2291f, 115.2686f, -35.0291f, -107.2686f },
|
|
{ 41.3977f, 124.9666f, -33.1977f, -116.9666f },
|
|
{ 40.0175f, 134.4587f, -31.8175f, -126.4587f },
|
|
{ 38.9847f, 143.8219f, -30.7847f, -135.8219f },
|
|
{ 38.2169f, 153.0966f, -30.0169f, -145.0966f },
|
|
};
|
|
|
|
// Draw an individual solid rectangular block for 4-quadrant view with smooth subpixel anti-aliasing
|
|
inline void drawQuadBarBlock(uint8_t cell, uint8_t i, uint16_t color) {
|
|
int16_t ox = cell4_x[cell];
|
|
int16_t oy = cell4_y[cell];
|
|
int16_t minX = pgm_read_word(&quadBlockMinX[i]);
|
|
int16_t maxX = pgm_read_word(&quadBlockMaxX[i]);
|
|
int16_t minY = pgm_read_word(&quadBlockMinY[i]);
|
|
int16_t maxY = pgm_read_word(&quadBlockMaxY[i]);
|
|
|
|
float nx[4], ny[4], c[4];
|
|
for (uint8_t k = 0; k < 4; k++) {
|
|
nx[k] = pgm_read_float(&quadBlockNx[i][k]);
|
|
ny[k] = pgm_read_float(&quadBlockNy[i][k]);
|
|
c[k] = pgm_read_float(&quadBlockC[i][k]);
|
|
}
|
|
|
|
tft.startWrite();
|
|
for (int16_t y = minY; y <= maxY; y++) {
|
|
float py = (float)y + 0.5f;
|
|
int16_t sy = oy + y;
|
|
for (int16_t x = minX; x <= maxX; x++) {
|
|
float px = (float)x + 0.5f;
|
|
float min_d = 999.0f;
|
|
for (uint8_t k = 0; k < 4; k++) {
|
|
float d = px * nx[k] + py * ny[k] + c[k];
|
|
if (d < min_d) min_d = d;
|
|
}
|
|
if (min_d <= -0.5f) continue;
|
|
int16_t sx = ox + x;
|
|
if (color == TFT_BLACK) {
|
|
tft.drawPixel(sx, sy, TFT_BLACK);
|
|
} else {
|
|
if (min_d >= 0.5f) {
|
|
tft.drawPixel(sx, sy, color);
|
|
} else {
|
|
uint8_t alpha = (uint8_t)((min_d + 0.5f) * 255.0f);
|
|
tft.drawPixel(sx, sy, color, alpha, TFT_BLACK);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
tft.endWrite();
|
|
}
|
|
|
|
/* ####################################
|
|
draw digital numeric meter 160x80 px
|
|
####################################
|
|
cell
|
|
1 , 2 , 3
|
|
4 , 5 , 6
|
|
7 , 8 , 9 */
|
|
void numericMeter(uint8_t cell, uint8_t pid) {
|
|
int w = screenWidth / 2;
|
|
int h = screenHeight / 3;
|
|
int x = cell1_x[cell - 1];
|
|
int y = cell1_y[cell - 1];
|
|
// Array data -> { Label , unit, pid, fomula, min, max, ,skip, digit }
|
|
String label = pidConfig[pid][0]; // get PID to label
|
|
tft.drawRect(x, y, w, screenHeight, TFT_GREY);
|
|
tft.fillRect(x + 2, y + 2, w - 5, h - 5, TFT_BLACK);
|
|
tft.fillRectVGradient(x + 2, y + 2, w - 5, h * 0.33, TFT_BLUE, 0x0011);
|
|
drawPidIcon(x + 4, y + 2, pidConfig[pid][2]);
|
|
tft.setTextColor(TFT_WHITE);
|
|
tft.drawCentreString(label, x + w / 2, y + 2, 4);
|
|
tft.setTextColor(TFT_GREEN, TFT_BLACK);
|
|
tft.drawRightString("---", x + w - 5, y + (h * 0.25) + 11, 6);
|
|
|
|
} // numericMeter
|
|
/*---------------------------*/
|
|
// plot number on digital Meter
|
|
void plotNumeric(uint8_t cell, float data, int warn, bool digit) {
|
|
int compare = warn / data; // compare data and warn
|
|
if (compare == 0) { // warning
|
|
int w = screenWidth / 2 - 1;
|
|
int h = screenHeight / 3 - 1;
|
|
int x = cell1_x[cell - 1];
|
|
int y = cell1_y[cell - 1];
|
|
if (blinkCell[cell]) { // show
|
|
String result = String(data, digit);
|
|
switch (result.length()) {
|
|
case 2:
|
|
result = " " + result;
|
|
break;
|
|
case 3:
|
|
result = " " + result;
|
|
break;
|
|
case 4:
|
|
result = " " + result;
|
|
break;
|
|
} // switch
|
|
old_data[pidIndex] = data; // update old data
|
|
tft.setTextColor(TFT_RED, TFT_BLACK); // red color font
|
|
tft.drawRightString(result.c_str(), x + w - 5, y + (h * 0.25) + 11, 6);
|
|
|
|
} else { // hiding make blinking effect
|
|
tft.fillRect(x + 2, y + 28, w - 5, 50, TFT_BLACK); // delete old number
|
|
}
|
|
blinkCell[cell] = !blinkCell[cell];
|
|
|
|
} else { // no warning
|
|
|
|
if (data != old_data[pidIndex]) { // if value change then redraw new data
|
|
int w = screenWidth / 2 - 1;
|
|
int h = screenHeight / 3 - 1;
|
|
int x = cell1_x[cell - 1];
|
|
int y = cell1_y[cell - 1];
|
|
|
|
String result = String(data, digit);
|
|
switch (result.length()) {
|
|
case 2:
|
|
result = " " + result;
|
|
break;
|
|
case 3:
|
|
result = " " + result;
|
|
break;
|
|
case 4:
|
|
result = " " + result;
|
|
break;
|
|
} // if data
|
|
tft.setTextColor(TFT_GREEN, TFT_BLACK); // green color font
|
|
tft.drawRightString(result.c_str(), x + w - 5, y + (h * 0.25) + 11, 6);
|
|
old_data[pidIndex] = data; // update old data
|
|
} // if nothing changed then skip
|
|
} // if warn/data == 0
|
|
}
|
|
|
|
/* ##########################
|
|
draw analog meter 160x80 px
|
|
##########################
|
|
cell
|
|
1 , 2 , 3
|
|
4 , 5 , 6
|
|
7 , 8 , 9 */
|
|
void arcMeter(uint8_t cell, uint8_t pid) {
|
|
int w = screenWidth / 2;
|
|
int h = screenHeight / 3;
|
|
int x = cell1_x[cell - 1];
|
|
int y = cell1_y[cell - 1];
|
|
// Array data -> { Label , unit, pid, fomula, min, max, ,skip, digit }
|
|
String label = pidConfig[pid][0]; // get PID to label
|
|
String unit = pidConfig[pid][1]; // get PID to unit
|
|
int min = pidConfig[pid][4].toInt(); // get PID to min
|
|
int max = pidConfig[pid][5].toInt(); // get PID to max
|
|
// Meter outline
|
|
tft.fillRect(x, y, w, h, TFT_GREY);
|
|
tft.fillRect(x + 2, y + 2, 156, 76, TFT_BLACK);
|
|
tft.setTextColor(TFT_WHITE); // Text colour
|
|
tft.drawCentreString(String(min).c_str(), x + 16, y + 10, 2);
|
|
tft.drawCentreString(String(max).c_str(), x + w - 16, y + 10, 2);
|
|
tft.drawRightString(unit.c_str(), x + 150, y + 60,
|
|
2); // Units at bottom right
|
|
tft.drawCentreString(label.c_str(), x + 80, y + 58,
|
|
2); // Comment out to avoid font 4
|
|
tft.setTextColor(TFT_GREEN);
|
|
tft.drawString("---", x + 10, y + 60, 2); // data
|
|
// draw arc animation
|
|
for (int angle = 135; angle < 225; angle++) {
|
|
tft.drawSmoothArc(x + 80, y + 90, 80, 60, 134, angle, TFT_GREEN,
|
|
TFT_DARKGREY, false);
|
|
}
|
|
for (int angle = 224; angle > 135; angle--) {
|
|
tft.drawSmoothArc(x + 80, y + 90, 80, 60, angle + 1, 226, TFT_WHITE,
|
|
TFT_DARKGREY, false);
|
|
}
|
|
}
|
|
// #########################################################################
|
|
void plotArc(uint8_t cell, String label, float data, int warn, int min, int max,
|
|
bool digit) {
|
|
if (data != old_data[pidIndex]) {
|
|
// int w = screenWidth / 2 - 1;
|
|
// int h = screenHeight / 3 - 1;
|
|
int x = cell1_x[cell - 1];
|
|
int y = cell1_y[cell - 1];
|
|
|
|
String result = String(data, digit);
|
|
switch (result.length()) {
|
|
case 2:
|
|
result = result + " ";
|
|
break;
|
|
case 3:
|
|
result = result + " ";
|
|
break;
|
|
case 4:
|
|
result = result + " ";
|
|
break;
|
|
}
|
|
|
|
if (data < min)
|
|
data = min;
|
|
if (data > max)
|
|
data = max;
|
|
|
|
int arcColor = TFT_GREEN;
|
|
int compare = warn / data; // compare data and warn
|
|
if (compare == 0) // warning
|
|
arcColor = TFT_RED; // red font red arc
|
|
else // no warn
|
|
arcColor = TFT_GREEN; // gren font green arc
|
|
tft.setTextColor(arcColor, TFT_BLACK);
|
|
tft.drawString(result.c_str(), x + 10, y + 60, 2); // data
|
|
int angle = map(data, min, max, 135, 225);
|
|
if (data >= old_data[pidIndex]) // new data > old data -> draw only green
|
|
// arc
|
|
tft.drawSmoothArc(x + 80, y + 90, 80, 60, 134, angle, arcColor,
|
|
TFT_DARKGREY, false);
|
|
else // new data < old data -> draw only white arc
|
|
tft.drawSmoothArc(x + 80, y + 90, 80, 60, angle + 1, 226, TFT_WHITE,
|
|
TFT_DARKGREY, false);
|
|
old_data[pidIndex] = data; // update old data
|
|
} // if
|
|
}
|
|
/* ######################################
|
|
draw linear vertical meter 80x240 px
|
|
######################################
|
|
cell 1 , 2 , 3 , 4 */
|
|
// vertical meter cell 1 to 4 full screen height
|
|
void vBarMeter(uint8_t cell, uint8_t pid) {
|
|
int x = cell2_x[cell - 1]; // start origin
|
|
int w = screenWidth / 4;
|
|
// Array data -> { Label , unit, pid, fomula, min, max, ,skip, digit }
|
|
String label = pidConfig[pid][0]; // get PID to label
|
|
String unit = pidConfig[pid][1]; // get PID to unit
|
|
// int min = pidConfig[pid][4].toInt(); //get PID to min
|
|
int max = pidConfig[pid][5].toInt(); // get PID to max
|
|
tft.drawRect(x, 0, w, screenHeight, TFT_DARKGREY);
|
|
tft.fillRectVGradient(x + 2, 2, w - 3, screenHeight * 0.12 - 10, TFT_BLUE,
|
|
0x0011);
|
|
tft.fillRect(x + 2, screenHeight * 0.12, w - 3,
|
|
screenHeight - screenHeight * 0.24, TFT_BLACK);
|
|
tft.setTextColor(TFT_WHITE);
|
|
tft.drawCentreString(label, x + w / 2, 2, 2);
|
|
tft.setTextColor(TFT_WHITE, TFT_BLACK);
|
|
tft.drawString(unit, x + 3, screenHeight * 0.12 - 8, 1);
|
|
tft.setTextColor(TFT_GREEN, TFT_BLACK);
|
|
tft.setTextPadding(w - 6);
|
|
tft.drawRightString("---", x + w - 4,
|
|
screenHeight - (screenHeight * 0.12) + 1, 4);
|
|
tft.setTextPadding(0);
|
|
float smalltick = screenHeight * 0.75 / 50;
|
|
// float bigtick = screenHeight*0.75/10;
|
|
// draw number
|
|
tft.setTextColor(TFT_WHITE, TFT_BLACK);
|
|
// tft.drawRigscreenHeighttString("120",x+w-2,y+screenHeight*0.12+2,1);
|
|
for (int i = 0; i < 51; i++) { // draw tick
|
|
tft.drawFastHLine(x + w / 3, screenHeight * 0.12 + smalltick * i + 3, 10,
|
|
TFT_WHITE);
|
|
if (i % 5 == 0) {
|
|
tft.drawFastHLine(x + w / 3, screenHeight * 0.12 + smalltick * i + 3, 20,
|
|
TFT_WHITE);
|
|
if (i % 10 == 0) {
|
|
int mark = max - (max * i * 2 / 100);
|
|
tft.drawRightString(String(mark), x + w - 3,
|
|
screenHeight * 0.12 + smalltick * i - 7, 2);
|
|
} // i%10
|
|
} // i%5
|
|
} // for i
|
|
// animation
|
|
for (int barH = 0; barH < 183; barH++) { // draw bar
|
|
tft.fillRect(x + 5, 212 - barH, 20, barH, TFT_RED); // lower
|
|
}
|
|
for (int barH = 182; barH >= 0; barH--) { // draw bar
|
|
tft.fillRect(x + 5, 29, 20, 183 - barH, TFT_BLACK); // upper
|
|
}
|
|
} // drawLinerVmeter
|
|
/*-------------------*/
|
|
// vertical meter cell 1 to 4 full screen height
|
|
void plotVBar(uint8_t cell, float data, int warn, int min, int max,
|
|
bool digit) { // cell 1-4
|
|
if (data != old_data[pidIndex]) { // if value change then redraw new data
|
|
int x = cell2_x[cell - 1];
|
|
int w = screenWidth / 4;
|
|
if (data < min)
|
|
data = min;
|
|
if (data > max)
|
|
data = max;
|
|
int barColor = TFT_GREEN;
|
|
int compare = warn / data; // compare data and warn
|
|
if (compare == 0) // warning
|
|
barColor = TFT_RED; // red bar red font
|
|
else // no warn
|
|
barColor = TFT_GREEN; // green bar green font
|
|
// draw new bar
|
|
int barH = map(data, min, max, 0, 182);
|
|
if (data > old_data[pidIndex]) // new data > old data -> draw red bar
|
|
tft.fillRectVGradient(x + 5, 212 - barH, 20, barH, barColor,
|
|
0x8000); // lower
|
|
else // new data < old data -> draw black bar
|
|
tft.fillRect(x + 5, 29, 20, 183 - barH, TFT_BLACK); // upper
|
|
|
|
tft.setTextColor(barColor, TFT_BLACK); // draw text
|
|
String result = String(data, digit);
|
|
switch (result.length()) {
|
|
case 2:
|
|
result = " " + result + " ";
|
|
break;
|
|
case 3:
|
|
result = " " + result + " ";
|
|
break;
|
|
case 4:
|
|
result = " " + result + " ";
|
|
break;
|
|
}
|
|
tft.setTextPadding(w - 6);
|
|
tft.drawRightString(result.c_str(), x + w - 4,
|
|
screenHeight - (screenHeight * 0.12) + 1, 4);
|
|
tft.setTextPadding(0);
|
|
old_data[pidIndex] = data; // update old data
|
|
} // if
|
|
}
|
|
/*-------------------*/
|
|
///*-------------------*/
|
|
// 7-segment bitmask table: a, b, c, d, e, f, g
|
|
static const uint8_t seg7_map[10] = {
|
|
0b00111111, // 0
|
|
0b00000110, // 1
|
|
0b01011011, // 2
|
|
0b01001111, // 3
|
|
0b01100110, // 4
|
|
0b01101101, // 5
|
|
0b01111101, // 6
|
|
0b00000111, // 7
|
|
0b01111111, // 8
|
|
0b01101111 // 9
|
|
};
|
|
|
|
void draw7SegString(int x, int y, const char *str, uint8_t dW, uint8_t dH,
|
|
uint8_t t, uint16_t fg, uint16_t bg) {
|
|
int curX = x;
|
|
while (*str) {
|
|
char c = *str++;
|
|
if (c >= '0' && c <= '9') {
|
|
uint8_t mask = seg7_map[c - '0'];
|
|
uint16_t ca = (mask & 0x01) ? fg : bg;
|
|
uint16_t cb = (mask & 0x02) ? fg : bg;
|
|
uint16_t cc = (mask & 0x04) ? fg : bg;
|
|
uint16_t cd = (mask & 0x08) ? fg : bg;
|
|
uint16_t ce = (mask & 0x10) ? fg : bg;
|
|
uint16_t cf = (mask & 0x20) ? fg : bg;
|
|
uint16_t cg = (mask & 0x40) ? fg : bg;
|
|
|
|
tft.fillRect(curX + t, y, dW - 2 * t, t, ca);
|
|
tft.fillRect(curX + dW - t, y + t, t, (dH / 2) - t, cb);
|
|
tft.fillRect(curX + dW - t, y + (dH / 2), t, (dH / 2) - t, cc);
|
|
tft.fillRect(curX + t, y + dH - t, dW - 2 * t, t, cd);
|
|
tft.fillRect(curX, y + (dH / 2), t, (dH / 2) - t, ce);
|
|
tft.fillRect(curX, y + t, t, (dH / 2) - t, cf);
|
|
tft.fillRect(curX + t, y + (dH / 2) - (t / 2), dW - 2 * t, t, cg);
|
|
|
|
curX += dW + t;
|
|
} else if (c == '-') {
|
|
tft.fillRect(curX + t, y + (dH / 2) - (t / 2), dW - 2 * t, t, fg);
|
|
curX += dW + t;
|
|
} else if (c == '.') {
|
|
tft.fillRect(curX + 1, y + dH - t, t, t, fg);
|
|
curX += t + 3;
|
|
} else if (c == ' ') {
|
|
curX += dW / 2;
|
|
}
|
|
}
|
|
}
|
|
|
|
int get7SegWidth(const char *str, uint8_t dW, uint8_t t) {
|
|
int total = 0;
|
|
while (*str) {
|
|
char c = *str++;
|
|
if (c >= '0' && c <= '9')
|
|
total += dW + t;
|
|
else if (c == '-')
|
|
total += dW + t;
|
|
else if (c == '.')
|
|
total += t + 3;
|
|
else if (c == ' ')
|
|
total += dW / 2;
|
|
}
|
|
if (total > t)
|
|
total -= t;
|
|
return total;
|
|
}
|
|
|
|
// Draw blue header background for a 160x120 quadrant (25px height) with lateral and vertical smooth fade
|
|
void drawQuadHeaderGradient(uint8_t cell) {
|
|
int16_t ox = cell4_x[cell];
|
|
int16_t oy = cell4_y[cell];
|
|
uint16_t lineBuf[160];
|
|
const float fade_w_left = 12.0f;
|
|
const float fade_w_right = 12.0f;
|
|
const float x_right_start = 160.0f - fade_w_right;
|
|
|
|
tft.startWrite();
|
|
tft.setAddrWindow(ox, oy, 160, 25);
|
|
for (int16_t y = 0; y < 25; y++) {
|
|
float vy;
|
|
if (y < 14) {
|
|
vy = 1.0f;
|
|
} else {
|
|
float t = (24.0f - (float)y) / 10.0f;
|
|
vy = t * t * (3.0f - 2.0f * t);
|
|
}
|
|
for (int16_t x = 0; x < 160; x++) {
|
|
float hx = 1.0f;
|
|
if (x < (int16_t)fade_w_left) {
|
|
float t = (float)x / fade_w_left;
|
|
hx = t * t * (3.0f - 2.0f * t);
|
|
} else if (x > (int16_t)x_right_start) {
|
|
float t = (159.0f - (float)x) / fade_w_right;
|
|
if (t < 0.0f) t = 0.0f;
|
|
hx = t * t * (3.0f - 2.0f * t);
|
|
}
|
|
float b = vy * hx;
|
|
uint8_t g = (uint8_t)(140.0f * b);
|
|
uint8_t bl = (uint8_t)(255.0f * b);
|
|
lineBuf[x] = tft.color565(0, g, bl);
|
|
}
|
|
tft.pushPixels(lineBuf, 160);
|
|
}
|
|
tft.endWrite();
|
|
}
|
|
|
|
// Forward declarations
|
|
void plotArc4(uint8_t cell, float data, int warn, int min, int max, bool digit,
|
|
String unit);
|
|
void plotFullScreen(uint8_t cell, float data, int warn, int min, int max,
|
|
bool digit, String unit);
|
|
void plotNoData(uint8_t cell);
|
|
|
|
// 4-quadrant divider styling
|
|
const uint16_t QUAD_DIV_COLOR = 0x632C;
|
|
|
|
inline void drawQuadrantDividers() {
|
|
uint16_t divCol = getThemeDivColor();
|
|
tft.fillRect(159, 0, 2, 240, divCol);
|
|
tft.fillRect(0, 119, 320, 2, divCol);
|
|
}
|
|
|
|
// Determine display color for meter:
|
|
// Instrumentos: Color del tema activo (normal) o TFT_RED (alarma/peligro)
|
|
inline uint16_t getMeterColor(uint8_t pidIdx, float data, int warn = -1) {
|
|
if (pidIdx >= 4) return getThemePrimaryColor();
|
|
|
|
float warnVal = (warn > 0) ? (float)warn : warningValue[pidIdx].toFloat();
|
|
|
|
if (pidIdx == 0) { // 0 = Temperatura ECT (PID 0105)
|
|
if (warnVal <= 0 || warnVal == 106.0f) warnVal = 110.0f;
|
|
if (data >= warnVal) return TFT_RED;
|
|
return getThemePrimaryColor();
|
|
}
|
|
if (pidIdx == 1) { // 1 = RPM (PID 010C)
|
|
if (warnVal <= 0) warnVal = 5000.0f;
|
|
if (data >= warnVal) return TFT_RED;
|
|
return getThemePrimaryColor();
|
|
}
|
|
if (pidIdx == 2) { // 2 = Voltaje (PID 0142)
|
|
if (warnVal <= 0) warnVal = 15.0f;
|
|
// Si el dato es 0 (contacto apagado / desconectado) o motor detenido, no disparar alarma por < 12V
|
|
if (data <= 1.0f) return getThemePrimaryColor();
|
|
if (currentRpm <= 0.0f) {
|
|
if (data >= warnVal) return TFT_RED;
|
|
return getThemePrimaryColor();
|
|
}
|
|
if (data < 12.0f || data >= warnVal) return TFT_RED;
|
|
return getThemePrimaryColor();
|
|
}
|
|
if (pidIdx == 3) { // 3 = Velocidad (PID 010D)
|
|
if (warnVal <= 0) warnVal = 130.0f;
|
|
if (data >= warnVal) return TFT_RED;
|
|
return getThemePrimaryColor();
|
|
}
|
|
if (warnVal > 0 && data >= warnVal) return TFT_RED;
|
|
return getThemePrimaryColor();
|
|
}
|
|
|
|
// Compute block count (0..NUM_BAR_BLOCKS) with sub-integer floating point precision
|
|
inline int calcMeterBlocks(float val, int min, int max) {
|
|
float range = (float)(max - min);
|
|
if (range <= 0.0f) return 0;
|
|
if (val <= (float)min) return 0;
|
|
if (val >= (float)max) return NUM_BAR_BLOCKS;
|
|
int b = (int)(((val - (float)min) / range) * (float)NUM_BAR_BLOCKS + 0.5f);
|
|
if (b < 0) b = 0;
|
|
if (b > NUM_BAR_BLOCKS) b = NUM_BAR_BLOCKS;
|
|
return b;
|
|
}
|
|
|
|
|
|
|
|
// 4-quadrant Exponential Segmented Block Meter (160x120 px) - identical to full screen style
|
|
void arcMeter4(uint8_t cell, uint8_t pid, bool redrawHeader = true) {
|
|
int x = cell4_x[cell];
|
|
int y = cell4_y[cell];
|
|
int rx = (cell & 1) ? 161 : 0;
|
|
int ry = (cell & 2) ? 121 : 0;
|
|
|
|
// Ambient vignette gradient (theme tint fading to black)
|
|
tft.fillRectVGradient(rx, ry, 159, 82, getThemeBgColor(), TFT_BLACK);
|
|
tft.fillRect(rx, ry + 82, 159, 37, TFT_BLACK);
|
|
drawPidIcon(x + 5, y + 3, pidConfig[pid][2]);
|
|
drawQuadrantDividers();
|
|
|
|
// Initialize all 20 blocks in METER_INACTIVE_COLOR
|
|
for (uint8_t i = 0; i < NUM_BAR_BLOCKS; i++) {
|
|
drawQuadBarBlock(cell, i, METER_INACTIVE_COLOR);
|
|
}
|
|
|
|
int min = pidConfig[pid][4].toInt();
|
|
int max = pidConfig[pid][5].toInt();
|
|
bool digit = pidConfig[pid][7].toInt();
|
|
int warn = warningValue[pid].toInt();
|
|
String unit = pidConfig[pid][1];
|
|
|
|
if (last_valid_data[cell] != -999) {
|
|
old_data[cell] = -999;
|
|
plotArc4(cell, last_valid_data[cell], warn, min, max, digit, unit);
|
|
} else {
|
|
// Value placeholder using DSEG7 Modern 34pt smooth font
|
|
tft.loadFont(DSEG7_Modern_BoldItalic_34);
|
|
tft.setTextColor(getThemePrimaryColor(), TFT_BLACK);
|
|
tft.setTextPadding(114);
|
|
tft.drawRightString("---", x + 152, y + 74, 1);
|
|
tft.setTextPadding(0);
|
|
tft.unloadFont();
|
|
old_data[cell] = -999;
|
|
}
|
|
}
|
|
|
|
void plotArc4(uint8_t cell, float data, int warn, int min, int max, bool digit,
|
|
String unit) {
|
|
if (data == old_data[cell])
|
|
return;
|
|
int x = cell4_x[cell];
|
|
int y = cell4_y[cell];
|
|
|
|
uint8_t pidIdx = pidInCell[cell];
|
|
uint16_t col = getMeterColor(pidIdx, data, warn);
|
|
uint16_t oldCol = (old_data[cell] <= -900) ? 0 : getMeterColor(pidIdx, old_data[cell], warn);
|
|
|
|
String numStr = String(data, digit);
|
|
|
|
int newBlocks = calcMeterBlocks(data, min, max);
|
|
int oldBlocks = (old_data[cell] <= -900) ? 0 : calcMeterBlocks(old_data[cell], min, max);
|
|
|
|
bool colorChanged = (col != oldCol);
|
|
if (col == TFT_RED) {
|
|
if (!wasInRedAlarm[cell]) {
|
|
drawPidIcon(x + 5, y + 3, pidConfig[pidIdx][2]);
|
|
}
|
|
wasInRedAlarm[cell] = true;
|
|
if (colorChanged) {
|
|
arcFlashVisible = true;
|
|
lastArcFlashTime = millis();
|
|
drawPidIcon(x + 5, y + 3, pidConfig[pidIdx][2]);
|
|
for (uint8_t i = 0; i < newBlocks; i++) {
|
|
drawQuadBarBlock(cell, i, TFT_RED);
|
|
}
|
|
for (uint8_t i = newBlocks; i < NUM_BAR_BLOCKS; i++) {
|
|
drawQuadBarBlock(cell, i, METER_INACTIVE_COLOR);
|
|
}
|
|
} else if (arcFlashVisible || !alarmEnabled[pidIdx]) {
|
|
if (newBlocks > oldBlocks) {
|
|
for (uint8_t i = oldBlocks; i < newBlocks; i++) {
|
|
drawQuadBarBlock(cell, i, TFT_RED);
|
|
}
|
|
} else if (newBlocks < oldBlocks) {
|
|
for (uint8_t i = newBlocks; i < oldBlocks; i++) {
|
|
drawQuadBarBlock(cell, i, METER_INACTIVE_COLOR);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (wasInRedAlarm[cell]) {
|
|
drawPidIcon(x + 5, y + 3, pidConfig[pidIdx][2]);
|
|
}
|
|
wasInRedAlarm[cell] = false;
|
|
if (colorChanged || old_data[cell] <= -900) {
|
|
for (uint8_t i = 0; i < newBlocks; i++) {
|
|
drawQuadBarBlock(cell, i, col);
|
|
}
|
|
for (uint8_t i = newBlocks; i < NUM_BAR_BLOCKS; i++) {
|
|
drawQuadBarBlock(cell, i, METER_INACTIVE_COLOR);
|
|
}
|
|
} else if (newBlocks > oldBlocks) {
|
|
for (uint8_t i = oldBlocks; i < newBlocks; i++) {
|
|
drawQuadBarBlock(cell, i, col);
|
|
}
|
|
} else if (newBlocks < oldBlocks) {
|
|
for (uint8_t i = newBlocks; i < oldBlocks; i++) {
|
|
drawQuadBarBlock(cell, i, METER_INACTIVE_COLOR);
|
|
}
|
|
}
|
|
}
|
|
|
|
uint16_t txtCol = getThemePrimaryColor();
|
|
|
|
tft.loadFont(DSEG7_Modern_BoldItalic_34);
|
|
tft.setTextColor(txtCol, TFT_BLACK);
|
|
tft.setTextPadding(114);
|
|
tft.drawRightString(numStr.c_str(), x + 152, y + 74, 1);
|
|
tft.setTextPadding(0);
|
|
tft.unloadFont();
|
|
old_data[cell] = data;
|
|
}
|
|
|
|
void fullScreenMeter(uint8_t cell, uint8_t pid, bool redrawHeader = true) {
|
|
fullScreenCell = cell;
|
|
String label = pidConfig[pid][0];
|
|
String unit = pidConfig[pid][1];
|
|
if (unit == "volt")
|
|
unit = "V";
|
|
|
|
if (redrawHeader) {
|
|
// Ambient vignette gradient from y=0 fading to black (matching 4 quadrants style)
|
|
tft.fillRectVGradient(0, 0, 320, 145, getThemeBgColor(), TFT_BLACK);
|
|
tft.fillRect(0, 145, 320, 95, TFT_BLACK);
|
|
|
|
drawPidIconHeader(10, 4, pidConfig[pid][2]);
|
|
uint16_t titleCol = (getMeterColor(pid, last_valid_data[cell]) == TFT_RED && alarmEnabled[pid]) ? TFT_RED : TFT_WHITE;
|
|
tft.setTextColor(titleCol);
|
|
tft.drawCentreString(label.c_str(), 175, 12, 4);
|
|
} else {
|
|
tft.fillRectVGradient(0, 51, 320, 94, tft.alphaBlend((uint8_t)(255 * (145 - 51) / 145), getThemeBgColor(), TFT_BLACK), TFT_BLACK);
|
|
tft.fillRect(0, 145, 320, 95, TFT_BLACK);
|
|
}
|
|
|
|
int min = pidConfig[pid][4].toInt();
|
|
int max = pidConfig[pid][5].toInt();
|
|
bool digit = pidConfig[pid][7].toInt();
|
|
int warn = warningValue[pid].toInt();
|
|
|
|
if (last_valid_data[cell] != -999) {
|
|
old_data[cell] = -999;
|
|
plotFullScreen(cell, last_valid_data[cell], warn, min, max, digit, unit);
|
|
} else {
|
|
// Exponential segmented block mode full screen (18 discrete blocks, 3mm x 5mm, 1mm gap)
|
|
for (uint8_t i = 0; i < NUM_BAR_BLOCKS; i++) {
|
|
drawBarBlock(i, METER_INACTIVE_COLOR);
|
|
}
|
|
|
|
tft.loadFont(DSEG7_Modern_BoldItalic_80);
|
|
tft.setTextColor(getThemePrimaryColor(), TFT_BLACK);
|
|
tft.setTextPadding(240);
|
|
tft.drawRightString("---", 312, 148, 1);
|
|
tft.setTextPadding(0);
|
|
tft.unloadFont();
|
|
old_data[cell] = -999;
|
|
}
|
|
}
|
|
|
|
void plotFullScreen(uint8_t cell, float data, int warn, int min, int max,
|
|
bool digit, String unit) {
|
|
if (data == old_data[cell])
|
|
return;
|
|
uint8_t pidIdx = pidInCell[cell];
|
|
uint16_t col = getMeterColor(pidIdx, data, warn);
|
|
uint16_t oldCol = (old_data[cell] <= -900) ? 0 : getMeterColor(pidIdx, old_data[cell], warn);
|
|
|
|
String numStr = String(data, digit);
|
|
|
|
int newBlocks = calcMeterBlocks(data, min, max);
|
|
int oldBlocks = (old_data[cell] <= -900) ? 0 : calcMeterBlocks(old_data[cell], min, max);
|
|
|
|
bool colorChanged = (col != oldCol);
|
|
if (col == TFT_RED) {
|
|
if (!wasInRedAlarm[cell]) {
|
|
drawPidIconHeader(10, 4, pidConfig[pidIdx][2]);
|
|
}
|
|
wasInRedAlarm[cell] = true;
|
|
if (colorChanged) {
|
|
arcFlashVisible = true;
|
|
lastArcFlashTime = millis();
|
|
drawPidIconHeader(10, 4, pidConfig[pidIdx][2]);
|
|
if (alarmEnabled[pidIdx]) {
|
|
drawFullScreenTitle(pidConfig[pidIdx][0], TFT_RED);
|
|
}
|
|
for (uint8_t i = 0; i < newBlocks; i++) {
|
|
drawBarBlock(i, TFT_RED);
|
|
}
|
|
for (uint8_t i = newBlocks; i < NUM_BAR_BLOCKS; i++) {
|
|
drawBarBlock(i, METER_INACTIVE_COLOR);
|
|
}
|
|
} else if (arcFlashVisible || !alarmEnabled[pidIdx]) {
|
|
if (newBlocks > oldBlocks) {
|
|
for (uint8_t i = oldBlocks; i < newBlocks; i++) {
|
|
drawBarBlock(i, TFT_RED);
|
|
}
|
|
} else if (newBlocks < oldBlocks) {
|
|
for (uint8_t i = newBlocks; i < oldBlocks; i++) {
|
|
drawBarBlock(i, METER_INACTIVE_COLOR);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (wasInRedAlarm[cell]) {
|
|
drawPidIconHeader(10, 4, pidConfig[pidIdx][2]);
|
|
}
|
|
wasInRedAlarm[cell] = false;
|
|
if (colorChanged || old_data[cell] <= -900) {
|
|
for (uint8_t i = 0; i < newBlocks; i++) {
|
|
drawBarBlock(i, col);
|
|
}
|
|
for (uint8_t i = newBlocks; i < NUM_BAR_BLOCKS; i++) {
|
|
drawBarBlock(i, METER_INACTIVE_COLOR);
|
|
}
|
|
} else if (newBlocks > oldBlocks) {
|
|
for (uint8_t i = oldBlocks; i < newBlocks; i++) {
|
|
drawBarBlock(i, col);
|
|
}
|
|
} else if (newBlocks < oldBlocks) {
|
|
for (uint8_t i = newBlocks; i < oldBlocks; i++) {
|
|
drawBarBlock(i, METER_INACTIVE_COLOR);
|
|
}
|
|
}
|
|
}
|
|
|
|
uint16_t txtCol = getThemePrimaryColor();
|
|
|
|
// Value bottom-right using DSEG7 Modern smooth font
|
|
tft.loadFont(DSEG7_Modern_BoldItalic_80);
|
|
tft.setTextColor(txtCol, TFT_BLACK);
|
|
tft.setTextPadding(240);
|
|
tft.drawRightString(numStr.c_str(), 312, 148, 1);
|
|
tft.setTextPadding(0);
|
|
tft.unloadFont();
|
|
old_data[cell] = data;
|
|
}
|
|
|
|
// Display "---" (no data) with all blocks inactive on specified quadrant or full screen
|
|
void plotNoData(uint8_t cell) {
|
|
if (cell >= 4) return;
|
|
if (old_data[cell] <= -900.0f && last_valid_data[cell] <= -900.0f) {
|
|
return; // Already showing no data, skip redraw to avoid SPI overhead
|
|
}
|
|
|
|
old_data[cell] = -999.0f;
|
|
last_valid_data[cell] = -999.0f;
|
|
wasInRedAlarm[cell] = false;
|
|
|
|
uint8_t pidIdx = pidInCell[cell];
|
|
|
|
if (fullScreenCell >= 0 && fullScreenCell < 4) {
|
|
if (cell == fullScreenCell) {
|
|
clearPidIconHeader();
|
|
drawPidIconHeader(10, 4, pidConfig[pidIdx][2]);
|
|
for (uint8_t i = 0; i < NUM_BAR_BLOCKS; i++) {
|
|
drawBarBlock(i, METER_INACTIVE_COLOR);
|
|
}
|
|
tft.loadFont(DSEG7_Modern_BoldItalic_80);
|
|
tft.setTextColor(getThemePrimaryColor(), TFT_BLACK);
|
|
tft.setTextPadding(240);
|
|
tft.drawRightString("---", 312, 148, 1);
|
|
tft.setTextPadding(0);
|
|
tft.unloadFont();
|
|
}
|
|
} else if (currentScreenPage == 0) {
|
|
int x = cell4_x[cell];
|
|
int y = cell4_y[cell];
|
|
clearPidIcon(x + 5, y + 3, pidConfig[pidIdx][2]);
|
|
drawPidIcon(x + 5, y + 3, pidConfig[pidIdx][2]);
|
|
for (uint8_t i = 0; i < NUM_BAR_BLOCKS; i++) {
|
|
drawQuadBarBlock(cell, i, METER_INACTIVE_COLOR);
|
|
}
|
|
tft.loadFont(DSEG7_Modern_BoldItalic_34);
|
|
tft.setTextColor(getThemePrimaryColor(), TFT_BLACK);
|
|
tft.setTextPadding(114);
|
|
tft.drawRightString("---", x + 152, y + 74, 1);
|
|
tft.setTextPadding(0);
|
|
tft.unloadFont();
|
|
}
|
|
}
|
|
|
|
// Render Page 0 (4 Quadrants) into double-buffered Sprite slice
|
|
inline void renderPage0ToSprite(TFT_eSprite &s, int x_offset, int y_slice, int slice_h) {
|
|
uint16_t bgCol = getThemeBgColor();
|
|
uint16_t divCol = getThemeDivColor();
|
|
uint16_t priCol = getThemePrimaryColor();
|
|
|
|
for (uint8_t c = 0; c < 4; c++) {
|
|
int qx = cell4_x[c] + x_offset;
|
|
int qy = cell4_y[c] - y_slice;
|
|
int rx = (c & 1) ? (161 + x_offset) : (0 + x_offset);
|
|
int ry = ((c & 2) ? 121 : 0) - y_slice;
|
|
|
|
if (qx + 160 <= 0 || qx >= 320 || ry + 119 <= 0 || ry >= slice_h) continue;
|
|
|
|
s.fillRect(rx, ry, 159, 119, bgCol);
|
|
|
|
uint8_t pidIdx = pidInCell[c];
|
|
s.setTextColor(TFT_WHITE, bgCol);
|
|
s.drawString(pidConfig[pidIdx][0].c_str(), qx + 8, qy + 6, 2);
|
|
|
|
int warn = warningValue[pidIdx].toInt();
|
|
int min = pidConfig[pidIdx][4].toInt();
|
|
int max = pidConfig[pidIdx][5].toInt();
|
|
bool digit = pidConfig[pidIdx][7].toInt();
|
|
float val = last_valid_data[c];
|
|
|
|
int barY = qy + 28;
|
|
s.fillRoundRect(qx + 8, barY, 144, 6, 2, METER_INACTIVE_COLOR);
|
|
if (val > -900.0f) {
|
|
uint16_t col = getMeterColor(pidIdx, val, warn);
|
|
float ratio = (val - (float)min) / (float)(max - min);
|
|
if (ratio < 0.0f) ratio = 0.0f;
|
|
if (ratio > 1.0f) ratio = 1.0f;
|
|
int fillW = (int)(ratio * 144.0f);
|
|
if (fillW < 4) fillW = 4;
|
|
if (fillW > 144) fillW = 144;
|
|
s.fillRoundRect(qx + 8, barY, fillW, 6, 2, col);
|
|
}
|
|
|
|
String numStr = (val <= -900.0f) ? "---" : String(val, digit);
|
|
s.loadFont(DSEG7_Modern_BoldItalic_34);
|
|
s.setTextColor(priCol, bgCol);
|
|
s.setTextPadding(114);
|
|
s.drawRightString(numStr.c_str(), qx + 152, qy + 70, 1);
|
|
s.setTextPadding(0);
|
|
s.unloadFont();
|
|
}
|
|
|
|
// Crosshair dividers
|
|
s.fillRect(159 + x_offset, 0, 2, slice_h, divCol);
|
|
int hLineY = 119 - y_slice;
|
|
if (hLineY >= 0 && hLineY < slice_h) {
|
|
s.fillRect(x_offset, hLineY, 320, 2, divCol);
|
|
}
|
|
}
|
|
|
|
// Render Page 1 (3 Temperature Cards) into double-buffered Sprite slice
|
|
inline void renderPage1ToSprite(TFT_eSprite &s, int x_offset, int y_slice, int slice_h) {
|
|
for (uint8_t cardIdx = 0; cardIdx < 3; cardIdx++) {
|
|
int cardY = (6 + cardIdx * 77) - y_slice;
|
|
int cardH = 73;
|
|
int cardX = 4 + x_offset;
|
|
int cardW = 312;
|
|
|
|
if (cardX + cardW <= 0 || cardX >= 320 || cardY + cardH <= 0 || cardY >= slice_h) continue;
|
|
|
|
uint16_t cardBg = 0x10A2;
|
|
uint16_t cardBorder = 0x2945;
|
|
|
|
s.fillRoundRect(cardX, cardY, cardW, cardH, 6, cardBg);
|
|
s.drawRoundRect(cardX, cardY, cardW, cardH, 6, cardBorder);
|
|
|
|
uint16_t accentCol = getThemePrimaryColor();
|
|
const char* titleStr = "";
|
|
const char* subStr = "";
|
|
float val = 0.0f;
|
|
float minRange = 0.0f, maxRange = 100.0f;
|
|
bool isInt = false;
|
|
|
|
if (cardIdx == 0) {
|
|
titleStr = "MOTOR / REFRIGERANTE";
|
|
subStr = ignitionOn ? "ECU OBD-II (PID 0105)" : "ECU OBD-II (STANDBY)";
|
|
val = tempEngineCoolant;
|
|
minRange = 60.0f; maxRange = 120.0f; isInt = true;
|
|
if (val >= 110.0f) accentCol = TFT_RED;
|
|
else if (val >= 100.0f) accentCol = TFT_YELLOW;
|
|
} else if (cardIdx == 1) {
|
|
titleStr = "HABITACULO / INTERIOR";
|
|
subStr = (dsSensorCount > 0) ? "DS18B20 SENSOR 1" : "DS18B20 SENSOR 1 (DEMO)";
|
|
val = tempInterior;
|
|
minRange = 10.0f; maxRange = 40.0f;
|
|
accentCol = 0x07F3;
|
|
} else {
|
|
titleStr = "AMBIENTE / EXTERIOR";
|
|
subStr = (dsSensorCount > 1) ? "DS18B20 SENSOR 2" : "DS18B20 SENSOR 2 (DEMO)";
|
|
val = tempExterior;
|
|
minRange = -10.0f; maxRange = 50.0f;
|
|
accentCol = 0x3D7F;
|
|
}
|
|
|
|
s.fillRoundRect(cardX + 6, cardY + 8, 4, cardH - 16, 2, accentCol);
|
|
s.setTextColor(TFT_WHITE, cardBg);
|
|
s.drawString(titleStr, cardX + 16, cardY + 8, 2);
|
|
s.setTextColor(0x8410, cardBg);
|
|
s.drawString(subStr, cardX + 16, cardY + 28, 1);
|
|
|
|
// Progress bar
|
|
int barX = cardX + 16;
|
|
int barY = cardY + 50;
|
|
int barW = 120;
|
|
s.fillRoundRect(barX, barY, barW, 8, 3, 0x18C3);
|
|
float ratio = (val - minRange) / (maxRange - minRange);
|
|
if (ratio < 0.0f) ratio = 0.0f;
|
|
if (ratio > 1.0f) ratio = 1.0f;
|
|
int fillW = (int)(barW * ratio);
|
|
if (fillW < 4) fillW = 4;
|
|
s.fillRoundRect(barX, barY, fillW, 8, 3, accentCol);
|
|
|
|
// Value text
|
|
String numStr = (val <= -900.0f) ? "---" : (isInt ? String((int)val) : String(val, 1));
|
|
s.loadFont(DSEG7_Modern_BoldItalic_34);
|
|
s.setTextColor(accentCol, cardBg);
|
|
s.setTextPadding(100);
|
|
s.drawRightString(numStr.c_str(), cardX + 262, cardY + 22, 1);
|
|
s.setTextPadding(0);
|
|
s.unloadFont();
|
|
|
|
s.setTextColor(0xC618, cardBg);
|
|
s.drawString("`C", cardX + 268, cardY + 32, 2);
|
|
}
|
|
}
|
|
|
|
// 100% Flicker-Free Double-Buffered Mobile Slide Transition
|
|
inline void animateSlideTransition(bool swipeLeft) {
|
|
touchBeep();
|
|
|
|
TFT_eSprite spr(&tft);
|
|
int slice_h = 240;
|
|
// Try 320x240 full double-buffer first; if heap is tight, allocate two 320x120 slices
|
|
if (spr.createSprite(320, 240) == nullptr) {
|
|
slice_h = 120;
|
|
if (spr.createSprite(320, 120) == nullptr) {
|
|
return; // Fallback: switch instantly without crashing if RAM is fully depleted
|
|
}
|
|
}
|
|
|
|
const uint8_t FRAMES = 10;
|
|
// Smooth cubic ease-out deceleration curve
|
|
const int16_t step_shifts[FRAMES] = { 45, 92, 140, 186, 228, 264, 290, 308, 317, 320 };
|
|
uint8_t numSlices = (slice_h == 240) ? 1 : 2;
|
|
|
|
for (uint8_t f = 0; f < FRAMES; f++) {
|
|
int16_t shift = step_shifts[f];
|
|
int16_t splitX = swipeLeft ? (320 - shift) : shift;
|
|
int16_t x0 = swipeLeft ? (-shift) : (shift - 320);
|
|
int16_t x1 = swipeLeft ? (320 - shift) : shift;
|
|
|
|
for (uint8_t s = 0; s < numSlices; s++) {
|
|
int y_slice = s * slice_h;
|
|
|
|
spr.fillSprite(TFT_BLACK);
|
|
|
|
if (splitX > 0) {
|
|
spr.setViewport(0, 0, splitX, slice_h, false);
|
|
renderPage0ToSprite(spr, x0, y_slice, slice_h);
|
|
}
|
|
if (splitX < 320) {
|
|
spr.setViewport(splitX, 0, 320 - splitX, slice_h, false);
|
|
renderPage1ToSprite(spr, x1, y_slice, slice_h);
|
|
}
|
|
spr.resetViewport();
|
|
|
|
// Dividing neon seam line
|
|
if (splitX > 0 && splitX < 320) {
|
|
spr.drawFastVLine(splitX, 0, slice_h, getThemePrimaryColor());
|
|
spr.drawFastVLine(splitX + (swipeLeft ? 1 : -1), 0, slice_h, TFT_WHITE);
|
|
}
|
|
|
|
// Pagination indicator dots on top slice
|
|
if (y_slice == 0) {
|
|
spr.fillCircle(153, 2, 2, (splitX > 160) ? getThemePrimaryColor() : 0x5AEB);
|
|
spr.fillCircle(167, 2, 2, (splitX <= 160) ? getThemePrimaryColor() : 0x5AEB);
|
|
}
|
|
|
|
// Direct single SPI push: ZERO visual flicker!
|
|
spr.pushSprite(0, y_slice);
|
|
}
|
|
|
|
delay(8);
|
|
}
|
|
|
|
spr.deleteSprite();
|
|
}
|
|
|
|
/*-------------------*/
|
|
// initialize display
|
|
void initScreen() {
|
|
terminalLineCount = 0;
|
|
#ifdef SERIAL_DEBUG
|
|
Serial.printf("Display init, fullScreenCell = %d\n", fullScreenCell);
|
|
#endif
|
|
for (int i = 0; i < 4; i++) {
|
|
pidList[i] = pidConfig[pidInCell[i]][2]; // get PID to list
|
|
pidReadSkip[i] = pidConfig[pidInCell[i]][6].toInt(); // get read skip
|
|
pidCurrentSkip[i] = pidReadSkip[i]; // skip for skip reading pid
|
|
old_data[i] = -999; // clear old data
|
|
}
|
|
for (int i = 4; i < maxpidIndex; i++) {
|
|
pidList[i] = pidConfig[i][2]; // get background PIDs (e.g. 0104)
|
|
pidReadSkip[i] = pidConfig[i][6].toInt(); // get read skip
|
|
pidCurrentSkip[i] = pidReadSkip[i];
|
|
old_data[i] = -999;
|
|
}
|
|
if (fullScreenCell >= 0 && fullScreenCell < 4) {
|
|
fullScreenMeter(fullScreenCell, pidInCell[fullScreenCell]);
|
|
} else if (currentScreenPage == 1) {
|
|
drawTriTempScreen(0);
|
|
} else {
|
|
tft.fillScreen(TFT_BLACK); // clear screen
|
|
for (uint8_t c = 0; c < 4; c++) {
|
|
uint8_t pid = pidInCell[c];
|
|
arcMeter4(c, pid);
|
|
}
|
|
drawQuadrantDividers();
|
|
// Pagination indicator dots [● ○]
|
|
tft.fillCircle(153, 2, 2, getThemePrimaryColor()); // Page 1 active
|
|
tft.fillCircle(167, 2, 2, 0x5AEB); // Page 2 inactive
|
|
}
|
|
if (currentScreenPage == 0 && fullScreenCell == -1) {
|
|
badgeEcoDrawn = false;
|
|
updateEcoBadge(true);
|
|
}
|
|
}
|
|
/*-------------------------------*/
|
|
|
|
// get A B from response return in global A B variable; returns true only if valid OBD2 data bytes were parsed
|
|
bool getAB(String elm_rsp, String currentPid) { // 41 05 2A 3C 01>
|
|
A = 0;
|
|
B = 0;
|
|
if (currentPid == "ATRV") {
|
|
return true;
|
|
}
|
|
if (elm_rsp.indexOf("NO DATA") != -1 ||
|
|
elm_rsp.indexOf("UNABLE") != -1 ||
|
|
elm_rsp.indexOf("ERROR") != -1 ||
|
|
elm_rsp.indexOf("STOPPED") != -1 ||
|
|
elm_rsp.indexOf("BUS BUSY") != -1 ||
|
|
elm_rsp.indexOf("TIMEOUT") != -1 ||
|
|
elm_rsp.indexOf("SEARCHING") != -1 ||
|
|
elm_rsp.indexOf("?") != -1 ||
|
|
elm_rsp.indexOf("BUFFER FULL") != -1) {
|
|
return false;
|
|
}
|
|
|
|
// Normalize: replace carriage returns, newlines, and prompt chars with spaces
|
|
elm_rsp.replace('\r', ' ');
|
|
elm_rsp.replace('\n', ' ');
|
|
elm_rsp.replace('>', ' ');
|
|
|
|
// Extract expected PID hex byte (e.g. "0105" -> "05", "010C" -> "0C", "010D" -> "0D")
|
|
String pidByte = (currentPid.length() >= 4) ? currentPid.substring(2) : currentPid;
|
|
pidByte.toUpperCase();
|
|
bool needB = (pidByte == "0C"); // RPM requires both A and B!
|
|
|
|
// 1. Tokenized search: look for "41" followed by PID byte
|
|
String tokens[16];
|
|
uint8_t tokenCount = 0;
|
|
int startIdx = 0;
|
|
while (startIdx < elm_rsp.length() && tokenCount < 16) {
|
|
while (startIdx < elm_rsp.length() && elm_rsp.charAt(startIdx) == ' ') {
|
|
startIdx++;
|
|
}
|
|
if (startIdx >= elm_rsp.length()) break;
|
|
int endIdx = elm_rsp.indexOf(' ', startIdx);
|
|
if (endIdx == -1) endIdx = elm_rsp.length();
|
|
tokens[tokenCount++] = elm_rsp.substring(startIdx, endIdx);
|
|
startIdx = endIdx + 1;
|
|
}
|
|
|
|
for (uint8_t i = 0; i < tokenCount; i++) {
|
|
tokens[i].toUpperCase();
|
|
}
|
|
|
|
for (uint8_t i = 0; i + 1 < tokenCount; i++) {
|
|
if (tokens[i] == "41" && tokens[i + 1] == pidByte) {
|
|
if (needB) {
|
|
if (i + 3 < tokenCount) {
|
|
A = strtol(tokens[i + 2].c_str(), NULL, 16);
|
|
B = strtol(tokens[i + 3].c_str(), NULL, 16);
|
|
return true;
|
|
}
|
|
} else {
|
|
if (i + 2 < tokenCount) {
|
|
A = strtol(tokens[i + 2].c_str(), NULL, 16);
|
|
B = 0;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 2. Compact string fallback (in case adapter sends responses without spaces, e.g. "410D32")
|
|
String compact = "";
|
|
for (int i = 0; i < elm_rsp.length(); i++) {
|
|
char c = elm_rsp.charAt(i);
|
|
if (c != ' ') compact += (char)toupper(c);
|
|
}
|
|
String targetPrefix = "41" + pidByte;
|
|
int fIdx = compact.indexOf(targetPrefix);
|
|
if (fIdx != -1) {
|
|
int dataIdx = fIdx + targetPrefix.length();
|
|
if (needB) {
|
|
if (dataIdx + 4 <= compact.length()) {
|
|
A = strtol(compact.substring(dataIdx, dataIdx + 2).c_str(), NULL, 16);
|
|
B = strtol(compact.substring(dataIdx + 2, dataIdx + 4).c_str(), NULL, 16);
|
|
return true;
|
|
}
|
|
} else {
|
|
if (dataIdx + 2 <= compact.length()) {
|
|
A = strtol(compact.substring(dataIdx, dataIdx + 2).c_str(), NULL, 16);
|
|
B = 0;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 3. Positional fallback ONLY if tokens[0] == "41" AND tokens[1] == pidByte
|
|
if (tokenCount >= 2 && tokens[0] == "41" && tokens[1] == pidByte) {
|
|
if (needB && tokenCount >= 4) {
|
|
A = strtol(tokens[2].c_str(), NULL, 16);
|
|
B = strtol(tokens[3].c_str(), NULL, 16);
|
|
return true;
|
|
} else if (!needB && tokenCount >= 3) {
|
|
A = strtol(tokens[2].c_str(), NULL, 16);
|
|
B = 0;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
} // getAB
|
|
/*-------------------------------*/
|
|
void updateMeter(uint8_t pidNo, String response) { // update parameter on screen
|
|
if (pidNo >= maxpidIndex)
|
|
return;
|
|
|
|
// Background PID 4: Carga de Motor (Calculated Engine Load % - PID 0104)
|
|
if (pidNo == 4) {
|
|
bool valid = getAB(response, pidList[4]);
|
|
if (valid) {
|
|
ignitionOn = true;
|
|
consecutiveEcuFails = 0;
|
|
float data = A * 100.0 / 255.0; // Formula 2: Engine Load %
|
|
if (data >= 0.0f && data <= 100.0f) {
|
|
currentEngineLoad = data;
|
|
updateEcoBadge();
|
|
}
|
|
}
|
|
bt_message = "";
|
|
return;
|
|
}
|
|
|
|
if (pidNo >= 4)
|
|
return;
|
|
uint8_t pidIdx = pidInCell[pidNo];
|
|
if (pidIdx >= 4)
|
|
return;
|
|
String label = pidConfig[pidIdx][0];
|
|
String unit = pidConfig[pidIdx][1];
|
|
uint8_t formula = pidConfig[pidIdx][3].toInt();
|
|
int min = pidConfig[pidIdx][4].toInt();
|
|
int max = pidConfig[pidIdx][5].toInt();
|
|
bool digit = pidConfig[pidIdx][7].toInt();
|
|
int warn = warningValue[pidIdx].toInt();
|
|
|
|
// Contador de fallos consecutivos por cada instrumento (debounce automotriz)
|
|
static uint8_t pidFailCount[4] = {0, 0, 0, 0};
|
|
|
|
bool valid = getAB(response, pidList[pidNo]);
|
|
float data = 0.0;
|
|
bool isFailed = false;
|
|
|
|
if (formula == 8) {
|
|
// Battery Voltage from ELM327 command "ATRV" (e.g. "14.2V\r\r>")
|
|
String s = response;
|
|
s.trim();
|
|
int vIdx = s.indexOf('V');
|
|
if (vIdx == -1) vIdx = s.indexOf('v');
|
|
if (vIdx != -1) s = s.substring(0, vIdx);
|
|
int lastSpace = s.lastIndexOf(' ');
|
|
if (lastSpace != -1) s = s.substring(lastSpace + 1);
|
|
int lastCr = s.lastIndexOf('\r');
|
|
if (lastCr != -1) s = s.substring(lastCr + 1);
|
|
int lastLf = s.lastIndexOf('\n');
|
|
if (lastLf != -1) s = s.substring(lastLf + 1);
|
|
s.trim();
|
|
data = s.toFloat();
|
|
if (data <= 1.0f) {
|
|
isFailed = true;
|
|
}
|
|
|
|
if (!ignitionOn || isFailed) {
|
|
plotNoData(pidNo);
|
|
bt_message = "";
|
|
return;
|
|
}
|
|
} else {
|
|
if (!valid) {
|
|
isFailed = true;
|
|
}
|
|
}
|
|
|
|
if (isFailed) {
|
|
pidFailCount[pidNo]++;
|
|
// Debounce automotriz: si un paquete cae por ruido en el bus J1850, NUNCA poner en cero la pantalla,
|
|
// simplemente mantener el valor anterior. Solo si falla 10 veces seguidas declarar perdida de contacto.
|
|
if (pidFailCount[pidNo] >= 10) {
|
|
if (formula == 3) {
|
|
currentRpm = 0.0f; // Motor detenido / sin RPM
|
|
updateEcoBadge();
|
|
}
|
|
consecutiveEcuFails++;
|
|
if (consecutiveEcuFails >= 6) {
|
|
ignitionOn = false;
|
|
updateEcoBadge();
|
|
// Contacto cerrado sostenido: limpiar todos los instrumentos a "---" (sin datos)
|
|
for (uint8_t c = 0; c < 4; c++) {
|
|
plotNoData(c);
|
|
}
|
|
}
|
|
}
|
|
bt_message = "";
|
|
return; // SALE SIN TOCAR LA PANTALLA NI PONERLA EN CERO
|
|
}
|
|
|
|
// Si la respuesta fue valida, reseteamos contadores de fallo y confirmamos contacto puesto
|
|
pidFailCount[pidNo] = 0;
|
|
consecutiveEcuFails = 0;
|
|
ignitionOn = true;
|
|
|
|
switch (formula) {
|
|
case 0:
|
|
data = A * 0.145;
|
|
break; // psi
|
|
case 1:
|
|
data = A - 40;
|
|
// Filtro de rango realista para refrigerante (-20°C a 140°C)
|
|
if (data < -20 || data > 140) {
|
|
bt_message = "";
|
|
return;
|
|
}
|
|
tempEngineCoolant = data;
|
|
if (currentScreenPage == 1 && fullScreenCell == -1) {
|
|
updateTriTempCoolant(data);
|
|
}
|
|
break; // temp °C (ECT)
|
|
case 2:
|
|
data = A * 100.0 / 255;
|
|
break; // %
|
|
case 3:
|
|
data = (256 * A + B) / 4.0;
|
|
// Filtro de rango realista para RPM (0 a 9000)
|
|
if (data < 0 || data > 9000) {
|
|
bt_message = "";
|
|
return;
|
|
}
|
|
currentRpm = data;
|
|
if (data > 300.0f) {
|
|
lastActivityTime = millis();
|
|
}
|
|
updateEcoBadge();
|
|
break; // rpm (ENG SPD)
|
|
case 4:
|
|
data = (256 * A + B) / 1000.0;
|
|
break; // volt (PCM Volt)
|
|
case 5:
|
|
data = (256 * A + B) / 16.0;
|
|
if (data > 150 || data < 0)
|
|
data = old_data[pidNo];
|
|
break;
|
|
case 6:
|
|
data = (A * 256 + B) * 5 / 72 - 18;
|
|
if (data > 150 || data < 0)
|
|
data = old_data[pidNo];
|
|
break;
|
|
case 7:
|
|
data = A; // km/h (PID 010D Vehicle Speed)
|
|
if (data > 0.0f) lastActivityTime = millis();
|
|
break;
|
|
case 8:
|
|
// Ya parseado y validado arriba en data
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
|
|
// Si el motor esta en contacto pero apagado (RPM == 0), mostrar "---" en RPM en vez de 0
|
|
if (formula == 3 && data <= 0.0f) {
|
|
currentRpm = 0.0f;
|
|
updateEcoBadge();
|
|
plotNoData(pidNo);
|
|
bt_message = "";
|
|
return;
|
|
}
|
|
|
|
last_valid_data[pidNo] = data;
|
|
|
|
if (fullScreenCell >= 0 && fullScreenCell < 4) {
|
|
if (pidNo == fullScreenCell) {
|
|
plotFullScreen(fullScreenCell, data, warn, min, max, digit, unit);
|
|
}
|
|
} else if (currentScreenPage == 0) {
|
|
plotArc4(pidNo, data, warn, min, max, digit, unit);
|
|
}
|
|
bt_message = ""; // reset
|
|
}
|
|
/*-------------------------------*/
|
|
|
|
// Non-blocking alarm sound generator: 4 selectable patterns
|
|
uint32_t lastAlarmSoundCycle = 0;
|
|
uint8_t alarmSoundStep = 0;
|
|
uint32_t alarmSoundStepTime = 0;
|
|
|
|
void handleAlarmSound(bool anyAlarmActive, bool flashTick = false) {
|
|
if (!anyAlarmActive || alarmVolumeLevel == 0) {
|
|
if (alarmSoundStep != 0) {
|
|
ledcWrite(buzzerChannel, 0);
|
|
alarmSoundStep = 0;
|
|
}
|
|
return;
|
|
}
|
|
|
|
uint32_t now = millis();
|
|
uint16_t duty = VOL_DUTY_TABLE[alarmVolumeLevel > 5 ? 3 : alarmVolumeLevel];
|
|
|
|
if (alarmSoundType == 0) {
|
|
// 0: Chime BMW (Mi7 -> Do7, 2637 Hz -> 2093 Hz cada 1100ms)
|
|
if (alarmSoundStep == 0) {
|
|
if (now - lastAlarmSoundCycle >= 1100) {
|
|
lastAlarmSoundCycle = now;
|
|
alarmSoundStep = 1;
|
|
alarmSoundStepTime = now;
|
|
ledcSetup(buzzerChannel, 2637, 10);
|
|
ledcWrite(buzzerChannel, duty);
|
|
}
|
|
} else if (alarmSoundStep == 1) { // 60ms tono 1
|
|
if (now - alarmSoundStepTime >= 60) {
|
|
ledcWrite(buzzerChannel, 0);
|
|
alarmSoundStep = 2;
|
|
alarmSoundStepTime = now;
|
|
}
|
|
} else if (alarmSoundStep == 2) { // 15ms pausa
|
|
if (now - alarmSoundStepTime >= 15) {
|
|
ledcSetup(buzzerChannel, 2093, 10);
|
|
ledcWrite(buzzerChannel, duty);
|
|
alarmSoundStep = 3;
|
|
alarmSoundStepTime = now;
|
|
}
|
|
} else if (alarmSoundStep == 3) { // 110ms tono 2
|
|
if (now - alarmSoundStepTime >= 110) {
|
|
ledcWrite(buzzerChannel, 0);
|
|
alarmSoundStep = 0;
|
|
}
|
|
}
|
|
} else if (alarmSoundType == 1) {
|
|
// 1: Mercedes Gong (Re7 -> Fa#7, 2349 Hz -> 2960 Hz cada 1100ms)
|
|
if (alarmSoundStep == 0) {
|
|
if (now - lastAlarmSoundCycle >= 1100) {
|
|
lastAlarmSoundCycle = now;
|
|
alarmSoundStep = 1;
|
|
alarmSoundStepTime = now;
|
|
ledcSetup(buzzerChannel, 2349, 10);
|
|
ledcWrite(buzzerChannel, duty);
|
|
}
|
|
} else if (alarmSoundStep == 1) { // 45ms tono 1
|
|
if (now - alarmSoundStepTime >= 45) {
|
|
ledcWrite(buzzerChannel, 0);
|
|
alarmSoundStep = 2;
|
|
alarmSoundStepTime = now;
|
|
}
|
|
} else if (alarmSoundStep == 2) { // 20ms pausa
|
|
if (now - alarmSoundStepTime >= 20) {
|
|
ledcSetup(buzzerChannel, 2960, 10);
|
|
ledcWrite(buzzerChannel, duty);
|
|
alarmSoundStep = 3;
|
|
alarmSoundStepTime = now;
|
|
}
|
|
} else if (alarmSoundStep == 3) { // 85ms tono 2
|
|
if (now - alarmSoundStepTime >= 85) {
|
|
ledcWrite(buzzerChannel, 0);
|
|
alarmSoundStep = 0;
|
|
}
|
|
}
|
|
} else if (alarmSoundType == 2) {
|
|
// 2: Audi Cockpit (Do7 -> Mi7 -> Sol7, 2093 -> 2637 -> 3136 Hz cada 1100ms)
|
|
if (alarmSoundStep == 0) {
|
|
if (now - lastAlarmSoundCycle >= 1100) {
|
|
lastAlarmSoundCycle = now;
|
|
alarmSoundStep = 1;
|
|
alarmSoundStepTime = now;
|
|
ledcSetup(buzzerChannel, 2093, 10);
|
|
ledcWrite(buzzerChannel, duty);
|
|
}
|
|
} else if (alarmSoundStep == 1) { // 35ms nota 1
|
|
if (now - alarmSoundStepTime >= 35) {
|
|
ledcSetup(buzzerChannel, 2637, 10);
|
|
ledcWrite(buzzerChannel, duty);
|
|
alarmSoundStep = 2;
|
|
alarmSoundStepTime = now;
|
|
}
|
|
} else if (alarmSoundStep == 2) { // 35ms nota 2
|
|
if (now - alarmSoundStepTime >= 35) {
|
|
ledcSetup(buzzerChannel, 3136, 10);
|
|
ledcWrite(buzzerChannel, duty);
|
|
alarmSoundStep = 3;
|
|
alarmSoundStepTime = now;
|
|
}
|
|
} else if (alarmSoundStep == 3) { // 65ms nota 3
|
|
if (now - alarmSoundStepTime >= 65) {
|
|
ledcWrite(buzzerChannel, 0);
|
|
alarmSoundStep = 0;
|
|
}
|
|
}
|
|
} else if (alarmSoundType == 3) {
|
|
// 3: Porsche Sport (Doble staccato rapido 3500 Hz cada 900ms)
|
|
if (alarmSoundStep == 0) {
|
|
if (now - lastAlarmSoundCycle >= 900) {
|
|
lastAlarmSoundCycle = now;
|
|
alarmSoundStep = 1;
|
|
alarmSoundStepTime = now;
|
|
ledcSetup(buzzerChannel, 3500, 10);
|
|
ledcWrite(buzzerChannel, duty);
|
|
}
|
|
} else if (alarmSoundStep == 1) { // 30ms pulso 1
|
|
if (now - alarmSoundStepTime >= 30) {
|
|
ledcWrite(buzzerChannel, 0);
|
|
alarmSoundStep = 2;
|
|
alarmSoundStepTime = now;
|
|
}
|
|
} else if (alarmSoundStep == 2) { // 25ms pausa
|
|
if (now - alarmSoundStepTime >= 25) {
|
|
ledcSetup(buzzerChannel, 3500, 10);
|
|
ledcWrite(buzzerChannel, duty);
|
|
alarmSoundStep = 3;
|
|
alarmSoundStepTime = now;
|
|
}
|
|
} else if (alarmSoundStep == 3) { // 30ms pulso 2
|
|
if (now - alarmSoundStepTime >= 30) {
|
|
ledcWrite(buzzerChannel, 0);
|
|
alarmSoundStep = 0;
|
|
}
|
|
}
|
|
} else if (alarmSoundType == 4) {
|
|
// 4: Casio Clasico (Doble chirp 4096 Hz cada 1000ms)
|
|
if (alarmSoundStep == 0) {
|
|
if (now - lastAlarmSoundCycle >= 1000) {
|
|
lastAlarmSoundCycle = now;
|
|
alarmSoundStep = 1;
|
|
alarmSoundStepTime = now;
|
|
ledcSetup(buzzerChannel, 4096, 10);
|
|
ledcWrite(buzzerChannel, duty);
|
|
}
|
|
} else if (alarmSoundStep == 1) { // 24ms chirp 1
|
|
if (now - alarmSoundStepTime >= 24) {
|
|
ledcWrite(buzzerChannel, 0);
|
|
alarmSoundStep = 2;
|
|
alarmSoundStepTime = now;
|
|
}
|
|
} else if (alarmSoundStep == 2) { // 35ms pausa
|
|
if (now - alarmSoundStepTime >= 35) {
|
|
ledcSetup(buzzerChannel, 4096, 10);
|
|
ledcWrite(buzzerChannel, duty);
|
|
alarmSoundStep = 3;
|
|
alarmSoundStepTime = now;
|
|
}
|
|
} else if (alarmSoundStep == 3) { // 24ms chirp 2
|
|
if (now - alarmSoundStepTime >= 24) {
|
|
ledcWrite(buzzerChannel, 0);
|
|
alarmSoundStep = 0;
|
|
}
|
|
}
|
|
} else if (alarmSoundType == 5) {
|
|
// 5: Triple Urgente (3 pulsos rapidos 4096 Hz cada 1200ms)
|
|
if (alarmSoundStep == 0) {
|
|
if (now - lastAlarmSoundCycle >= 1200) {
|
|
lastAlarmSoundCycle = now;
|
|
alarmSoundStep = 1;
|
|
alarmSoundStepTime = now;
|
|
ledcSetup(buzzerChannel, 4096, 10);
|
|
ledcWrite(buzzerChannel, duty);
|
|
}
|
|
} else if (alarmSoundStep == 1) { // 22ms pulso 1
|
|
if (now - alarmSoundStepTime >= 22) {
|
|
ledcWrite(buzzerChannel, 0);
|
|
alarmSoundStep = 2;
|
|
alarmSoundStepTime = now;
|
|
}
|
|
} else if (alarmSoundStep == 2) { // 25ms pausa
|
|
if (now - alarmSoundStepTime >= 25) {
|
|
ledcSetup(buzzerChannel, 4096, 10);
|
|
ledcWrite(buzzerChannel, duty);
|
|
alarmSoundStep = 3;
|
|
alarmSoundStepTime = now;
|
|
}
|
|
} else if (alarmSoundStep == 3) { // 22ms pulso 2
|
|
if (now - alarmSoundStepTime >= 22) {
|
|
ledcWrite(buzzerChannel, 0);
|
|
alarmSoundStep = 4;
|
|
alarmSoundStepTime = now;
|
|
}
|
|
} else if (alarmSoundStep == 4) { // 25ms pausa
|
|
if (now - alarmSoundStepTime >= 25) {
|
|
ledcSetup(buzzerChannel, 4096, 10);
|
|
ledcWrite(buzzerChannel, duty);
|
|
alarmSoundStep = 5;
|
|
alarmSoundStepTime = now;
|
|
}
|
|
} else if (alarmSoundStep == 5) { // 22ms pulso 3
|
|
if (now - alarmSoundStepTime >= 22) {
|
|
ledcWrite(buzzerChannel, 0);
|
|
alarmSoundStep = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Non-blocking handler to blink/flash arcs and numerical values on alarm (when in TFT_RED)
|
|
void handleArcAlarmFlash() {
|
|
uint32_t now = millis();
|
|
bool toggleTick = false;
|
|
if (now - lastArcFlashTime >= 250) {
|
|
lastArcFlashTime = now;
|
|
arcFlashVisible = !arcFlashVisible;
|
|
toggleTick = true;
|
|
}
|
|
|
|
bool anyInRedAlarm = false;
|
|
|
|
if (fullScreenCell >= 0 && fullScreenCell < 4) {
|
|
uint8_t cell = fullScreenCell;
|
|
if (last_valid_data[cell] != -999) {
|
|
uint8_t pidIdx = pidInCell[cell];
|
|
int warn = warningValue[pidIdx].toInt();
|
|
float data = last_valid_data[cell];
|
|
uint16_t col = getMeterColor(pidIdx, data, warn);
|
|
bool inRed = (col == TFT_RED);
|
|
bool isAlarmActive = alarmEnabled[pidIdx];
|
|
if (inRed && isAlarmActive) anyInRedAlarm = true;
|
|
bool digit = pidConfig[pidIdx][7].toInt();
|
|
String numStr = String(data, digit);
|
|
|
|
if (wasInRedAlarm[cell] && !inRed) {
|
|
// Exited red alarm: restore steady arc, text, icon, and title
|
|
wasInRedAlarm[cell] = false;
|
|
drawPidIconHeader(10, 4, pidConfig[pidIdx][2]);
|
|
drawFullScreenTitle(pidConfig[pidIdx][0], TFT_WHITE);
|
|
int min = pidConfig[pidIdx][4].toInt();
|
|
int max = pidConfig[pidIdx][5].toInt();
|
|
int newBlocks = calcMeterBlocks(data, min, max);
|
|
for (uint8_t i = 0; i < newBlocks; i++) {
|
|
drawBarBlock(i, col);
|
|
}
|
|
for (uint8_t i = newBlocks; i < NUM_BAR_BLOCKS; i++) {
|
|
drawBarBlock(i, METER_INACTIVE_COLOR);
|
|
}
|
|
tft.loadFont(DSEG7_Modern_BoldItalic_80);
|
|
tft.setTextColor(getThemePrimaryColor(), TFT_BLACK);
|
|
tft.setTextPadding(240);
|
|
tft.drawRightString(numStr.c_str(), 312, 148, 1);
|
|
tft.setTextPadding(0);
|
|
tft.unloadFont();
|
|
} else if (inRed) {
|
|
wasInRedAlarm[cell] = true;
|
|
if (isAlarmActive) {
|
|
if (toggleTick) {
|
|
if (arcFlashVisible) {
|
|
drawPidIconHeader(10, 4, pidConfig[pidIdx][2]);
|
|
drawFullScreenTitle(pidConfig[pidIdx][0], TFT_RED);
|
|
} else {
|
|
clearPidIconHeader();
|
|
drawFullScreenTitle(pidConfig[pidIdx][0], 0);
|
|
}
|
|
int min = pidConfig[pidIdx][4].toInt();
|
|
int max = pidConfig[pidIdx][5].toInt();
|
|
int newBlocks = calcMeterBlocks(data, min, max);
|
|
|
|
if (arcFlashVisible) {
|
|
for (uint8_t i = 0; i < newBlocks; i++) {
|
|
drawBarBlock(i, TFT_RED);
|
|
}
|
|
for (uint8_t i = newBlocks; i < NUM_BAR_BLOCKS; i++) {
|
|
drawBarBlock(i, METER_INACTIVE_COLOR);
|
|
}
|
|
} else {
|
|
for (uint8_t i = 0; i < NUM_BAR_BLOCKS; i++) {
|
|
drawBarBlock(i, TFT_BLACK);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (currentScreenPage == 0) {
|
|
// 4 quadrants mode
|
|
for (uint8_t cell = 0; cell < 4; cell++) {
|
|
if (last_valid_data[cell] != -999) {
|
|
uint8_t pidIdx = pidInCell[cell];
|
|
int warn = warningValue[pidIdx].toInt();
|
|
float data = last_valid_data[cell];
|
|
uint16_t col = getMeterColor(pidIdx, data, warn);
|
|
bool inRed = (col == TFT_RED);
|
|
bool isAlarmActive = alarmEnabled[pidIdx];
|
|
if (inRed && isAlarmActive) anyInRedAlarm = true;
|
|
bool digit = pidConfig[pidIdx][7].toInt();
|
|
String numStr = String(data, digit);
|
|
int x = cell4_x[cell];
|
|
int y = cell4_y[cell];
|
|
|
|
if (wasInRedAlarm[cell] && !inRed) {
|
|
// Exited red alarm: restore steady arc, text, and icon
|
|
wasInRedAlarm[cell] = false;
|
|
drawPidIcon(x + 5, y + 3, pidConfig[pidIdx][2]);
|
|
int min = pidConfig[pidIdx][4].toInt();
|
|
int max = pidConfig[pidIdx][5].toInt();
|
|
int newBlocks = calcMeterBlocks(data, min, max);
|
|
for (uint8_t i = 0; i < newBlocks; i++) {
|
|
drawQuadBarBlock(cell, i, col);
|
|
}
|
|
for (uint8_t i = newBlocks; i < NUM_BAR_BLOCKS; i++) {
|
|
drawQuadBarBlock(cell, i, METER_INACTIVE_COLOR);
|
|
}
|
|
tft.loadFont(DSEG7_Modern_BoldItalic_34);
|
|
tft.setTextColor(getThemePrimaryColor(), TFT_BLACK);
|
|
tft.setTextPadding(114);
|
|
tft.drawRightString(numStr.c_str(), x + 152, y + 74, 1);
|
|
tft.setTextPadding(0);
|
|
tft.unloadFont();
|
|
} else if (inRed) {
|
|
wasInRedAlarm[cell] = true;
|
|
if (isAlarmActive) {
|
|
if (toggleTick) {
|
|
if (arcFlashVisible) {
|
|
drawPidIcon(x + 5, y + 3, pidConfig[pidIdx][2]);
|
|
} else {
|
|
clearPidIcon(x + 5, y + 3, pidConfig[pidIdx][2]);
|
|
}
|
|
int min = pidConfig[pidIdx][4].toInt();
|
|
int max = pidConfig[pidIdx][5].toInt();
|
|
int newBlocks = calcMeterBlocks(data, min, max);
|
|
|
|
if (arcFlashVisible) {
|
|
for (uint8_t i = 0; i < newBlocks; i++) {
|
|
drawQuadBarBlock(cell, i, TFT_RED);
|
|
}
|
|
for (uint8_t i = newBlocks; i < NUM_BAR_BLOCKS; i++) {
|
|
drawQuadBarBlock(cell, i, METER_INACTIVE_COLOR);
|
|
}
|
|
} else {
|
|
for (uint8_t i = 0; i < NUM_BAR_BLOCKS; i++) {
|
|
drawQuadBarBlock(cell, i, TFT_BLACK);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// Page 1 (Tri-Temperature screen): check alarm conditions for acoustic warning without touching screen graphics
|
|
for (uint8_t cell = 0; cell < 4; cell++) {
|
|
if (last_valid_data[cell] != -999) {
|
|
uint8_t pidIdx = pidInCell[cell];
|
|
int warn = warningValue[pidIdx].toInt();
|
|
float data = last_valid_data[cell];
|
|
uint16_t col = getMeterColor(pidIdx, data, warn);
|
|
bool inRed = (col == TFT_RED);
|
|
bool isAlarmActive = alarmEnabled[pidIdx];
|
|
if (inRed && isAlarmActive) anyInRedAlarm = true;
|
|
}
|
|
}
|
|
}
|
|
handleAlarmSound(anyInRedAlarm, toggleTick);
|
|
}
|
|
|
|
// Target and current brightness variables for smooth fade
|
|
uint8_t targetBacklight = 255;
|
|
float currentBacklight = 255.0f;
|
|
uint32_t lastBacklightStepTime = 0;
|
|
|
|
void updateBacklightFade() {
|
|
uint32_t now = millis();
|
|
if (now - lastBacklightStepTime >= 15) { // every 15ms step
|
|
lastBacklightStepTime = now;
|
|
if (abs(currentBacklight - (float)targetBacklight) > 0.5f) {
|
|
if (currentBacklight < targetBacklight) {
|
|
currentBacklight += 3.0f;
|
|
if (currentBacklight > targetBacklight)
|
|
currentBacklight = targetBacklight;
|
|
} else {
|
|
currentBacklight -= 3.0f;
|
|
if (currentBacklight < targetBacklight)
|
|
currentBacklight = targetBacklight;
|
|
}
|
|
ledcWrite(backlightChannel, (uint32_t)currentBacklight);
|
|
}
|
|
}
|
|
}
|
|
|
|
// auto dim backlight function
|
|
void autoDim() {
|
|
if (brightnessIndex > 0) {
|
|
uint8_t manualVal = BRIGHTNESS_PWM_TABLE[brightnessIndex > 5 ? 5 : brightnessIndex];
|
|
if (targetBacklight != manualVal) {
|
|
targetBacklight = manualVal;
|
|
}
|
|
updateBacklightFade();
|
|
return;
|
|
}
|
|
int light = analogRead(LDR_PIN); // read light
|
|
if (light > LIGHT_LEVEL) { // low light (dark)
|
|
low_count++;
|
|
if (low_count > 6) {
|
|
low_count = 6;
|
|
if (!dim) {
|
|
targetBacklight = 15; // smooth fade target: dim
|
|
dim = true;
|
|
#ifdef SERIAL_DEBUG
|
|
Serial.println(F("Backlight -> target dim (15)"));
|
|
#endif
|
|
}
|
|
}
|
|
high_count = 0;
|
|
|
|
} else { // bright light (day)
|
|
high_count++;
|
|
if (high_count > 6) {
|
|
high_count = 6;
|
|
if (dim) {
|
|
targetBacklight = 255; // smooth fade target: bright
|
|
dim = false;
|
|
#ifdef SERIAL_DEBUG
|
|
Serial.println(F("Backlight -> target bright (255)"));
|
|
#endif
|
|
}
|
|
}
|
|
low_count = 0;
|
|
}
|
|
updateBacklightFade();
|
|
} // autodim
|
|
//---------------------------
|
|
/*############################################*/
|