/*
===============================================================
REPROMOD TESTER – v1.0        (2025-10-31 21:47)
© 2025 Repromod® – Marca registrada
Licencia: Creative Commons BY-NC-SA 4.0 International
https://creativecommons.org/licenses/by-nc-sa/4.0/

Descripción:
  Analizador/inyector basado en Arduino Mega + INA226 + OLED SSD1306.
  Modos: HOME/Gráfica SAFE (canal 1), Voltímetro, Tester Chip (CPU/GPU/VRAM/BUCK),
  y Portátil (18–21V). SAFE protege por caída brusca de V; SAFE+ añade pico de corriente.

Dónde editar configuración en el código:
  - Direcciones/Dimensiones OLED e I2C: buscar definiciones de OLED_* e INA_ADDR
  - Calibraciones: SHUNT_OHMS, V_CAL, I_CAL
  - Pines: RELAY1/RELAY2/BTN1/BTN2/BEEPER

Botonera:
  - B1: Canal1 / acciones contextuales (armar, rearmar, medir)
  - B2: Menú / salir / cambiar SAFE (según modo)
  - B1+B2 (hold): Bloque de emergencia → ciclo relés y WDT reset

Bloque de emergencia:
  Doble pulsación mantenida BTN1+BTN2 ejecuta la rutina de seguridad:
  conmuta relés 3 veces y reinicia por watchdog (WDT).

===============================================================
*/
/*  Notas para operador (resumen práctico)
    - SAFE / SAFE+: en la gráfica de Canal 1, pulsa B2 para rotar: SAFE → NO SAFE → SAFE+.
      SAFE corta si V < 0.30 V tras el arm (protege por corto). SAFE+ añade corte por pico de I.
    - Voltímetro: B2 para salir (aviso pinzas). Estado: ESTABLE / FLUCTUANTE / PULSANTE.
    - Tester Chip: B2 rota la categoría; B1 inicia la medición. Si el ajuste no es 1.0 V (1.2 V VRAM), avisa.
    - Portátil: B1 valida 18–21 V y entra en análisis. B1 conmuta relé; B2 vuelve atrás.
    - OLED Sleep: solo en HOME+IDLE. Cualquier tecla despierta (se ignora el primer click tras despertar).
*/


#include <avr/wdt.h>
#include <Wire.h>
#include <Adafruit_GFX.h> //V.1.11.9
#include <Adafruit_SSD1306.h> //V.2.5.7
#include <INA226.h> // ROB TILLAART V.0.4.4
#include <math.h>

// ======================== CONFIGURACIÓN BÁSICA// =====================================================
// PANTALLA OLED *No altere la resolución
#define OLED_ADDR 0x3C
#define OLED_W    128
#define OLED_H    64
Adafruit_SSD1306 display(OLED_W, OLED_H, &Wire);

// INA226 *Cálculo de medición en referencia al valor de la fuente
#define INA_ADDR 0x40
INA226 ina(INA_ADDR);
// Calibración campo
const float SHUNT_OHMS = 0.005f;   // 5 mΩ, si tienes otra resistencia cámbiala en tu placa a esta
// Si metiste divisor de tensión de 100k/100k a VBUS multiplicamos x2:
const float V_CAL = 1.0501f * 2.0f;   // ajusta fino de voltaje  
// Ajuste el fino de amperajes 
const float I_CAL = 0.810f;     // Este ajuste es para (2.47A → 2.00A) relación 1:!

// CONFIGURACIÓN DE PINES
#define RELAY1   7    // canal 1 con SAFE / Led indicador
#define RELAY2   6    // canal 2 libre / Led indicador
#define BTN1     9    // Botón 1
#define BTN2     10   // Botón 2
#define BEEPER   5    // Beeper

// =============================FIN DE CONFIGURACIÓN// ================================================

enum Ch1State {
  CH1_IDLE = 0,
  CH1_ACTIVE,
  CH1_TRIPPED
};
Ch1State ch1State = CH1_IDLE;

bool wakeSwallowInputs = false;
bool safeModeEnabled = true;
float tc_lastAdjV = NAN;
float tc_lastAdjA = NAN;
const float SAFE_SHORT_VOLTAGE        = 0.40f;
const unsigned long SAFE_ARM_DELAY_MS = 200;

enum SafeMode : uint8_t { SAFE_V = 0, SAFE_OFF = 1, SAFE_PLUS = 2 };
SafeMode safeMode = SAFE_V;

bool lastTripWasPlus = false;
unsigned long ch1OnMs = 0;

float   tc_aPrev       = NAN;
float   tc_aP2P        = 0.0f;
float   tc_aStepMax    = 0.0f;
uint16_t tc_runMs = 4000;
uint16_t tc_settleMs = 200;
bool lastShortTrip   = false;
bool tripScreenDrawn = false;

enum TestChipSel_TC : uint8_t {
  TCSEL_CPU   = 0,
  TCSEL_GPU   = 1,
  TCSEL_VRAM  = 2,
  TCSEL_BUCK  = 3,
  TCSEL_COUNT = 4
};
uint8_t testChipSel_TC = TCSEL_CPU;

enum TestChipPhase_TC : uint8_t {
  TCPH_READY = 0,
  TCPH_ARMED,
  TCPH_MEASURE,
  TCPH_RESULT
};
TestChipPhase_TC testPhase_TC = TCPH_READY;

enum LaptopPhase { LAPH_ADJ = 0, LAPH_ANALYSIS = 1 };
LaptopPhase laptopPhase = LAPH_ADJ;

enum TestChipResult_TC : uint8_t {
  TCR_NONE = 0,
  TCR_OK,
  TCR_VLOW,
  TCR_VHIGH,
  TCR_SHORT,
  TCR_FAIL,
  TCR_NOCON
};
TestChipResult_TC lastResult_TC = TCR_NONE;

bool RELAY_ACTIVE_LOW = false;
inline void setRelay(uint8_t pin, bool on){
  digitalWrite(pin,
    RELAY_ACTIVE_LOW
      ? (on ? LOW : HIGH)
      : (on ? HIGH : LOW)
  );
}

bool relay1=false;
bool relay2=false;

const char *FW_VERSION = "Tester v1.0";

const uint16_t TC_TRACE_MAX = 120;
float    tc_trace[TC_TRACE_MAX];
uint16_t tc_traceCount = 0;

uint8_t tc_finalCode = 4;

float tc_vMin   = 99.0f;
float tc_vMax   = 0.0f;
float tc_vSum   = 0.0f;
uint16_t tc_cnt = 0;
float tc_lastCheckVolt = 0.0f;

float tc_aMin   = 99.0f;
float tc_aMax   = 0.0f;
float tc_aSum   = 0.0f;

float tc_vMinStable = 99.0f;
float tc_vMaxStable = 0.0f;
float tc_aSumStable = 0.0f;
uint16_t tc_cntStable = 0;
float tc_aMinStable = 99.0f;
float tc_aMaxStable = 0.0f;

unsigned long tc_stableStartMs = 0;
float  tc_aSumEarly = 0.0f;  uint16_t tc_aCntEarly = 0;
float  tc_aSumLate  = 0.0f;  uint16_t tc_aCntLate  = 0;

unsigned long tcMeasureStartMs = 0;
unsigned long TC_MEASURE_WINDOW_MS = 2000;

const float TC_OK_MIN_V  = 0.90f;
const float TC_OK_MAX_V  = 1.10f;
const float TC_SHORT_V   = 0.30f;
const float TC_HIGH_V    = 1.40f;

bool laptopNeedsAdj = true;

const float LAPTOP_VMIN = 18.0f;
const float LAPTOP_VMAX = 21.0f;

const float L_NO_POWER_A    = 0.010f;
const float L_STBY_MIN_A    = 0.015f;
const float L_STBY_MAX_A    = 0.050f;
const float L_COMM_SWING_A  = 0.020f;
const float L_BOOT_A        = 0.50f;
const float L_SHORT_I       = 3.0f;
const float L_SHORT_DROP_P  = 0.10f;

static float lap_aFast = 0.0f, lap_aSlow = 0.0f, lap_aSwingPeak = 0.0f;
static float lap_vBase = 0.0f;
static bool  lap_lastRelayOn = false;
static bool  lap_wasAboveStandby = false;
static unsigned long lap_lastAboveTs = 0;
static unsigned long lap_lastSampleMs = 0;

#include <avr/wdt.h>
void delaySafe(unsigned long ms){
  unsigned long t0 = millis();
  while (millis() - t0 < ms){
    wdt_reset();
    delay(10);
  }
}
void repromod_dualButtonResetHandler(){
  static uint8_t state = 0;
  static unsigned long t0 = 0;

  const bool b1 = (digitalRead(BTN1) == LOW);
  const bool b2 = (digitalRead(BTN2) == LOW);

  switch(state){
    case 0:
      if (b1 && b2){
        t0 = millis();
        state = 1;
      }
      break;

    case 1:
      if (!(b1 && b2)){
        state = 0;
        break;
      }
      if (millis() - t0 >= 250){

        for (int i = 0; i < 3; i++){
          setRelay(RELAY1, true);
          setRelay(RELAY2, true);
          delay(120);

          setRelay(RELAY1, false);
          setRelay(RELAY2, false);
          delay(200);
        }

        setRelay(RELAY1, false);
        setRelay(RELAY2, false);

        wdt_enable(WDTO_15MS);
        while (true) { }
      }
      break;
  }
}
void beepOnce(uint16_t ms){
  tone(BEEPER, 3000);
  delay(ms);
  noTone(BEEPER);
}
void beepCount(uint8_t n, uint16_t onMs=80, uint16_t offMs=80){
  for(uint8_t i=0;i<n;i++){
    beepOnce(onMs);
    if(i+1<n) delay(offMs);
  }
}

void beepLongWarning(){
  tone(BEEPER, 2500);
  delay(3000);
  noTone(BEEPER);
}

bool lastBtn1=HIGH, lastBtn2=HIGH;
unsigned long lastDeb1=0,lastDeb2=0;
const unsigned long DEBOUNCE_MS=50;

bool b2Held=false;
bool b2EscapeDone=false;
unsigned long b2PressStart=0;
const unsigned long B2_LONG_MS = 600;
bool consumeClick(uint8_t pin){

  if (wakeSwallowInputs){

    if (digitalRead(BTN1)==HIGH && digitalRead(BTN2)==HIGH){
      wakeSwallowInputs = false;

      lastBtn1 = HIGH; lastBtn2 = HIGH;
    }
    return false;
  }
  bool *lastPtr=(pin==BTN1)? &lastBtn1 : &lastBtn2;
  unsigned long *debPtr=(pin==BTN1)? &lastDeb1 : &lastDeb2;
  bool reading = digitalRead(pin);
  unsigned long now = millis();
  bool clicked = false;

  if(reading != *lastPtr && (now - *debPtr) > DEBOUNCE_MS){
    *debPtr = now;
    if(reading == LOW){
      clicked = true;
    }
    *lastPtr = reading;
  }
  return clicked;
}

bool checkLongPressB2(){
  bool b2Now = (digitalRead(BTN2)==LOW);
  unsigned long now = millis();

  if(!b2Held){
    if(b2Now){
      b2Held=true;
      b2EscapeDone=false;
      b2PressStart=now;
    }
  } else {
    if(!b2Now){
      b2Held=false;
      b2EscapeDone=false;
    } else {
      if(!b2EscapeDone && (now - b2PressStart)>=B2_LONG_MS){
        b2EscapeDone=true;
        return true;
      }
    }
  }
  return false;
}

bool voltCheckExitHold(){
  static bool vHeld=false;
  static unsigned long vStart=0;
  static bool fired=false;

  bool nowPressed = (digitalRead(BTN2)==LOW);
  unsigned long nowMs = millis();

  if(!vHeld){
    if(nowPressed){
      vHeld=true;
      vStart=nowMs;
      fired=false;
    }
  } else {
    if(!nowPressed){
      vHeld=false;
    } else {
      if(!fired && (nowMs - vStart)>=B2_LONG_MS){
        fired=true;
        return true;
      }
    }
  }
  return false;
}

#ifndef REPROMOD_COMPAT_FWD_INCLUDED
#define REPROMOD_COMPAT_FWD_INCLUDED

#include <stdint.h>

enum TestChipResult_TC : uint8_t;

void beepOnce(uint16_t ms);
void beepCount(uint8_t n, uint16_t onMs = 80, uint16_t offMs = 80);

extern const unsigned long SAFE_ARM_DELAY_MS;

class Adafruit_SSD1306;
extern Adafruit_SSD1306 display;

void setRelay(uint8_t pin, bool on);
void readVA(float &voltsOut, float &ampsOut);
void registerActivity(void);

extern bool relay1;
extern unsigned long ch1OnMs;
extern bool lastShortTrip;

#endif

bool displaySleeping=false;
unsigned long lastActivityMs=0;
const unsigned long OLED_SLEEP_MS = 20000;

void registerActivity(){
  lastActivityMs = millis();
}

void oledOff(){
  if(!displaySleeping){
    display.ssd1306_command(SSD1306_DISPLAYOFF);
    displaySleeping=true;
  }
}
void oledOn(){
  if(displaySleeping){
    display.ssd1306_command(SSD1306_DISPLAYON);
    displaySleeping=false;
  }
}

bool rawBtnPressed(){
  return (digitalRead(BTN1)==LOW) || (digitalRead(BTN2)==LOW);
}

enum UiMode {
  MODE_HOME = 0,
  MODE_MENU,
  MODE_TEST_CHIP,
  MODE_VOLT,
  MODE_LAPTOP
};
UiMode uiMode = MODE_HOME;

enum MainMenuItem {
  MM_CANAL2 = 0,
  MM_TESTCHIP,
  MM_MEDICION,
  MM_LAPTOP,
  MM_COUNT
};
uint8_t mainSel = 0;

enum TestChipItem {
  TC_CPU = 0,
  TC_GPU,
  TC_VRAM,
  TC_BUCK,
  TC_COUNT
};
uint8_t testChipSel = 0;

const uint8_t PW=118;
const uint8_t PH=24;
const uint8_t GX=5;
const uint8_t GY=20;
uint8_t gbuf[PW];
uint8_t head=0;

float aHist[4] = {0,0,0,0};
unsigned long tHist[4] = {0,0,0,0};
uint8_t aHidx = 0;
bool aHistPrimed = false;
const float GRAPH_MAX_DROP = 1.0f;

float vref = 0.0f;
const float VREF_HYST = 0.40f;
const unsigned long VREF_REARM_HOLD_MS=1000;

#define INA_SHUNT_REG 0x01

float readVoltageCal(){
  return ina.getBusVoltage() * V_CAL;
}

int16_t inaReadRegister16(uint8_t reg){
  Wire.beginTransmission(INA_ADDR);
  Wire.write(reg);
  Wire.endTransmission(false);
  Wire.requestFrom(INA_ADDR,(uint8_t)2);
  if(Wire.available()<2) return 0;
  uint16_t msb=Wire.read();
  uint16_t lsb=Wire.read();
  uint16_t raw=(msb<<8)|lsb;
  return (int16_t)raw;
}

float readShuntVoltage_mV(){
  int16_t raw=inaReadRegister16(INA_SHUNT_REG);
  return (float)raw * 0.0025f;
}

void readVA(float &voltsOut, float &ampsOut){
  float vOut = readVoltageCal();
  float shunt_mV = readShuntVoltage_mV();
  float shunt_V  = shunt_mV / 1000.0f;
  float amps     = (shunt_V / SHUNT_OHMS) * I_CAL;

  voltsOut = vOut;
  ampsOut  = amps;
}

float aSlow = 0.0f;
float aPeakSwing = 0.0f;
unsigned long lastVoltSampleMs=0;

const float FLUCT_THRESH = 0.01f;
const float PULSE_THRESH = 0.05f;

void drawLaptopAnalysisSimple(const char* msg, float ampsNow, bool relayOn){
  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE);

  display.setTextSize(2);
  display.setCursor(18, 0);
  display.print("ANALISIS");

  display.fillRect(0, 16, 160, 14, SSD1306_WHITE);
  display.setTextColor(SSD1306_BLACK);
  display.setTextSize(1);
  display.setCursor(2, 20);
  display.print(msg);
  display.setTextColor(SSD1306_WHITE);

  display.setTextSize(2);
  display.setCursor(10, 34);
  display.print(fabs(ampsNow), 3);
  display.print("A");

float vNow = 0.0f, aNow = 0.0f;
readVA(vNow, aNow);

display.setTextSize(1);
display.setTextColor(SSD1306_WHITE);
display.setCursor(90, 40);
int vDisplay = (int)vNow;
int vDec = (int)((vNow - vDisplay) * 10);

if (vDisplay < 10) display.print('0');
display.print(vDisplay);
display.print('.');
display.print(vDec);
display.print('V');
  display.fillRect(2, 52, 40, 14, SSD1306_WHITE);
  display.setTextColor(SSD1306_BLACK);
  display.setTextSize(1);
  display.setCursor(5, 54);
  display.print("B1 ");
  display.print(relayOn ? "ON" : "OFF");
  display.setTextColor(SSD1306_WHITE);

  display.setCursor(94, 54);
  display.print("B2<");

  display.display();
}

void drawInvertedLabel(int16_t x, int16_t y, const char *txt){
  int16_t bx,by; uint16_t bw,bh;
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.getTextBounds(txt, x, y, &bx,&by,&bw,&bh);

  display.fillRect(bx-2, by-1, bw+4, bh+2, SSD1306_WHITE);

  display.setTextColor(SSD1306_BLACK);
  display.setCursor(x,y);
  display.print(txt);

  display.setTextColor(SSD1306_WHITE);
}

void drawHomeIdle(){
  display.clearDisplay();

display.setTextSize(1);
display.setTextColor(SSD1306_WHITE);

display.setCursor(3, 54);
display.print("B1 canal1");

display.setCursor(79, 54);
display.print("B2 menu");

display.setTextColor(SSD1306_WHITE);

  {
    const char *txt="REPROMOD";
    int16_t x1,y1; uint16_t w1,h1;
    display.setTextSize(2);
    display.getTextBounds(txt,0,0,&x1,&y1,&w1,&h1);

    int16_t boxX = (OLED_W - (w1+6)) / 2;
    if(boxX<0) boxX=0;
    int16_t boxY = 8;
    uint16_t boxW = w1+6;
    uint16_t boxH = h1+4;

    display.fillRect(boxX,boxY,boxW,boxH,SSD1306_WHITE);

    display.setTextColor(SSD1306_BLACK);
    display.setCursor(boxX+3, boxY+2);
    display.print(txt);

    display.setTextSize(1);
    display.setTextColor(SSD1306_WHITE);
    int16_t vx,vy; uint16_t vw,vh;
    display.getTextBounds(FW_VERSION,0,0,&vx,&vy,&vw,&vh);
    display.setCursor((OLED_W - vw)/2, boxY+boxH+6);
    display.print(FW_VERSION);
  }

  display.display();
}

void drawTripScreen() {
  display.clearDisplay();

  display.setTextSize(2);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(2, 2);
  display.println(F("PROTECCION"));

  display.fillRect(0, 28, 128, 14, SSD1306_WHITE);
  display.setTextColor(SSD1306_BLACK);
  display.setTextSize(1);
  display.setCursor(4, 32);
  if (lastTripWasPlus) {
    display.println(F("  Pico de corriente"));
  } else {
    display.println(F("  Caida de voltaje"));
  }

  display.setTextColor(SSD1306_WHITE);
  display.setTextSize(1);
  display.setCursor(2, 54);
  display.println(F("B1> Rearmar"));
  display.setCursor(98, 54);
  display.println(F("B2<"));

  display.display();
}

void drawChannel1Frame(float v, float a, float dropV, float pct, bool safeOn){
  display.clearDisplay();

  display.fillRect(0,0,128,12,SSD1306_BLACK);
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0,0);
  display.print(v,2); display.print("v ");
  display.print(a,2); display.print("A");

  const int16_t STATUS_X = 76;
  const int16_t STATUS_Y = 0;
  const int16_t STATUS_W = 52;
  const int16_t STATUS_H = 12;

  display.fillRect(STATUS_X, STATUS_Y, STATUS_W, STATUS_H, SSD1306_BLACK);

  switch (safeMode) {
    case SAFE_V: {
      display.setTextColor(SSD1306_WHITE);
      display.setCursor(STATUS_X + 12, STATUS_Y);
      display.print("SAFE");
    } break;

    case SAFE_PLUS: {
      display.setTextColor(SSD1306_WHITE);
      display.setCursor(STATUS_X + 6, STATUS_Y);
      display.print("SAFE+");
    } break;

    case SAFE_OFF: {

      static bool blink=false;
      static unsigned long t0=0;
      unsigned long now=millis();
      if (now - t0 > 500) { t0 = now; blink = !blink; }

      if (blink) {
        display.fillRect(STATUS_X, STATUS_Y, STATUS_W, STATUS_H, SSD1306_WHITE);
        display.drawRect(STATUS_X, STATUS_Y, STATUS_W, STATUS_H, SSD1306_BLACK);
        display.setTextColor(SSD1306_BLACK);
        display.setCursor(STATUS_X + 6, STATUS_Y + 1);
        display.print("NO SAFE");
        display.setTextColor(SSD1306_WHITE);
      } else {
        display.setTextColor(SSD1306_WHITE);
        display.setCursor(STATUS_X + 6, STATUS_Y);
        display.print("NO SAFE");
      }
    } break;
  }

  const uint8_t PLOT_TOP    = 14;
  const uint8_t PLOT_BOTTOM = OLED_H - 18;
  const uint8_t plotH       = (PLOT_BOTTOM > PLOT_TOP) ? (PLOT_BOTTOM - PLOT_TOP) : 1;

  for(uint8_t band=1; band<=4; band++){
    uint8_t yGuide = PLOT_TOP + (uint16_t)plotH * band / 5;
    for(uint8_t x=GX; x < (uint8_t)(GX+PW); x++){
      if((x % 4) < 2){
        if(yGuide < OLED_H) display.drawPixel(x, yGuide, SSD1306_WHITE);
      }
    }
  }

  {
    uint8_t x = GX;
    uint8_t idx = head;
    for(uint8_t i=0; i<PW; i++){

      uint8_t oldY = gbuf[idx];
      uint8_t yScaled = (uint8_t)((uint32_t)oldY * (uint32_t)(plotH-1) / (uint32_t)((PH>1)?(PH-1):1));
      uint8_t baseY = PLOT_TOP + yScaled;

      for(int8_t dy=-1; dy<=1; dy++){
        int16_t yy = (int16_t)baseY + dy;
        if(yy>=0 && yy<OLED_H) display.drawPixel(x, yy, SSD1306_WHITE);
      }

      x++;
      idx = (idx+1) % PW;
    }
  }

  int mvInt = (int)(dropV*1000.0f+0.5f); if(mvInt>999) mvInt=999;
  int pctInt=(int)(pct+0.5f);
  if(pctInt<0) pctInt=0; if(pctInt>99) pctInt=99;

  display.setTextSize(2);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(2, OLED_H-18);

  if(mvInt<100) display.print('0');
  if(mvInt<10)  display.print('0');
  display.print(mvInt);
  display.print("mV ");

  if(pctInt<10) display.print('0');
  display.print(pctInt);
  display.print("%");

  display.display();
}

void drawTestChipMenu_TC(uint8_t sel, TestChipResult_TC pendingRes){

  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);

  display.setCursor(30,0);
  display.print("TESTER CHIP");

  if(sel==TCSEL_CPU){
    drawInvertedLabel(10,14,"CPU");
  } else {
    display.setCursor(10,14); display.print("CPU");
  }

  if(sel==TCSEL_GPU){
    drawInvertedLabel(90,14,"GPU");
  } else {
    display.setCursor(90,14); display.print("GPU");
  }

  if(sel==TCSEL_VRAM){
    drawInvertedLabel(10,30,"VRAM");
  } else {
    display.setCursor(10,30); display.print("VRAM");
  }

  if(sel==TCSEL_BUCK){
    drawInvertedLabel(90,30,"BUCK");
  } else {
    display.setCursor(90,30); display.print("BUCK");
  }

  display.setCursor(4,42);
 display.print("Ajuste 1v a 4A  B1>");
 drawInvertedLabel(6, 54, " DESCONECTE PINZAS!");

}
void drawTestArmed_TC(uint8_t sel){

  display.clearDisplay();
  display.setTextSize(2);
  display.setTextColor(SSD1306_WHITE);

  switch(sel){
    case TCSEL_CPU:  display.setCursor(0,0); display.print("CPU");  break;
    case TCSEL_GPU:  display.setCursor(0,0); display.print("GPU");  break;
    case TCSEL_VRAM: display.setCursor(0,0); display.print("VRAM"); break;
    case TCSEL_BUCK: display.setCursor(0,0); display.print("BUCK"); break;
  }

  display.setTextSize(1);
  display.setCursor(0,24);
  display.print("Pinza + en placa");

  display.setCursor(0,34);
  display.print("Pinza - en GND");

  drawInvertedLabel(0,50,"B1 TEST");
  display.setCursor(60,50);
  display.print("B2<");

  display.display();
}

void drawTestMeasuring_TC(uint8_t sel){

  display.clearDisplay();
  display.setTextSize(2);
  display.setTextColor(SSD1306_WHITE);

  switch(sel){
    case TCSEL_CPU:  display.setCursor(0,0); display.print("CPU");  break;
    case TCSEL_GPU:  display.setCursor(0,0); display.print("GPU");  break;
    case TCSEL_VRAM: display.setCursor(0,0); display.print("VRAM"); break;
    case TCSEL_BUCK: display.setCursor(0,0); display.print("BUCK"); break;
  }

  display.setTextSize(1);
  display.setCursor(0,28);
  display.print("Comprobando V...");

  display.setCursor(0,40);
  display.print("Mantenga 1v estable");

  unsigned long elapsed = millis() - tcMeasureStartMs;
  uint8_t barW = (elapsed >= TC_MEASURE_WINDOW_MS)
                 ? 100
                 : (uint8_t)( (elapsed*100UL)/TC_MEASURE_WINDOW_MS );
  display.drawRect(0,56,104,6,SSD1306_WHITE);
  display.fillRect(1,57,barW,4,SSD1306_WHITE);

  display.display();
}

void drawTestResult_TC(uint8_t sel,
                       TestChipResult_TC res,
                       float vAvg,float vMin,float vMax)
{
  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE);

  display.setTextSize(2);
  switch(sel){
    case TCSEL_CPU:  display.setCursor(0,0); display.print("CPU");  break;
    case TCSEL_GPU:  display.setCursor(0,0); display.print("GPU");  break;
    case TCSEL_VRAM: display.setCursor(0,0); display.print("VRAM"); break;
    case TCSEL_BUCK: display.setCursor(0,0); display.print("BUCK"); break;
  }

  display.setTextSize(1);

  const char *msgMain = "";
  bool invertMsg=false;

  switch(res){
  case TCR_OK:    msgMain="CHIP OK!"; invertMsg=false; break;
  case TCR_VLOW:  msgMain="V BAJO";   invertMsg=true;  break;
  case TCR_VHIGH: msgMain="V ALTO";   invertMsg=true;  break;
  case TCR_SHORT: msgMain="CORTO!";   invertMsg=true;  break;
  case TCR_NOCON: msgMain="SIN CARGA";invertMsg=true;  break;
  case TCR_FAIL:
  default:        msgMain="CHIP FALLA"; invertMsg=true; break;
}

  if(invertMsg){
    drawInvertedLabel(0,24,msgMain);
  }else{
    display.setCursor(0,24);
    display.print(msgMain);
  }

float useMin = (tc_cntStable>0) ? tc_vMinStable : vMin;
float useMax = (tc_cntStable>0) ? tc_vMaxStable : vMax;

float dropPct = 0.0f;
if(useMax > 0.001f){
  dropPct = (useMax - useMin)/useMax * 100.0f;
  if(dropPct < 0) dropPct = 0;
  if(dropPct > 99.0f) dropPct = 99.0f;
}

  display.setCursor(0,36);
  display.print("Media ");
  display.print(vAvg,2);
  display.print("v");

  display.setCursor(0,46);
  display.print("MIN ");
  display.print(vMin,2);
  display.print("v");

  display.setCursor(64,46);
  display.print("MAX ");
  display.print(vMax,2);
  display.print("v");

  display.setCursor(0,56);
  display.print("Caida ");
  display.print(dropPct,0);
  display.print("%");

  drawInvertedLabel(95,56,"B1>");

  display.setCursor(70,56);
  display.print("B2<");

  display.display();
}
void drawTestSummaryScreen_WithGraph_Compact(
    uint8_t sel,
    uint8_t finalCode,
    float vAvg,
    float vMin,
    float vMax,
    uint8_t dropPct
){
  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE);

  const char *chipTxt = "CPU";
  switch(sel){
    case TCSEL_CPU:  chipTxt="CPU";  break;
    case TCSEL_GPU:  chipTxt="GPU";  break;
    case TCSEL_VRAM: chipTxt="VRAM"; break;
    case TCSEL_BUCK: chipTxt="BUCK"; break;
  }

const char *resTxt = "OK";
bool badRes = false;
switch(finalCode){
  case 0: resTxt="OK";         badRes=false; break;
  case 1: resTxt="V BAJO";     badRes=true;  break;
  case 2: resTxt="V ALTO";     badRes=true;  break;
  case 3: resTxt="CORTO";      badRes=true;  break;
  case 5: resTxt="SIN CARGA";  badRes=true;  break;
  default:
  case 4: resTxt="INESTABLE";  badRes=true;  break;
}

  char headerBuf[20];
  snprintf(headerBuf,sizeof(headerBuf),"%s  %s", chipTxt, resTxt);

  display.setTextSize(1);
  int16_t hbX, hbY; uint16_t hbW, hbH;
  display.getTextBounds(headerBuf, 0,0, &hbX,&hbY,&hbW,&hbH);

  int16_t boxX = (OLED_W - (int16_t)hbW - 6) / 2;
  if(boxX < 0) boxX = 0;
  int16_t boxY = 0;
  uint16_t boxW = hbW + 6;
  uint16_t boxH = hbH + 4;

  display.fillRect(boxX, boxY, boxW, boxH, SSD1306_WHITE);

  display.setTextColor(SSD1306_BLACK);
  display.setCursor(boxX+3, boxY+2);
  display.print(headerBuf);

  display.setTextColor(SSD1306_WHITE);

const int GXg   = 0;
const int GW    = 128;
const int yTop  = 16;
const int y1V   = 24;
const int y05V  = 36;
const int y0V   = 52;
const int yText0 = 10;

display.setTextSize(1);
display.setTextColor(SSD1306_WHITE);
display.setCursor(0, yText0);
display.print("1v");

display.setCursor(0, y05V-3);
display.print("0.5");

display.setCursor(0, y0V-3);
display.print("0v");

for (int x = 12; x < GW; x++) {
  if ((x % 4) < 2) {
    display.drawPixel(GXg + x, y1V, SSD1306_WHITE);
  }
}

for (int x = 12; x < GW; x++) {
  if ((x % 4) < 2) {
    display.drawPixel(GXg + x, y05V, SSD1306_WHITE);
  }
}

for (int x = 12; x < GW; x++) {
  display.drawPixel(GXg + x, y0V, SSD1306_WHITE);
}

if (tc_traceCount > 1) {

  uint16_t startIdx = (uint16_t)(tc_traceCount * 20UL / 100UL);
  if (startIdx >= tc_traceCount - 1) startIdx = 0;

  uint16_t usedCount = tc_traceCount - startIdx;
  if (usedCount < 2) usedCount = 2;

  const float V_TOP  = 1.00f;
  const float V_MID  = 0.50f;

  const int yTopTrace    = y1V;
  const int yBottomTrace = y05V;

  int prevX = -1;
  int prevY = -1;

  for (int x = 12; x < GW; x++) {

    uint16_t idx = startIdx + (uint16_t)(
      ((uint32_t)(x-12) * (uint32_t)usedCount) / (uint32_t)(GW-12)
    );
    if (idx >= tc_traceCount) idx = tc_traceCount - 1;

    float vNow = tc_trace[idx];

    if (vNow > V_TOP) vNow = V_TOP;
    if (vNow < V_MID) vNow = V_MID;

    float norm = (vNow - V_MID) / (V_TOP - V_MID);

    int yPix = yBottomTrace
               - (int)( norm * (float)(yBottomTrace - yTopTrace) + 0.5f );

    if (yPix < yTopTrace)    yPix = yTopTrace;
    if (yPix > yBottomTrace) yPix = yBottomTrace;

    int Xpix = GXg + x;
    display.drawPixel(Xpix, yPix, SSD1306_WHITE);

    if (prevX >= 0) {
      if (abs(yPix - prevY) > 1) {
        int yA = (yPix < prevY) ? yPix : prevY;
        int yB = (yPix < prevY) ? prevY : yPix;
        for (int yy = yA; yy <= yB; yy++) {
          display.drawPixel(Xpix, yy, SSD1306_WHITE);
        }
      }
    }

    prevX = Xpix;
    prevY = yPix;
  }

} else {

  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(32, (y1V + y05V)/2 - 3);
  display.print("SIN DATOS");
}

char footerBuf[48];

int vMax_i = (int)floor(fabs(vMax));
int vMax_d = (int)round((fabs(vMax) - (float)vMax_i) * 100.0f);
if (vMax_d > 99) vMax_d = 99;

int vMin_i = (int)floor(fabs(vMin));
int vMin_d = (int)round((fabs(vMin) - (float)vMin_i) * 100.0f);
if (vMin_d > 99) vMin_d = 99;

int vAvg_i = (int)floor(fabs(vAvg));
int vAvg_d = (int)round((fabs(vAvg) - (float)vAvg_i) * 100.0f);
if (vAvg_d > 99) vAvg_d = 99;

snprintf(
  footerBuf,
  sizeof(footerBuf),
  "%02u%% +%d.%02d -%d.%02d =%d.%02d",
  (unsigned int)dropPct,
  vMax_i, vMax_d,
  vMin_i, vMin_d,
  vAvg_i, vAvg_d
);

int16_t fx, fy;
uint16_t fW, fH;
display.getTextBounds(footerBuf, 0, 0, &fx, &fy, &fW, &fH);

int16_t footerY = OLED_H - fH;
int16_t footerX = (OLED_W - fW) / 2;
if (footerX < 0) footerX = 0;

display.setCursor(footerX, footerY);
display.print(footerBuf);

  display.display();
}

TestChipResult_TC classifyResult_TC(){

  uint16_t useCnt   = (tc_cntStable > 0) ? tc_cntStable : tc_cnt;
  float    useVmin  = (tc_cntStable > 0) ? tc_vMinStable : tc_vMin;
  float    useVmax  = (tc_cntStable > 0) ? tc_vMaxStable : tc_vMax;

  if(useCnt == 0){
    return TCR_FAIL;
  }

  float vAvg = tc_vSum / (float)tc_cnt;
  float aAvg = tc_aSum / (float)tc_cnt;

if (testChipSel_TC == TCSEL_GPU) {
  if (aAvg < 0.02f) return TCR_NOCON;
} else {
  if (aAvg < 0.05f) return TCR_NOCON;
}

  if ((useVmin < 0.60f && aAvg > 0.5f) || (useVmin < 0.35f)) {
  return TCR_SHORT;
}

  if(useVmax > 1.40f){
    return TCR_VHIGH;
  }

  bool vOk = (vAvg >= 0.80f && vAvg <= 1.20f);
  bool aOk = (aAvg >= 0.20f && aAvg <= 3.50f);
  if(vOk && aOk){
    return TCR_OK;
  }

  if(vAvg < 0.80f){
    return TCR_VLOW;
  }

  if(vAvg > 1.20f){
    return TCR_VHIGH;
  }

  return TCR_FAIL;
}

const float CPU_SHORT_V        = 0.30f;
const float CPU_MIN_AVG_OK_V   = 0.75f;
const float CPU_MAX_EXPECTED_V = 1.20f;
const float CPU_DROP_BAD_PCT   = 30.0f;

TestChipResult_TC classifyCPU_TC(){
    if(tc_cnt == 0){

        return TCR_FAIL;
    }

    float vAvg = tc_vSum / (float)tc_cnt;

    float dropPct = 0.0f;
    if (tc_vMax > 0.001f) {
        dropPct = (tc_vMax - tc_vMin) / tc_vMax * 100.0f;
        if(dropPct < 0.0f) dropPct = 0.0f;
    }

    if (tc_vMin < CPU_SHORT_V){
        return TCR_SHORT;
    }

    if (tc_vMax > CPU_MAX_EXPECTED_V){
        return TCR_VHIGH;
    }

    if (vAvg < CPU_MIN_AVG_OK_V){
        return TCR_VLOW;
    }

    if (dropPct > CPU_DROP_BAD_PCT){
        return TCR_FAIL;
    }

    return TCR_OK;
}
void drawMainMenu(uint8_t sel){
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);

  if(sel==MM_CANAL2){
    drawInvertedLabel(4,10,"CANAL 2");
  } else {
    display.setCursor(4,10);
    display.print("CANAL 2");
  }

  if(sel==MM_TESTCHIP){
    drawInvertedLabel(70,10,"TEST CHIP");
  } else {
    display.setCursor(70,10);
    display.print("TEST CHIP");
  }

  if(sel==MM_MEDICION){
    drawInvertedLabel(4,30,"MEDICION");
  } else {
    display.setCursor(4,30);
    display.print("MEDICION");
  }

  if(sel==MM_LAPTOP){
    drawInvertedLabel(70,30,"PORTATIL");
  } else {
    display.setCursor(70,30);
    display.print("PORTATIL");
  }

  drawInvertedLabel(4,52,"B1>");
  display.setCursor(50,52);
  display.print("B2 pasa/sal");

  display.display();
}

void drawTestChipMenu(uint8_t sel){
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);

  if(sel==TC_CPU){
    drawInvertedLabel(4,8,"CPU");
  } else {
    display.setCursor(4,8); display.print("CPU");
  }

  if(sel==TC_GPU){
    drawInvertedLabel(74,8,"GPU");
  } else {
    display.setCursor(74,8); display.print("GPU");
  }

  if(sel==TC_VRAM){
    drawInvertedLabel(4,24,"VRAM");
  } else {
    display.setCursor(4,24); display.print("VRAM");
  }

  if(sel==TC_BUCK){
    drawInvertedLabel(74,24,"BUCK");
  } else {
    display.setCursor(74,24); display.print("BUCK");
  }

  display.setCursor(4,44);
  display.print("Ajuste 1v Pulse B1");

  display.setCursor(4,56);
  display.print("Volver B2 largo");

  display.display();
}

void drawVoltimetro(float vShow, const char *estadoTxt){
  display.clearDisplay();

  display.setTextColor(SSD1306_WHITE);
  display.setTextSize(2);
  display.setCursor(2,0);
  display.print("VOLTIMETRO");

  {
    char buf[16];
    dtostrf(vShow,0,3,buf);
    int16_t x1,y1; uint16_t w1,h1;
    display.setTextSize(2);
    display.setTextColor(SSD1306_WHITE);
    display.getTextBounds(buf,0,0,&x1,&y1,&w1,&h1);
    int16_t xx=(OLED_W - (w1+12))/2;
    if(xx<0)xx=0;
    int16_t yy=24;
    display.setCursor(xx,yy);
    display.print(buf);
    display.print("V");
  }

  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(10,50);
  display.print("Senal ");
  display.print(estadoTxt);

  drawInvertedLabel(90,50,"B2<");

  display.display();
}

void drawVoltimetroExitWarning(){
  display.clearDisplay();
  display.fillRect(0,0,OLED_W,OLED_H,SSD1306_WHITE);

  display.setTextColor(SSD1306_BLACK);
  display.setTextSize(2);
  display.setCursor(16,12);
  display.print("RECUERDE");

  display.setTextSize(1);
  display.setCursor(28,36);
  display.print("¡DESCONECTE");
  display.setCursor(28,48);
  display.print("LAS PINZAS!");

  display.display();
}

void drawLaptopScreen(bool needAdj19v){
  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE);

  display.setTextSize(2);
  display.setCursor(20,0);
  display.print("PORTATIL");

  display.setTextSize(1);

  if (needAdj19v) {

    display.setCursor(15, 20);
    display.print("AJUSTE EL VOLTAJE");

    drawInvertedLabel(22, 36, "RANGO 18 A 21V");

    display.setCursor(4, 54);
    drawInvertedLabel(4,54, "B1>");
    display.setCursor(105, 54);
    display.print("B2<");
  } else {

    display.setCursor(4, 16);
    display.print("ANALISIS");

    display.setTextSize(2);
    display.setCursor(0, 30);
    display.print("0.000A");

    display.setTextSize(1);
    display.setCursor(4, 54);
    display.print("B1 on/off");
    display.setCursor(90, 54);
    display.print("B2<");
  }

  display.display();
}

void drawLaptopAdjustWarning(float vAvg){
  display.clearDisplay();

  display.setTextSize(2);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.print("AVISO");

  display.setTextSize(1);
  display.setCursor(0, 22);
  display.print("Medido: ");
  display.print(vAvg, 2);
  display.print("V");

  display.fillRect(0, 36, 128, 14, SSD1306_WHITE);
  display.setTextColor(SSD1306_BLACK);
  display.setCursor(8, 38);
  display.print("Ajuste 18 a 21V primero");

  display.setTextColor(SSD1306_WHITE);
  display.setCursor(92, 54);
  display.print("B2<");

  display.display();
}

void armCh1(){
  relay1=true;
  setRelay(RELAY1,true);

  safeModeEnabled=true;
  ch1OnMs=millis();
  vref = readVoltageCal();

  lastShortTrip=false;
  tripScreenDrawn=false;

  ch1State=CH1_ACTIVE;
}

void forceGoHome(){
  relay1=false;
  setRelay(RELAY1,false);
  ch1State = CH1_IDLE;
  lastShortTrip=false;
  tripScreenDrawn=false;
  uiMode = MODE_HOME;
}

void redrawCurrentScreenAfterWake() {
  uiMode   = MODE_HOME;
  ch1State = CH1_IDLE;
  relay1   = false;
  setRelay(RELAY1,false);
  drawHomeIdle();
}

bool tcCheckOneVolt_OK() {

  relay1 = true;
  setRelay(RELAY1, true);
  safeModeEnabled = true;
  ch1OnMs = millis();

  delay(50);

  float vNow = 0.0f, aNow = 0.0f;
  readVA(vNow, aNow);

if (aNow >= 4.0f) {
  relay1 = false;
  setRelay(RELAY1, false);
  beepCount(3);
  lastResult_TC = TCR_SHORT;
  testPhase_TC  = TCPH_RESULT;
  return false;
}

  tc_lastCheckVolt = vNow;

  relay1 = false;
  setRelay(RELAY1, false);

  if (vNow >= TC_OK_MIN_V && vNow <= TC_OK_MAX_V) {
    return true;
  } else {
    return false;
  }
}

struct TCProfile {
  float minV;
  float maxV;
  float shortV;
  float highV;
  float dropBadPct;
  unsigned long windowMs;
};

TCProfile tcProfile;

void configureProfileForCurrentSelection(uint8_t sel) {
  switch (sel) {
    case TCSEL_CPU:
      tcProfile = {0.80f, 1.20f, 0.30f, 1.40f, 30.0f, 5500};
      break;

    case TCSEL_GPU:
      tcProfile = {0.80f, 1.20f, 0.30f, 1.50f, 25.0f, 5500};
      break;

    case TCSEL_VRAM:
      tcProfile = {1.00f, 1.40f, 0.50f, 1.60f, 20.0f, 3000};
      break;

    case TCSEL_BUCK:
      tcProfile = {0.60f, 2.00f, 0.20f, 2.50f, 50.0f, 500};
      break;

    default:
      tcProfile = {0.80f, 1.20f, 0.30f, 1.40f, 30.0f, 5500};
      break;
  }

  TC_MEASURE_WINDOW_MS = tcProfile.windowMs;
}

void handleTestChip_TC(){

  if(checkLongPressB2()){
    beepOnce(40);

    setRelay(RELAY1,false);
    relay1=false;

    ch1State = CH1_IDLE;
    uiMode   = MODE_HOME;
    return;
  }

  switch(testPhase_TC){

case TCPH_READY: {

  drawTestChipMenu_TC(testChipSel_TC, lastResult_TC);
  display.display();

  if (consumeClick(BTN2)) {
    beepOnce(40);
    testChipSel_TC = (testChipSel_TC + 1) % TCSEL_COUNT;
    drawTestChipMenu_TC(testChipSel_TC, lastResult_TC);
    display.display();
    registerActivity();
    break;
  }

 if (consumeClick(BTN1)) {

  relay1 = true;
  setRelay(RELAY1, true);
  delay(100);

  float vNow = 0.0f, aNow = 0.0f;
  readVA(vNow, aNow);
tc_lastAdjV = vNow;
tc_lastAdjA = aNow;
  delay(200);
  relay1 = false;
  setRelay(RELAY1, false);

  float vTarget = 1.0f;
  if (testChipSel_TC == TCSEL_VRAM) {
    vTarget = 1.20f;
  }

  float vMinOk = vTarget * 0.90f;
  float vMaxOk = vTarget * 1.10f;

  if (vNow >= vMinOk && vNow <= vMaxOk) {

    switch (testChipSel_TC) {
      case TCSEL_GPU:   tc_runMs = 6000; tc_settleMs = 300; break;
      case TCSEL_VRAM:  tc_runMs = 4000; tc_settleMs = 200; break;
      case TCSEL_BUCK:  tc_runMs =  300; tc_settleMs = 100; break;
      default:          tc_runMs = 4000; tc_settleMs = 200; break;
    }
    beepOnce(80);
    testPhase_TC = TCPH_ARMED;
    break;
  }

  beepCount(2, 60, 80);
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(30,0);
  display.print("TESTER CHIP");

  if (testChipSel_TC == TCSEL_VRAM) {
    drawInvertedLabel(4,48,"AJUSTE 1.2V PRIMERO");
    display.setCursor(4,28);
display.print("Medido: ");
display.print(tc_lastAdjV, 3);
display.print("V");
  } else {
    drawInvertedLabel(4,48,"AJUSTE 1V PRIMERO");
        display.setCursor(4,28);
display.print("Medido: ");
display.print(tc_lastAdjV, 3);
display.print("V");
  }

  display.display();
 display.display();
delaySafe(6000);
break;
  break;
}

} break;

case TCPH_ARMED: {

  drawTestArmed_TC(testChipSel_TC);

  if (consumeClick(BTN2)) {
    beepOnce(40);
    testPhase_TC = TCPH_READY;
    return;
  }

if(consumeClick(BTN1)){
    beepOnce(80);

    tc_vMin = 99.0f;
    tc_vMax = 0.0f;
    tc_vSum = 0.0f;
    tc_cnt  = 0;
    tc_aMinStable = 99.0f;
tc_aMaxStable = 0.0f;

    tc_vMinStable = 99.0f;
    tc_vMaxStable = 0.0f;
    tc_aSumStable = 0.0f;
    tc_cntStable  = 0;
    tc_aPrev    = NAN;
tc_aP2P     = 0.0f;
tc_aStepMax = 0.0f;

    for (uint16_t i = 0; i < TC_TRACE_MAX; i++) {
        tc_trace[i] = 0.0f;
    }
    tc_traceCount = 0;

    relay1=true;
    setRelay(RELAY1,true);
    safeModeEnabled=true;
    ch1OnMs=millis();

    tcMeasureStartMs=millis();

    testPhase_TC = TCPH_MEASURE;
    return;
}
configureProfileForCurrentSelection(testChipSel_TC);

} break;
case TCPH_MEASURE: {

      const unsigned long WARMUP_IGNORE_MS   = 50;
      const unsigned long STABLE_START_MS    = 200;

      unsigned long now     = millis();
      unsigned long elapsed = now - tcMeasureStartMs;

      float vNow = 0.0f;
      float aNow = 0.0f;
      readVA(vNow, aNow);

if (elapsed < (tcMeasureStartMs + (TC_MEASURE_WINDOW_MS / 2))) {
    tc_aSumEarly += aNow;
    tc_aCntEarly++;
} else {
    tc_aSumLate  += aNow;
    tc_aCntLate++;
}

if (aNow > tc_aMax) tc_aMax = aNow;
if (aNow < tc_aMin) tc_aMin = aNow;

if (!isnan(tc_aPrev)) {
  float step = fabs(aNow - tc_aPrev);
  if (step > tc_aStepMax) tc_aStepMax = step;
}
tc_aPrev = aNow;

if (tc_traceCount < TC_TRACE_MAX) {
  tc_trace[tc_traceCount] = vNow;
  tc_traceCount++;
}

      if (elapsed >= WARMUP_IGNORE_MS){

        if (vNow < tc_vMin) tc_vMin = vNow;
        if (vNow > tc_vMax) tc_vMax = vNow;
        tc_vSum += vNow;

        if (aNow < tc_aMin) tc_aMin = aNow;
        if (aNow > tc_aMax) tc_aMax = aNow;
        tc_aSum += aNow;
if (aNow < tc_aMinStable) tc_aMinStable = aNow;
if (aNow > tc_aMaxStable) tc_aMaxStable = aNow;
        tc_cnt++;
      }

if (elapsed >= STABLE_START_MS){
  if (vNow < tc_vMinStable) tc_vMinStable = vNow;
  if (vNow > tc_vMaxStable) tc_vMaxStable = vNow;
  tc_aSumStable += aNow;
  tc_cntStable++;

  if (tc_stableStartMs == 0) tc_stableStartMs = millis();

  unsigned long stableMs = millis() - tc_stableStartMs;
  const unsigned long STABLE_SPLIT_MS = 400;

  if (stableMs < STABLE_SPLIT_MS) {
    tc_aSumEarly += aNow;  tc_aCntEarly++;
  } else {
    tc_aSumLate  += aNow;  tc_aCntLate++;
  }
}

if (safeModeEnabled){
  if ((now - ch1OnMs) >= SAFE_ARM_DELAY_MS){
    if (vNow < TC_SHORT_V){
      relay1 = false;
      setRelay(RELAY1,false);
      beepCount(3);

      lastResult_TC = TCR_SHORT;
      tc_finalCode  = 3;

      testPhase_TC = TCPH_RESULT;
      return;
    }
  }
}

      drawTestMeasuring_TC(testChipSel_TC);

      if (elapsed >= TC_MEASURE_WINDOW_MS){

        relay1 = false;
        setRelay(RELAY1,false);

if (testChipSel_TC == TCSEL_CPU || testChipSel_TC == TCSEL_GPU) {

  uint16_t useCnt   = (tc_cntStable > 0) ? tc_cntStable : tc_cnt;
  float    useVmin  = (tc_cntStable > 0) ? tc_vMinStable : tc_vMin;
  float    useVmax  = (tc_cntStable > 0) ? tc_vMaxStable : tc_vMax;

  float vAvg_all = (tc_cnt>0) ? (tc_vSum / (float)tc_cnt) : 0.0f;
  float aAvg_all = (tc_cnt>0) ? (tc_aSum / (float)tc_cnt) : 0.0f;

float aEarly = (tc_aCntEarly>0) ? (tc_aSumEarly/(float)tc_aCntEarly) : 0.0f;
float aLate  = (tc_aCntLate >0) ? (tc_aSumLate /(float)tc_aCntLate ) : aEarly;

if (aEarly >= 0.30f && aLate <= 0.05f && useVmin >= tcProfile.minV*0.95f) {
  lastResult_TC = TCR_FAIL;
}

else if (tc_aStepMax >= 0.50f) {
  lastResult_TC = TCR_FAIL;
}

  float dropPct = 0.0f;
  if (useVmax > 0.001f) {
    dropPct = (useVmax - useVmin) / useVmax * 100.0f;
    if (dropPct < 0.0f)  dropPct = 0.0f;
    if (dropPct > 99.0f) dropPct = 99.0f;
  }

float aEarlyCPU = (tc_aCntEarly > 0) ? (tc_aSumEarly / (float)tc_aCntEarly) : 0.0f;
float aLateCPU  = (tc_aCntLate  > 0) ? (tc_aSumLate  / (float)tc_aCntLate ) : 0.0f;
float aDropCPU  = aEarlyCPU - aLateCPU;
float aP2P_CPU  = tc_aMax - tc_aMin;

const float EARLY_MIN_A    = 0.20f;
const float LATE_NEAR_ZERO = 0.05f;
const float DROP_MIN_A     = 0.15f;
const float STEP_BAD_A     = 0.35f;
const float P2P_BAD_A      = 0.45f;
const float DROP_V_HELP    = 10.0f;

if ( (aEarlyCPU >= EARLY_MIN_A && aLateCPU <= LATE_NEAR_ZERO) ||
     (aDropCPU   >= DROP_MIN_A) ||
     (tc_aStepMax >= STEP_BAD_A) ||
     (aP2P_CPU   >= P2P_BAD_A && dropPct >= DROP_V_HELP) ) {
  lastResult_TC = TCR_FAIL;
}

  const float NO_LOAD_A   = 0.02f;
  const float MIN_A_CPU   = 0.30f;
  const float MIN_A_GPU   = 0.50f;
  const float MIN_A_OK    = (testChipSel_TC==TCSEL_GPU) ? MIN_A_GPU : MIN_A_CPU;

if (aAvg_all <= 0.005f) {
  lastResult_TC = TCR_NOCON;
}
else if ((useVmin < 0.60f && aAvg_all > 0.5f) || (useVmin < 0.35f)) {
  lastResult_TC = TCR_SHORT;
}
  else if (useVmax > tcProfile.highV) {
    lastResult_TC = TCR_VHIGH;
  }
  else if (vAvg_all < tcProfile.minV) {
    lastResult_TC = TCR_VLOW;
  }
  else if (vAvg_all > tcProfile.maxV) {
    lastResult_TC = TCR_VHIGH;
  }
  else if (aAvg_all < MIN_A_OK) {
    lastResult_TC = TCR_FAIL;
  }
  else if (dropPct > tcProfile.dropBadPct) {
    lastResult_TC = TCR_FAIL;
  }
  else {
    lastResult_TC = TCR_OK;
  }

{
  float aP2P = tc_aMax - tc_aMin;
  float rel  = (aAvg_all > 0.0f) ? (aP2P / aAvg_all) : 0.0f;
  if (rel > 0.55f && dropPct > 6.0f) {
    lastResult_TC = TCR_FAIL;
  }
}
}
else if (testChipSel_TC == TCSEL_VRAM) {

  float vAvg_all = (tc_cnt>0) ? (tc_vSum/(float)tc_cnt) : 0.0f;
  float aAvg_all = (tc_cnt>0) ? (tc_aSum/(float)tc_cnt) : 0.0f;

if (aAvg_all < 0.02f)            lastResult_TC = TCR_NOCON;
  else if (tc_vMin < 0.50f)        lastResult_TC = TCR_SHORT;
  else if (tc_vMax > 1.60f)        lastResult_TC = TCR_VHIGH;
  else if (vAvg_all < 1.10f)       lastResult_TC = TCR_VLOW;
  else if (vAvg_all > 1.30f)       lastResult_TC = TCR_VHIGH;
  else                              lastResult_TC = TCR_OK;
}

else {
  uint16_t useCnt   = (tc_cntStable > 0) ? tc_cntStable : tc_cnt;
  float    useVmin  = (tc_cntStable > 0) ? tc_vMinStable : tc_vMin;
  float    useVmax  = (tc_cntStable > 0) ? tc_vMaxStable : tc_vMax;

  float vAvg_all = (tc_cnt  > 0) ? (tc_vSum / (float)tc_cnt) : 0.0f;
  float aAvg_all = (tc_cnt  > 0) ? (tc_aSum / (float)tc_cnt) : 0.0f;
  float aP2P     = tc_aMax - tc_aMin;

  float dropPct = 0.0f;
  if (useVmax > 0.001f) {
    dropPct = (useVmax - useVmin) / useVmax * 100.0f;
    if (dropPct < 0.0f)  dropPct = 0.0f;
    if (dropPct > 99.0f) dropPct = 99.0f;
  }

  const float NOLOAD_A       = 0.02f;
  const float OK_V_MIN       = 0.85f;
  const float OK_V_MAX       = 1.20f;
  const float OK_DROP_MAX    = 20.0f;
  const float FLUCT_A_STRONG = 0.40f;
  const float FLUCT_A_MED    = 0.25f;
  const float UNSTABLE_DROP  = 25.0f;
  const float SHORT_A_SPIKE  = 3.0f;
  const float SHORT_V_ABS    = 0.60f;

  if (aAvg_all < NOLOAD_A && dropPct < 3.0f) {
    lastResult_TC = TCR_NOCON;
  }

  else if ( (tc_aMax >= SHORT_A_SPIKE && useVmin < SHORT_V_ABS) ||
            (dropPct >= 55.0f && aAvg_all > 0.5f) ) {
    lastResult_TC = TCR_SHORT;
  }

  else if (aP2P >= FLUCT_A_STRONG) {
    lastResult_TC = TCR_FAIL;
  }

  else if (aP2P >= FLUCT_A_MED && dropPct >= UNSTABLE_DROP) {
    lastResult_TC = TCR_FAIL;
  }

  else if (vAvg_all >= OK_V_MIN && vAvg_all <= OK_V_MAX && dropPct <= OK_DROP_MAX) {

    if (aAvg_all >= 0.04f && aAvg_all <= 3.0f) {
      lastResult_TC = TCR_OK;
    } else {

      lastResult_TC = TCR_FAIL;
    }
  }

  else if (vAvg_all < OK_V_MIN) {
    lastResult_TC = TCR_VLOW;
  }
  else if (vAvg_all > OK_V_MAX) {
    lastResult_TC = TCR_VHIGH;
  }

  else {
    lastResult_TC = TCR_FAIL;
  }
}

if (tc_cntStable >= 12 && lastResult_TC != TCR_SHORT && lastResult_TC != TCR_NOCON) {
  float aP2P_stable = tc_aMaxStable - tc_aMinStable;

  const float TH_CPU_GPU = 0.45f;
  const float TH_VRAM_BUCK = 0.30f;

  bool isCpuGpu = (testChipSel_TC == TCSEL_CPU || testChipSel_TC == TCSEL_GPU);
  float th = isCpuGpu ? TH_CPU_GPU : TH_VRAM_BUCK;

  float vAvg_all = (tc_cnt>0) ? (tc_vSum / (float)tc_cnt) : 0.0f;
  if (vAvg_all >= 0.75f && vAvg_all <= 1.25f) {
    if (aP2P_stable >= th) {
      lastResult_TC = TCR_FAIL;
    }
  }
}

switch(lastResult_TC){
  case TCR_OK:     tc_finalCode = 0; break;
  case TCR_VLOW:   tc_finalCode = 1; break;
  case TCR_VHIGH:  tc_finalCode = 2; break;
  case TCR_SHORT:  tc_finalCode = 3; break;
  case TCR_NOCON:  tc_finalCode = 5; break;
  default:         tc_finalCode = 4; break;
}

        testPhase_TC = TCPH_RESULT;
        return;
      }

    } break;

 case TCPH_RESULT: {

    float vAvg = (tc_cnt>0) ? (tc_vSum/(float)tc_cnt) : 0.0f;

    float dropPctF = 0.0f;
    if(tc_vMax>0.001f){
      dropPctF = (tc_vMax - tc_vMin)/tc_vMax * 100.0f;
      if(dropPctF<0) dropPctF=0;
    }
    uint8_t dropPct = (dropPctF>99.0f)?99:(uint8_t)(dropPctF+0.5f);

    drawTestSummaryScreen_WithGraph_Compact(
        testChipSel_TC,
        tc_finalCode,
        vAvg,
        tc_vMin,
        tc_vMax,
        dropPct
    );

    if (consumeClick(BTN1)) {
        beepOnce(80);

        tc_vMin        = 99.0f;
        tc_vMax        = 0.0f;
        tc_vSum        = 0.0f;
        tc_cnt         = 0;

        tc_aMin        = 99.0f;
        tc_aMax        = 0.0f;
        tc_aSum        = 0.0f;
tc_aMinStable = 99.0f;
tc_aMaxStable = 0.0f;
        tc_vMinStable  = 99.0f;
        tc_vMaxStable  = 0.0f;
        tc_aSumStable  = 0.0f;
        tc_cntStable   = 0;
tc_aPrev    = NAN;
tc_aP2P     = 0.0f;
tc_aStepMax = 0.0f;
        for (uint16_t i = 0; i < TC_TRACE_MAX; i++) {
            tc_trace[i] = 0.0f;
        }
        tc_traceCount = 0;

        lastResult_TC = TCR_NONE;
        tc_finalCode  = 4;

        relay1 = true;
        setRelay(RELAY1, true);
        safeModeEnabled = true;
        ch1OnMs = millis();

        tcMeasureStartMs = millis();

        testPhase_TC = TCPH_MEASURE;
        return;
    }

    if (consumeClick(BTN2)) {
        beepOnce(40);

        relay1 = false;
        setRelay(RELAY1,false);

        tc_vMin        = 99.0f;
        tc_vMax        = 0.0f;
        tc_vSum        = 0.0f;
        tc_cnt         = 0;
tc_aMinStable = 99.0f;
tc_aMaxStable = 0.0f;
        tc_aMin        = 99.0f;
        tc_aMax        = 0.0f;
        tc_aSum        = 0.0f;

        tc_vMinStable  = 99.0f;
        tc_vMaxStable  = 0.0f;
        tc_aSumStable  = 0.0f;
        tc_cntStable   = 0;
tc_aPrev    = NAN;
tc_aP2P     = 0.0f;
tc_aStepMax = 0.0f;
        for (uint16_t i = 0; i < TC_TRACE_MAX; i++) {
            tc_trace[i] = 0.0f;
        }
        tc_traceCount = 0;

        lastResult_TC = TCR_NONE;
        tc_finalCode  = 4;

        testPhase_TC = TCPH_READY;
        return;
    }

} break;

  }
}

void handleLaptop_TC(){

  if (laptopPhase == LAPH_ADJ) {

    if (consumeClick(BTN2)) {
      beepOnce(40);
      relay1 = false; setRelay(RELAY1, false);
      ch1State = CH1_IDLE;
      uiMode   = MODE_MENU;
      registerActivity();
      return;
    }

    if (consumeClick(BTN1)) {
      beepOnce(80);

      relay1 = true; setRelay(RELAY1, true);
      safeModeEnabled = true;
      ch1OnMs = millis();

      unsigned long t0 = millis();
      float vSum = 0.0f;
      uint16_t vCnt = 0;
      float vNow = 0.0f, aNow = 0.0f;

      while (millis() - t0 < 1000) {
        readVA(vNow, aNow);
        vSum += vNow;
        vCnt++;
        delay(10);
      }

      relay1 = false; setRelay(RELAY1, false);

      float vAvg = (vCnt ? (vSum / (float)vCnt) : 0.0f);

      if (vAvg < LAPTOP_VMIN || vAvg > LAPTOP_VMAX) {
        display.clearDisplay();
        display.setTextColor(SSD1306_WHITE);
        display.setTextSize(2);  display.setCursor(15, 0);  display.print("ATENCION");
        display.setTextSize(1);  display.setCursor(18, 24);
        display.print("Medido: "); display.print(vAvg, 2); display.print("V");
        drawInvertedLabel(17, 40, "AJUSTE 18 a 21V");
        display.display();
        display.display();
delaySafe(3500);
return;
        return;
      }

      laptopPhase = LAPH_ANALYSIS;
      registerActivity();
      return;
    }

    drawLaptopScreen(true);
    return;
  }

  {

    if (consumeClick(BTN2)) {
      beepOnce(40);
      relay1 = false; setRelay(RELAY1, false);
      ch1State = CH1_IDLE;
      uiMode   = MODE_MENU;
      registerActivity();
      return;
    }

    if (consumeClick(BTN1)) {
      beepOnce(60);
      relay1 = !relay1;
      setRelay(RELAY1, relay1);
    }

    float vNow = 0.0f, aNow = 0.0f;
    readVA(vNow, aNow);

    if (relay1 && !lap_lastRelayOn) {
      lap_vBase = vNow;
      lap_aFast = aNow;
      lap_aSlow = aNow;
      lap_aSwingPeak = 0.0f;
    }
    lap_lastRelayOn = relay1;

    unsigned long nowMs = millis();
    if (nowMs - lap_lastSampleMs >= 30) {
      lap_lastSampleMs = nowMs;

      lap_aFast += (aNow - lap_aFast) * 0.40f;
      lap_aSlow += (aNow - lap_aSlow) * 0.05f;
      float swing = fabs(lap_aFast - lap_aSlow);

      if (swing > lap_aSwingPeak) lap_aSwingPeak = swing;
      else                        lap_aSwingPeak *= 0.92f;

      if (aNow >= L_STBY_MIN_A) {
        lap_wasAboveStandby = true;
        lap_lastAboveTs = nowMs;
      }
    }

    const char* diagMsg = "Analisis activo";

    if (!relay1) {
      diagMsg = "Analisis pausado";
      drawLaptopAnalysisSimple(diagMsg, aNow, relay1);
      return;
    }

    if (vNow > LAPTOP_VMAX || vNow < LAPTOP_VMIN) {
      diagMsg = "V FUERA RANGO";
      drawLaptopAnalysisSimple(diagMsg, aNow, relay1);
      return;
    }

    if ( (aNow >= L_SHORT_I) ||
         (lap_vBase > 0.1f && vNow < (lap_vBase * (1.0f - L_SHORT_DROP_P)) && aNow > 0.10f) ) {
      diagMsg = "CORTO!";
      drawLaptopAnalysisSimple(diagMsg, aNow, relay1);
      return;
    }

    if (aNow < L_NO_POWER_A) {
      if (lap_wasAboveStandby && (nowMs - lap_lastAboveTs) < 1500) {
        diagMsg = "SE APAGA";
      } else {
        diagMsg = "SIN ALIMENTACION";
      }
      drawLaptopAnalysisSimple(diagMsg, aNow, relay1);
      return;
    }

    if (aNow >= L_STBY_MIN_A && aNow <= L_STBY_MAX_A && lap_aSwingPeak < L_COMM_SWING_A) {
      diagMsg = "STANDBY OK";
      drawLaptopAnalysisSimple(diagMsg, aNow, relay1);
      return;
    }

    if (lap_aSwingPeak >= L_COMM_SWING_A && aNow < L_BOOT_A) {
      diagMsg = "COMUNICACION OK";
      drawLaptopAnalysisSimple(diagMsg, aNow, relay1);
      return;
    }

    if (aNow >= L_BOOT_A) {
      diagMsg = "INTENTO ARRANQUE";
      drawLaptopAnalysisSimple(diagMsg, aNow, relay1);
      return;
    }

    diagMsg = "ALIMENTANDO...";
    drawLaptopAnalysisSimple(diagMsg, aNow, relay1);
    return;
  }
}

void handleHomeMode(){
  if(checkLongPressB2()){
    beepOnce(40);
    forceGoHome();
    registerActivity();
    return;
  }

  switch(ch1State){

    case CH1_IDLE:{
      if(consumeClick(BTN1)){
        if(!displaySleeping){
          beepOnce(50);
          armCh1();
          registerActivity();
          return;
        }

if (consumeClick(BTN2)) {
  beepOnce(40);
  setRelay(RELAY1, false);
  relay1 = false;
  ch1State = CH1_IDLE;
  uiMode = MODE_HOME;
  registerActivity();
  return;
}
      }
      if(consumeClick(BTN2)){
        if(!displaySleeping){
          beepOnce(40);
          uiMode=MODE_MENU;
          registerActivity();
          return;
        }
      }
      if(!displaySleeping){
        drawHomeIdle();
      }
      delay(40);
    } break;

    case CH1_ACTIVE:{
      if(consumeClick(BTN1)){
        if(!displaySleeping){
          beepOnce(50);
          relay1=false;
          setRelay(RELAY1,false);
          ch1State=CH1_IDLE;
          registerActivity();
          return;
        }
      }

      if (consumeClick(BTN2)){
  if(!displaySleeping){

    safeMode = (SafeMode)((((int)safeMode) + 1) % 3);

    switch(safeMode){
      case SAFE_V:    beepOnce(80);  break;
      case SAFE_OFF:  beepOnce(20);  break;
      case SAFE_PLUS: beepCount(2,40,60); break;
    }

    ch1OnMs = millis();
    registerActivity();
  }
}

      float vNow=0.0f, aNow=0.0f;
      readVA(vNow,aNow);

unsigned long nowMs = millis();

if (safeMode != SAFE_OFF){
  if ((nowMs - ch1OnMs) >= SAFE_ARM_DELAY_MS) {
    if (vNow < SAFE_SHORT_VOLTAGE) {
      relay1=false; setRelay(RELAY1,false);
      lastTripWasPlus = false;
      beepCount(3);
      lastShortTrip=true;
      ch1State=CH1_TRIPPED;
      registerActivity();
      return;
    }
  }
}

const float I_BASE           = 0.06f;
const float I_SPIKE          = 1.10f;
const float I_ABS_HARD       = 1.50f;
const unsigned long I_ABS_CONFIRM_MS = 4;
const unsigned long I_IGN_START_MS   = 6;
const float DI_DT            = 0.80f;

if (safeMode == SAFE_PLUS){
  if ((nowMs - ch1OnMs) >= (SAFE_ARM_DELAY_MS + I_IGN_START_MS)) {
    aHist[aHidx] = aNow;
    tHist[aHidx] = nowMs;
    aHidx = (aHidx + 1) & 0x03;
    if (!aHistPrimed && aHidx==0) aHistPrimed = true;
    if (aHistPrimed){
      int i0 = (aHidx + 3) & 0x03;
      int i1 = (aHidx + 2) & 0x03;
      float a_now  = aHist[i0];
      float a_prev = aHist[i1];
      unsigned long dt = tHist[i0] - tHist[i1];
      float di = a_now - a_prev;
      bool jumpFast = ((a_now >= I_SPIKE) && (dt <= 40)) || ((di >= DI_DT) && (dt <= 40));
      bool absHigh  = (a_now >= I_ABS_HARD);
      static unsigned long absStartMs = 0;
      if (absHigh){
        if (absStartMs == 0) absStartMs = nowMs;
      } else {
        absStartMs = 0;
      }
      bool absConfirmed = (absStartMs && (nowMs - absStartMs) >= I_ABS_CONFIRM_MS);
      if (jumpFast || absConfirmed){
        relay1=false; setRelay(RELAY1,false);
        lastTripWasPlus = true;
        beepCount(3);
        lastShortTrip=true;
        ch1State=CH1_TRIPPED;
        registerActivity();
        return;
      }
    }
  }
}


      static unsigned long diffStart=0;
      unsigned long now=millis();
      float dvfabs=fabs(vNow - vref);
      if(dvfabs > VREF_HYST){
        if(diffStart==0){
          diffStart=now;
        } else if(now-diffStart>=VREF_REARM_HOLD_MS){
          vref=vNow;
          diffStart=0;
        }
      } else {
        diffStart=0;
      }

      float dropV = vref - vNow;
      if(dropV<0) dropV=0;
      float pctDrop=(vref>0.001f)?(dropV/vref*100.0f):0.0f;

      if(pctDrop>=99.0f){
        beepOnce(60);
      }

float zoomFactor;
if (dropV < 0.10f) {
  zoomFactor = 4.0f;
} else if (dropV < 0.20f) {
  zoomFactor = 2.5f;
} else if (dropV < 0.40f) {
  zoomFactor = 1.5f;
} else {
  zoomFactor = 1.0f;
}

float scaledDrop = dropV * zoomFactor;

if(scaledDrop > GRAPH_MAX_DROP) scaledDrop = GRAPH_MAX_DROP;
if(scaledDrop < 0)             scaledDrop = 0;

float norm = scaledDrop / GRAPH_MAX_DROP;
uint8_t yVal = (uint8_t)(norm * (PH-1) + 0.5f);

gbuf[head] = yVal;
head = (head+1) % PW;

      if(!displaySleeping){
        drawChannel1Frame(vNow,aNow,dropV,pctDrop,safeModeEnabled);
      }

      delay(80);
    } break;

    case CH1_TRIPPED: {

      if (consumeClick(BTN1)) {
        if (!displaySleeping) {
          beepOnce(50);
          armCh1();
          registerActivity();
          return;
        }
      }

      if (consumeClick(BTN2)) {
        if (!displaySleeping) {
          beepOnce(40);
          setRelay(RELAY1, false);
          relay1 = false;
          ch1State = CH1_IDLE;
          uiMode   = MODE_HOME;
          registerActivity();
          return;
        }
      }

      if (!displaySleeping) {
        drawTripScreen();
      }

      delay(40);
    } break;
  }
}

void handleMainMenu(){
  if(checkLongPressB2()){
    beepOnce(40);
    forceGoHome();
    registerActivity();
    return;
  }

  if(consumeClick(BTN2)){
    if(!displaySleeping){
      beepOnce(40);
      mainSel = (mainSel+1)%MM_COUNT;
      registerActivity();
    }
  }

  if(consumeClick(BTN1)){
    if(!displaySleeping){
      beepOnce(80);
      registerActivity();

      if(mainSel==MM_CANAL2){
        relay2 = !relay2;
        setRelay(RELAY2, relay2);
        forceGoHome();
        return;
      } else if (mainSel == MM_TESTCHIP) {

        relay1 = false;
        setRelay(RELAY1, false);
        ch1State = CH1_IDLE;

        testChipSel        = 0;
        testChipSel_TC     = TCSEL_CPU;
        lastResult_TC      = TCR_NONE;
        testPhase_TC       = TCPH_READY;
        tc_vMin            = 99.0f;
        tc_vMax            = 0.0f;
        tc_vSum            = 0.0f;
        tc_cnt             = 0;
        tcMeasureStartMs   = 0;

        safeModeEnabled    = true;
        ch1OnMs            = millis();

        uiMode = MODE_TEST_CHIP;

        registerActivity();
        drawTestChipMenu_TC(testChipSel_TC, lastResult_TC);
        display.display();

        return;
      }
      else if(mainSel==MM_LAPTOP){
  relay1=false; setRelay(RELAY1,false);
  ch1State=CH1_IDLE;
  laptopPhase = LAPH_ADJ;
  uiMode=MODE_LAPTOP;
  return;
}

      else if(mainSel==MM_MEDICION){
        relay1=false; setRelay(RELAY1,false);
        ch1State=CH1_IDLE;
        uiMode=MODE_VOLT;
        return;
      } else if(mainSel==MM_LAPTOP){
        relay1=false; setRelay(RELAY1,false);
        ch1State=CH1_IDLE;
        uiMode=MODE_LAPTOP;
        return;
      }
    }
  }

  if(!displaySleeping){
    drawMainMenu(mainSel);
  }
  delay(60);
}

void handleTestChipMenu(){
  if(checkLongPressB2()){
    beepOnce(40);
    forceGoHome();
    registerActivity();
    return;
  }

  if(consumeClick(BTN2)){
    if(!displaySleeping){
      beepOnce(40);
      testChipSel = (testChipSel+1)%TC_COUNT;
      registerActivity();
    }
  }

  if(consumeClick(BTN1)){
    if(!displaySleeping){

      beepOnce(80);
      registerActivity();
    }
  }

  if(!displaySleeping){
    drawTestChipMenu(testChipSel);
  }
  delay(60);
}

void handleVoltimetro(){
  if (consumeClick(BTN2)){
    beepOnce(60);
    drawVoltimetroExitWarning();
    beepLongWarning();
    registerActivity();
    forceGoHome();
    return;
  }
  static float vSlow=0.0f;
  static float vFast=0.0f;
  static float vPeakSwing=0.0f;
  static unsigned long winStart=0;
  static uint8_t phase=0;
  static uint8_t lastState=255;
  static float vShow=0.0f;
  static uint8_t pendingState=255;
  static unsigned long stateStart=0;
  const float FLUCT_THRESH_V=0.020f;
  const float PULSE_THRESH_V=0.250f;
  const float DV_STEP=0.120f;
  const float PULSE_RATE=0.25f;
  const unsigned long STABLE_TIME_MS=1000UL;
  if (phase==0){
    if (winStart==0){
      winStart=micros();
      vPeakSwing=0.0f;
      vFast=0.0f;
      vSlow=0.0f;
    }
    float vPrev=0.0f;
    bool havePrev=false;
    unsigned long n=0, spikes=0;
    float vMin=999.0f, vMax=0.0f, vSum=0.0f;
    while ((unsigned long)(micros()-winStart) < 30000UL){
      float vNow=0.0f, aDummy=0.0f;
      readVA(vNow,aDummy);
      if (vFast==0.0f && vSlow==0.0f){ vFast=vNow; vSlow=vNow; }
      vFast += (vNow - vFast)*0.5f;
      vSlow += (vNow - vSlow)*0.05f;
      float swing=fabs(vFast - vSlow);
      if (swing>vPeakSwing) vPeakSwing=swing;
      if (!havePrev){ vPrev=vNow; havePrev=true; }
      else { if (fabs(vNow - vPrev)>DV_STEP) spikes++; vPrev=vNow; }
      if (vNow<vMin) vMin=vNow;
      if (vNow>vMax) vMax=vNow;
      vSum+=vNow;
      n++;
    }
    float p2p=(vMax - vMin);
    float rate=(n>0)?(float)spikes/(float)n:0.0f;
    uint8_t state;
    if ((p2p>PULSE_THRESH_V) && (rate>PULSE_RATE)) state=2;
    else if (p2p>FLUCT_THRESH_V || rate>(PULSE_RATE*0.5f)) state=1;
    else state=0;
    unsigned long now=millis();
    if (state!=pendingState){
      pendingState=state;
      stateStart=now;
    }
    if ((now - stateStart)>=STABLE_TIME_MS && state!=lastState){
      if (state==2) beepCount(3);
      else if (state==1) beepCount(2);
      else beepOnce(60);
      lastState=state;
    }
    vShow=(n>0)?(vSum/(float)n):vSlow;
    phase=1;
  } else {
    if(!displaySleeping){
      const char *estadoTxt;
      if (lastState==2) estadoTxt="PULSANTE";
      else if (lastState==1) estadoTxt="FLUCTUANTE";
      else estadoTxt="ESTABLE";
      display.clearDisplay();
      display.setTextColor(SSD1306_WHITE);
      display.setTextSize(2);
      display.setCursor(8,0);
      display.print("VOLTIMETRO");
      char buf[16];
      dtostrf(vShow,0,3,buf);
      int16_t x1,y1; uint16_t w1,h1;
      display.setTextSize(2);
      display.setTextColor(SSD1306_WHITE);
      display.getTextBounds(buf,0,0,&x1,&y1,&w1,&h1);
      int16_t xx=(OLED_W - (w1+12))/2; if(xx<0)xx=0;
      int16_t yy=24;
      display.setCursor(xx,yy);
      display.print(buf);
      display.print("V");
      display.setTextSize(1);
      display.setTextColor(SSD1306_WHITE);
      display.setCursor(10,50);
      display.print("V ");
      display.print(estadoTxt);
      drawInvertedLabel(90,50,"B2<");
      display.display();
    }
    phase=0;
    winStart=0;
  }
}


void handleLaptop(){
  if(checkLongPressB2()){
    beepOnce(40);
    forceGoHome();
    registerActivity();
    return;
  }

  bool needAdj19v = true;

  if(consumeClick(BTN1)){
    if(!displaySleeping){
      beepOnce(80);
      registerActivity();

    }
  }

  if(!displaySleeping){
    drawLaptopScreen(needAdj19v);
  }

  delay(60);
}

void handleOledSleep(){
  unsigned long now = millis();

  if(displaySleeping){
    if(rawBtnPressed()){
      oledOn();
      beepOnce(30);
      redrawCurrentScreenAfterWake();
      wakeSwallowInputs = true;
      registerActivity();
    }
    return;
}

  if(uiMode == MODE_HOME && ch1State == CH1_IDLE){
    if((now - lastActivityMs) >= OLED_SLEEP_MS){
      oledOff();
      return;
    }
  }
}

void setup(){
  ina.begin();
  ina.setMaxCurrentShunt(16.0f, 0.005f);
  pinMode(RELAY1,OUTPUT);
  pinMode(RELAY2,OUTPUT);
  setRelay(RELAY1,false); relay1=false;
  setRelay(RELAY2,false); relay2=false;

  pinMode(BTN1,INPUT_PULLUP);
  pinMode(BTN2,INPUT_PULLUP);

  pinMode(BEEPER,OUTPUT);
  noTone(BEEPER);

  Wire.begin();
  Wire.setClock(100000);
  display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR);
  display.setRotation(2);
  display.clearDisplay();
  display.display();

  ina.begin();
wdt_enable(WDTO_2S);
  vref = readVoltageCal();
  for(uint8_t i=0;i<PW;i++) gbuf[i]=0;
  head=0;

  uiMode = MODE_HOME;
  ch1State = CH1_IDLE;
  mainSel = 0;
  testChipSel = 0;
  safeModeEnabled = true;
  lastShortTrip=false;
  tripScreenDrawn=false;
  ch1OnMs=0;

  aSlow=0.0f;
  aPeakSwing=0.0f;
  lastVoltSampleMs=millis();

  displaySleeping=false;
  lastActivityMs=millis();

  drawHomeIdle();
}

void loop(){
  wdt_reset();
  handleOledSleep();
repromod_dualButtonResetHandler();
  if(displaySleeping){
    delay(10);
    return;
  }

  switch(uiMode){
  case MODE_HOME:
    handleHomeMode();
    break;

  case MODE_MENU:
    handleMainMenu();
    break;

  case MODE_TEST_CHIP:
    handleTestChip_TC();
    break;

  case MODE_VOLT:
    handleVoltimetro();
    break;

  case MODE_LAPTOP:
    handleLaptop_TC();
    break;
}
}