Colorimètre / Luxmètre Professionnel OPT4048

/*
 * ============================================================
 *  Colorimètre / Luxmètre Professionnel OPT4048
 *  Version 2.1 — Avril 2026 — ECOPHOT
 * ============================================================
 *  Matériel :
 *    - ESP32-WROOM-32
 *    - Capteur OPT4048 (I²C 0x44)
 *    - OLED SSD1306 128×64 (I²C 0x3C)
 *    - MicroSD (SPI : CLK=18, MISO=19, MOSI=23, CS=4)
 *    - CH340C USB-UART (programmation auto-reset)
 *    - Batterie 18650 + TP4056 + AMS1117-3.3
 *
 *  Bibliothèques requises (Library Manager) :
 *    - SparkFun_OPT4048          (SparkFun Electronics)
 *    - Adafruit_SSD1306          (Adafruit)
 *    - Adafruit GFX Library      (Adafruit)
 *    - SD (built-in Arduino/ESP32)
 *
 *  Licence : MIT — ecophot.fr
 * ============================================================
 *
 *  Fonctionnalités :
 *    - Mesure tristimulus XYZ + W directe
 *    - Photométrie lux (2,15 mlux – 144 klux, 26 bits)
 *    - Coordonnées chromatiques (x,y) CIE 1931
 *    - CCT méthode McCamy (rapide)
 *    - CCT méthode Hernández-Andrés (précise, Newton-Raphson)
 *    - Conversion CIE Lab + calcul ΔE
 *    - Longueur d'onde dominante approximée
 *    - Classification automatique source lumineuse
 *    - Affichage OLED temps réel
 *    - Datalogging CSV sur microSD
 *    - Serveur web WiFi (point d'accès "Colorimeter")
 *    - Calibration avec sauvegarde EEPROM
 *    - Tests répétabilité / linéarité
 *
 *  GPIO assignments :
 *    GPIO 21 → I²C SDA (OPT4048 + OLED)
 *    GPIO 22 → I²C SCL (OPT4048 + OLED)
 *    GPIO 33 → INT OPT4048 (data ready, pull-up 10kΩ)
 *    GPIO 18 → SPI CLK microSD
 *    GPIO 19 → SPI MISO microSD
 *    GPIO 23 → SPI MOSI microSD
 *    GPIO  4 → SD CS (pull-up 10kΩ)
 *    GPIO 25 → BTN1 MODE
 *    GPIO 13 → BTN2 SELECT (pull-up 10kΩ)
 *    GPIO 14 → BTN3 HOLD (pull-up 10kΩ)
 *    GPIO 34 → ADC tension batterie (input-only)
 *    GPIO  2 → LED status bleue (strapping, LOW au boot)
 *    GPIO 26 → LED charge rouge
 *    GPIO  1 → U0TXD → CH340C RXD + J3 debug
 *    GPIO  3 → U0RXD → CH340C TXD + J3 debug
 *    GPIO  0 → BOOT (contrôlé par circuit auto-reset Q1/Q2)
 * ============================================================
 */

#include <Arduino.h>
#include <Wire.h>
#include <SPI.h>
#include <SD.h>
#include <WiFi.h>
#include <WebServer.h>
#include <EEPROM.h>
#include <math.h>

#include <SparkFun_OPT4048.h>
#include <Adafruit_SSD1306.h>
#include <Adafruit_GFX.h>

// ============================================================
//  Définitions matérielles
// ============================================================
#define SD_CS_PIN     4
#define OPT_INT_PIN  33
#define BTN1_MODE    25
#define BTN2_SELECT  13
#define BTN3_HOLD    14
#define LED_STATUS    2
#define LED_CHARGE   26
#define BAT_ADC_PIN  34

// OLED
#define SCREEN_WIDTH  128
#define SCREEN_HEIGHT  64
#define OLED_RESET     -1

// WiFi AP
#define WIFI_SSID     "Colorimeter"
#define WIFI_PASSWORD "color123"

// EEPROM
#define EEPROM_SIZE   64
#define CAL_ADDR       0   // Adresse calibration dans EEPROM

// ============================================================
//  Structures de données
// ============================================================
struct ColorMeasurement {
    float X, Y, Z, W;
    float lux;
    float x, y;
    float u_prime, v_prime;
    float CCT;
    float dominant_wavelength;
    float purity;
    uint32_t timestamp;
};

struct LabColor {
    float L;   // Luminosité (0–100)
    float a;   // Rouge↔Vert (−128 à +127)
    float b;   // Jaune↔Bleu (−128 à +127)
};

struct CalibrationData {
    float lux_factor;
    float X_gain, Y_gain, Z_gain;
    float X_offset, Y_offset, Z_offset;
    uint32_t magic;   // 0xCAFECAFE si données valides
};

// ============================================================
//  Variables globales
// ============================================================
OPT4048         colorSensor;
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
WebServer       server(80);
CalibrationData cal;
bool            sdReady    = false;
bool            wifiActive = false;

// ============================================================
//  Calibration — EEPROM
// ============================================================
void loadCalibration() {
    EEPROM.begin(EEPROM_SIZE);
    EEPROM.get(CAL_ADDR, cal);
    if (cal.magic != 0xCAFECAFE) {
        // Valeurs par défaut (pas de calibration)
        cal.lux_factor = 1.0f;
        cal.X_gain = cal.Y_gain = cal.Z_gain = 1.0f;
        cal.X_offset = cal.Y_offset = cal.Z_offset = 0.0f;
    }
}

void saveCalibration() {
    cal.magic = 0xCAFECAFE;
    EEPROM.put(CAL_ADDR, cal);
    EEPROM.commit();
}

// ============================================================
//  Initialisation capteur OPT4048
// ============================================================
void initOPT4048() {
    Wire.begin(21, 22);  // SDA=GPIO21, SCL=GPIO22

    if (!colorSensor.begin(0x44)) {
        Serial.println("[OPT4048] ERREUR: capteur non détecté!");
        display.clearDisplay();
        display.setCursor(0, 0);
        display.println("OPT4048 absent!");
        display.display();
        while (1) { delay(500); digitalWrite(LED_STATUS, !digitalRead(LED_STATUS)); }
    }

    colorSensor.setConversionTime(OPT4048_CONVERSION_TIME_100MS);
    colorSensor.setRange(OPT4048_RANGE_AUTO);
    colorSensor.setOperatingMode(OPT4048_CONTINUOUS_MODE);

    // Interruption data ready sur GPIO33
    colorSensor.setInterruptConfig(
        OPT4048_CHANNEL_Y,
        OPT4048_INT_THRESHOLD_HIGH,
        1000
    );

    Serial.println("[OPT4048] Initialisé OK — adresse 0x44");
}

// ============================================================
//  Acquisition mesure brute
// ============================================================
ColorMeasurement acquireMeasurement() {
    ColorMeasurement data;

    data.X = (colorSensor.getX() + cal.X_offset) * cal.X_gain;
    data.Y = (colorSensor.getY() + cal.Y_offset) * cal.Y_gain;
    data.Z = (colorSensor.getZ() + cal.Z_offset) * cal.Z_gain;
    data.W = colorSensor.getW();
    data.lux = colorSensor.getLux() * cal.lux_factor;
    data.timestamp = millis();

    return data;
}

// ============================================================
//  Calculs colorimétriques
// ============================================================

// Coordonnées chromatiques xy (CIE 1931)
void calculateChromaticity(ColorMeasurement &data) {
    float sum = data.X + data.Y + data.Z;
    if (sum > 0.001f) {
        data.x = data.X / sum;
        data.y = data.Y / sum;
    } else {
        data.x = 0.3333f;
        data.y = 0.3333f;
    }

    // Coordonnées u'v' (CIE 1976)
    float denom = -2.0f * data.x + 12.0f * data.y + 3.0f;
    if (fabs(denom) > 0.0001f) {
        data.u_prime = 4.0f * data.x / denom;
        data.v_prime = 9.0f * data.y / denom;
    } else {
        data.u_prime = 0.2105f;
        data.v_prime = 0.4737f;
    }
}

// Locus de Planck (chromacité du corps noir à température T)
void plankianLocus(float T, float &x, float &y) {
    if (T >= 1667.0f && T <= 4000.0f) {
        x = -0.2661239e9f / (T*T*T)
            - 0.2343589e6f / (T*T)
            + 0.8776956e3f / T
            + 0.179910f;
    } else if (T > 4000.0f && T <= 25000.0f) {
        x = -3.0258469e9f / (T*T*T)
            + 2.1070379e6f / (T*T)
            + 0.2226347e3f / T
            + 0.240390f;
    } else {
        x = 0.3333f;
        y = 0.3333f;
        return;
    }

    if (T >= 1667.0f && T <= 2222.0f) {
        y = -1.1063814f*x*x*x - 1.34811020f*x*x + 2.18555832f*x - 0.20219683f;
    } else if (T > 2222.0f && T <= 4000.0f) {
        y = -0.9549476f*x*x*x - 1.37418593f*x*x + 2.09137015f*x - 0.16748867f;
    } else {
        y =  3.0817580f*x*x*x - 5.87338670f*x*x + 3.75112997f*x - 0.37001483f;
    }
}

// CCT — méthode McCamy (rapide, ±2% sur 2 000–12 000 K)
float calculateCCT_McCamy(float x, float y) {
    float n = (x - 0.3320f) / (y - 0.1858f);
    return -449.0f * n*n*n
           + 3525.0f * n*n
           - 6823.3f * n
           + 5520.33f;
}

// CCT — méthode Hernández-Andrés avec itération Newton-Raphson (précise)
float calculateCCT_Accurate(float x, float y) {
    const float xe = 0.3366f, ye = 0.1735f;
    const float A0 = -949.86315f, A1 = 6253.80338f, t1 = 0.92159f;
    const float A2 = 28.70599f,   t2 = 0.20039f;
    const float A3 = 0.00004f,    t3 = 0.07125f;

    float n = (x - xe) / (y - ye);
    float CCT = A0 + A1*expf(-n/t1) + A2*expf(-n/t2) + A3*expf(-n/t3);

    // Itération Newton-Raphson (max 5 passes)
    for (int i = 0; i < 5; i++) {
        float xc, yc, xc1, yc1, xc2, yc2;
        plankianLocus(CCT,      xc,  yc);
        plankianLocus(CCT + 10, xc1, yc1);
        plankianLocus(CCT - 10, xc2, yc2);

        float dx = x - xc, dy = y - yc;
        if (sqrtf(dx*dx + dy*dy) < 0.0001f) break;

        float dxdT = (xc1 - xc2) / 20.0f;
        float dydT = (yc1 - yc2) / 20.0f;
        float denom = dxdT*dxdT + dydT*dydT;
        if (denom > 0) CCT += (dx*dxdT + dy*dydT) / denom;
    }
    return CCT;
}

// Conversion XYZ → CIE Lab (illuminant D65)
LabColor XYZ_to_Lab(float X, float Y, float Z) {
    const float Xn = 0.95047f, Yn = 1.00000f, Zn = 1.08883f;
    const float delta = 6.0f / 29.0f;
    const float delta3 = delta * delta * delta;

    auto f = [&](float t) -> float {
        return (t > delta3) ? cbrtf(t) : (t / (3.0f * delta * delta) + 4.0f / 29.0f);
    };

    float fx = f(X / Xn);
    float fy = f(Y / Yn);
    float fz = f(Z / Zn);

    LabColor lab;
    lab.L =  116.0f * fy - 16.0f;
    lab.a =  500.0f * (fx - fy);
    lab.b =  200.0f * (fy - fz);
    return lab;
}

// Distance colorimétrique ΔE (CIE76)
float deltaE(LabColor lab1, LabColor lab2) {
    float dL = lab1.L - lab2.L;
    float da = lab1.a - lab2.a;
    float db = lab1.b - lab2.b;
    return sqrtf(dL*dL + da*da + db*db);
}

// Longueur d'onde dominante approchée (nm)
float calculateDominantWavelength(float x, float y) {
    const float xe = 0.3333f, ye = 0.3333f;
    float theta = atan2f(y - ye, x - xe);
    float lambda;
    if (theta > 0 && theta < 1.0f)
        lambda = 380.0f + (700.0f - 380.0f) * (theta / 1.0f);
    else if (theta < 0)
        lambda = 490.0f + fabsf(theta) * 50.0f;
    else
        lambda = 570.0f + (theta - 1.0f) * 50.0f;
    return lambda;
}

// Classification de la source lumineuse
String classifyLightSource(float CCT) {
    if (CCT < 2000)       return "Bougie";
    else if (CCT < 3000)  return "Incandescent";
    else if (CCT < 4000)  return "Halogene";
    else if (CCT < 5000)  return "Fluor chaud";
    else if (CCT < 6500)  return "Lumiere jour";
    else if (CCT < 10000) return "Ciel couvert";
    else                  return "Ciel bleu";
}

// ============================================================
//  Affichage OLED
// ============================================================
void displayMeasurement(ColorMeasurement &data) {
    display.clearDisplay();
    display.setTextSize(1);
    display.setTextColor(SSD1306_WHITE);

    display.setCursor(0, 0);
    display.print("Lux: ");
    display.print(data.lux, 1);

    display.setCursor(0, 10);
    display.print("CCT: ");
    display.print((int)data.CCT);
    display.print(" K");

    display.setCursor(0, 20);
    display.print("x:");
    display.print(data.x, 4);
    display.setCursor(64, 20);
    display.print("y:");
    display.print(data.y, 4);

    display.setCursor(0, 30);
    display.print("X:");
    display.print((int)data.X);
    display.setCursor(42, 30);
    display.print("Y:");
    display.print((int)data.Y);
    display.setCursor(84, 30);
    display.print("Z:");
    display.print((int)data.Z);

    display.setCursor(0, 40);
    display.print(classifyLightSource(data.CCT));

    display.setCursor(0, 52);
    display.print("t:");
    display.print(data.timestamp / 1000);
    display.print("s");

    display.display();
}

// ============================================================
//  Datalogging microSD
// ============================================================
void initSDCard() {
    SPI.begin(18, 19, 23, SD_CS_PIN);
    if (!SD.begin(SD_CS_PIN)) {
        Serial.println("[SD] Erreur initialisation");
        sdReady = false;
        return;
    }
    sdReady = true;

    // Créer l'en-tête CSV si le fichier n'existe pas
    if (!SD.exists("/colorlog.csv")) {
        File f = SD.open("/colorlog.csv", FILE_WRITE);
        if (f) {
            f.println("timestamp_ms,lux,X,Y,Z,W,x,y,u,v,CCT_McCamy,CCT_Precise,Lab_L,Lab_a,Lab_b,source");
            f.close();
        }
    }
    Serial.println("[SD] Carte OK");
}

void logToSD(ColorMeasurement &data) {
    if (!sdReady) return;
    File f = SD.open("/colorlog.csv", FILE_APPEND);
    if (!f) return;

    LabColor lab = XYZ_to_Lab(data.X, data.Y, data.Z);
    float cct_acc = calculateCCT_Accurate(data.x, data.y);

    f.print(data.timestamp);         f.print(",");
    f.print(data.lux, 4);            f.print(",");
    f.print(data.X, 4);              f.print(",");
    f.print(data.Y, 4);              f.print(",");
    f.print(data.Z, 4);              f.print(",");
    f.print(data.W, 4);              f.print(",");
    f.print(data.x, 5);              f.print(",");
    f.print(data.y, 5);              f.print(",");
    f.print(data.u_prime, 5);        f.print(",");
    f.print(data.v_prime, 5);        f.print(",");
    f.print(data.CCT, 1);            f.print(",");
    f.print(cct_acc, 1);             f.print(",");
    f.print(lab.L, 2);               f.print(",");
    f.print(lab.a, 2);               f.print(",");
    f.print(lab.b, 2);               f.print(",");
    f.println(classifyLightSource(data.CCT));

    f.close();
}

// ============================================================
//  Serveur Web WiFi
// ============================================================
ColorMeasurement lastMeasure;

void handleRoot() {
    String html = R"rawhtml(<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width,initial-scale=1">
<title>Colorimetre OPT4048</title>
<style>
 body{font-family:Arial,sans-serif;max-width:800px;margin:30px auto;padding:0 16px;background:#f5f5f5}
 h1{color:#1a73e8;text-align:center}
 .card{background:#fff;border-radius:12px;padding:20px;margin:16px 0;box-shadow:0 2px 8px rgba(0,0,0,.1)}
 .val{font-size:2rem;font-weight:bold;color:#1a73e8}
 .label{font-size:.85rem;color:#666;margin-bottom:4px}
 .grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(150px,1fr));gap:12px}
 #colorBox{width:100%;height:100px;border-radius:10px;border:1px solid #ddd;margin:12px 0;transition:background .5s}
 button{padding:12px 28px;font-size:1rem;cursor:pointer;background:#1a73e8;color:#fff;border:none;border-radius:8px;margin:4px}
 button:hover{background:#1557b0}
 .stream-on{background:#e53935 !important}
 .source{font-size:1.1rem;font-weight:bold;color:#333;text-align:center;padding:8px}
 .status{font-size:.8rem;color:#aaa;text-align:center}
</style>
</head>
<body>
<h1>Colorimetre Professionnel — OPT4048</h1>
<div style="text-align:center">
 <button onclick="measure()">Mesurer</button>
 <button id="btnStream" onclick="toggleStream()">Stream (500ms)</button>
</div>
<div id="colorBox"></div>
<div class="card source" id="source">--</div>
<div class="card">
 <div class="grid">
  <div><div class="label">Lux</div><div class="val" id="lux">--</div></div>
  <div><div class="label">CCT</div><div class="val" id="cct">-- K</div></div>
  <div><div class="label">x</div><div class="val" id="cx">--</div></div>
  <div><div class="label">y</div><div class="val" id="cy">--</div></div>
 </div>
</div>
<div class="card">
 <div class="grid">
  <div><div class="label">X</div><div class="val" id="X">--</div></div>
  <div><div class="label">Y</div><div class="val" id="Y">--</div></div>
  <div><div class="label">Z</div><div class="val" id="Z">--</div></div>
  <div><div class="label">W</div><div class="val" id="W">--</div></div>
 </div>
</div>
<div class="card">
 <div class="grid">
  <div><div class="label">u'</div><div class="val" id="u">--</div></div>
  <div><div class="label">v'</div><div class="val" id="v">--</div></div>
 </div>
</div>
<div class="status" id="status">Prêt</div>
<script>
function measure(){
 document.getElementById('status').textContent='Mesure en cours...';
 fetch('/measure').then(r=>r.json()).then(d=>{
  document.getElementById('lux').textContent=d.lux.toFixed(2);
  document.getElementById('cct').textContent=Math.round(d.CCT)+' K';
  document.getElementById('cx').textContent=d.x.toFixed(4);
  document.getElementById('cy').textContent=d.y.toFixed(4);
  document.getElementById('X').textContent=d.X.toFixed(2);
  document.getElementById('Y').textContent=d.Y.toFixed(2);
  document.getElementById('Z').textContent=d.Z.toFixed(2);
  document.getElementById('W').textContent=d.W.toFixed(2);
  document.getElementById('u').textContent=d.u.toFixed(4);
  document.getElementById('v').textContent=d.v.toFixed(4);
  document.getElementById('source').textContent=d.source;
  let r=3.2406*d.X-1.5372*d.Y-0.4986*d.Z;
  let g=-0.9689*d.X+1.8758*d.Y+0.0415*d.Z;
  let b=0.0557*d.X-0.2040*d.Y+1.0570*d.Z;
  r=Math.min(255,Math.round(Math.pow(Math.max(0,r),1/2.2)*255));
  g=Math.min(255,Math.round(Math.pow(Math.max(0,g),1/2.2)*255));
  b=Math.min(255,Math.round(Math.pow(Math.max(0,b),1/2.2)*255));
  document.getElementById('colorBox').style.background='rgb('+r+','+g+','+b+')';
  document.getElementById('status').textContent='Mesure OK — '+new Date().toLocaleTimeString();
 }).catch(e=>document.getElementById('status').textContent='Erreur: '+e);
}
let streaming=false,iv;
function toggleStream(){
 streaming=!streaming;
 const btn=document.getElementById('btnStream');
 if(streaming){iv=setInterval(measure,500);btn.textContent='Arrêter';btn.classList.add('stream-on');}
 else{clearInterval(iv);btn.textContent='Stream (500ms)';btn.classList.remove('stream-on');}
}
</script>
</body>
</html>)rawhtml";

    server.send(200, "text/html", html);
}

void handleMeasure() {
    ColorMeasurement data = acquireMeasurement();
    calculateChromaticity(data);
    data.CCT = calculateCCT_McCamy(data.x, data.y);
    data.dominant_wavelength = calculateDominantWavelength(data.x, data.y);
    lastMeasure = data;

    String json = "{";
    json += "\"lux\":"  + String(data.lux, 3)      + ",";
    json += "\"X\":"    + String(data.X, 3)         + ",";
    json += "\"Y\":"    + String(data.Y, 3)         + ",";
    json += "\"Z\":"    + String(data.Z, 3)         + ",";
    json += "\"W\":"    + String(data.W, 3)         + ",";
    json += "\"x\":"    + String(data.x, 5)         + ",";
    json += "\"y\":"    + String(data.y, 5)         + ",";
    json += "\"u\":"    + String(data.u_prime, 5)   + ",";
    json += "\"v\":"    + String(data.v_prime, 5)   + ",";
    json += "\"CCT\":"  + String(data.CCT, 1)       + ",";
    json += "\"source\":\"" + classifyLightSource(data.CCT) + "\"";
    json += "}";

    server.send(200, "application/json", json);
    logToSD(data);
}

void handleLog() {
    if (!sdReady || !SD.exists("/colorlog.csv")) {
        server.send(404, "text/plain", "Pas de log disponible");
        return;
    }
    File f = SD.open("/colorlog.csv", FILE_READ);
    server.streamFile(f, "text/csv");
    f.close();
}

void setupWebServer() {
    WiFi.softAP(WIFI_SSID, WIFI_PASSWORD);
    server.on("/",       handleRoot);
    server.on("/measure",handleMeasure);
    server.on("/log.csv",handleLog);
    server.begin();
    wifiActive = true;
    Serial.print("[WiFi] AP: ");
    Serial.print(WIFI_SSID);
    Serial.print(" — IP: ");
    Serial.println(WiFi.softAPIP());
}

// ============================================================
//  Calibration interactive (via port série)
// ============================================================
float readFloatSerial() {
    while (!Serial.available()) delay(10);
    return Serial.parseFloat();
}

void performCalibration() {
    Serial.println("\n=== CALIBRATION OPT4048 ===");
    Serial.println("Placer sous source de référence calibrée...");
    delay(5000);

    float Xs = 0, Ys = 0, Zs = 0;
    const int N = 100;
    for (int i = 0; i < N; i++) {
        ColorMeasurement d = acquireMeasurement();
        Xs += d.X; Ys += d.Y; Zs += d.Z;
        delay(10);
    }
    Xs /= N; Ys /= N; Zs /= N;

    Serial.print("Entrer lux référence: ");
    float lux_ref = readFloatSerial();
    cal.lux_factor = lux_ref / (Ys > 0 ? Ys : 1.0f);

    Serial.print("\nEntrer CCT référence (K): ");
    float cct_ref = readFloatSerial();
    (void)cct_ref;  // utilisé pour ajustement colorimétrique futur

    saveCalibration();
    Serial.println("\n[CAL] Calibration sauvegardée en EEPROM.");
}

// ============================================================
//  Tests de validation
// ============================================================
void testRepeatability() {
    const int N = 50;
    float values[N];
    Serial.println("[TEST] Répétabilité — N=50 mesures lux");

    for (int i = 0; i < N; i++) {
        ColorMeasurement d = acquireMeasurement();
        calculateChromaticity(d);
        d.CCT = calculateCCT_McCamy(d.x, d.y);
        values[i] = d.lux;
        delay(100);
    }

    float mean = 0;
    for (int i = 0; i < N; i++) mean += values[i];
    mean /= N;

    float variance = 0;
    for (int i = 0; i < N; i++) variance += (values[i] - mean) * (values[i] - mean);
    float std_dev = sqrtf(variance / N);
    float cv = (mean > 0) ? (std_dev / mean * 100.0f) : 0;

    Serial.printf("[TEST] Moyenne=%.2f lux  Ecart-type=%.4f  CV=%.3f%%\n",
                  mean, std_dev, cv);
}

// ============================================================
//  Application — Calibration écran (D65)
// ============================================================
void calibrateMonitor() {
    Serial.println("[MONITOR] Calibration — Mode D65");
    Serial.println("  Afficher un blanc 100% sur l'écran...");
    delay(3000);

    ColorMeasurement white = acquireMeasurement();
    calculateChromaticity(white);

    const float x_target = 0.3127f;
    const float y_target = 0.3290f;
    float dx = x_target - white.x;
    float dy = y_target - white.y;

    Serial.printf("[MONITOR] Blanc mesuré : x=%.4f  y=%.4f\n", white.x, white.y);
    Serial.printf("[MONITOR] Écart D65    : dx=%.4f  dy=%.4f\n", dx, dy);

    if      (dx >  0.01f) Serial.println("[MONITOR] → Augmenter gain ROUGE");
    else if (dx < -0.01f) Serial.println("[MONITOR] → Réduire gain ROUGE");
    if      (dy >  0.01f) Serial.println("[MONITOR] → Augmenter gain VERT");
    else if (dy < -0.01f) Serial.println("[MONITOR] → Réduire gain VERT");
}

// ============================================================
//  Binning LED
// ============================================================
enum LEDBin { WARM_WHITE, NEUTRAL_WHITE, COOL_WHITE, DAYLIGHT, OUT_OF_SPEC };

LEDBin classifyLED(float CCT) {
    if (CCT >= 2700 && CCT <= 3000) return WARM_WHITE;
    if (CCT >= 4000 && CCT <= 4500) return NEUTRAL_WHITE;
    if (CCT >= 5000 && CCT <= 6500) return COOL_WHITE;
    if (CCT >  6500)                return DAYLIGHT;
    return OUT_OF_SPEC;
}

String ledBinName(LEDBin bin) {
    switch (bin) {
        case WARM_WHITE:    return "Warm White (2700-3000K)";
        case NEUTRAL_WHITE: return "Neutral White (4000-4500K)";
        case COOL_WHITE:    return "Cool White (5000-6500K)";
        case DAYLIGHT:      return "Daylight (6500K+)";
        default:            return "Hors spec";
    }
}

// ============================================================
//  Lecture tension batterie
// ============================================================
float readBattery() {
    // Pont diviseur 100kΩ/100kΩ → Vbat/2 sur GPIO34
    // ADC ESP32 12 bits, Vref≈3.3V (non linéaire, calibration recommandée)
    int raw = analogRead(BAT_ADC_PIN);
    float v = (raw / 4095.0f) * 3.3f * 2.0f;
    return v;
}

// ============================================================
//  Setup
// ============================================================
void setup() {
    Serial.begin(115200);
    Serial.println("\n=== Colorimetre OPT4048 v2.1 — ECOPHOT ===");

    // GPIO
    pinMode(LED_STATUS,  OUTPUT);
    pinMode(LED_CHARGE,  OUTPUT);
    pinMode(BTN1_MODE,   INPUT_PULLUP);
    pinMode(BTN2_SELECT, INPUT_PULLUP);
    pinMode(BTN3_HOLD,   INPUT_PULLUP);
    digitalWrite(LED_STATUS, LOW);

    // EEPROM & calibration
    loadCalibration();

    // OLED
    if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
        Serial.println("[OLED] ERREUR initialisation!");
    } else {
        display.clearDisplay();
        display.setTextSize(1);
        display.setTextColor(SSD1306_WHITE);
        display.setCursor(0, 0);
        display.println("OPT4048 v2.1");
        display.println("ECOPHOT");
        display.println("Initialisation...");
        display.display();
    }

    // OPT4048
    initOPT4048();
    digitalWrite(LED_STATUS, HIGH);

    // MicroSD
    initSDCard();

    // WiFi + serveur web
    setupWebServer();

    display.clearDisplay();
    display.setCursor(0, 0);
    display.println("Pret!");
    display.print("WiFi: ");
    display.println(WIFI_SSID);
    display.print("IP: ");
    display.println(WiFi.softAPIP());
    display.display();

    Serial.println("[INIT] Démarrage complet. Prêt.");
}

// ============================================================
//  Loop principal
// ============================================================
void loop() {
    server.handleClient();

    static uint32_t lastMeasMs = 0;
    static uint32_t lastDispMs = 0;

    // Mesure toutes les 500 ms
    if (millis() - lastMeasMs > 500) {
        lastMeasMs = millis();

        lastMeasure = acquireMeasurement();
        calculateChromaticity(lastMeasure);
        lastMeasure.CCT = calculateCCT_McCamy(lastMeasure.x, lastMeasure.y);
        lastMeasure.dominant_wavelength = calculateDominantWavelength(lastMeasure.x, lastMeasure.y);
    }

    // Affichage OLED toutes les 300 ms
    if (millis() - lastDispMs > 300) {
        lastDispMs = millis();
        displayMeasurement(lastMeasure);
    }

    // Bouton MODE (GPIO25) — log manuel + Serial
    if (digitalRead(BTN1_MODE) == LOW) {
        delay(50);
        if (digitalRead(BTN1_MODE) == LOW) {
            logToSD(lastMeasure);
            LabColor lab = XYZ_to_Lab(lastMeasure.X, lastMeasure.Y, lastMeasure.Z);
            float cct_acc = calculateCCT_Accurate(lastMeasure.x, lastMeasure.y);
            Serial.printf("[LOG] lux=%.2f  CCT_mc=%.0f K  CCT_acc=%.0f K  x=%.4f  y=%.4f  "
                          "X=%.2f Y=%.2f Z=%.2f  Lab(%.1f,%.1f,%.1f)  src=%s\n",
                          lastMeasure.lux, lastMeasure.CCT, cct_acc,
                          lastMeasure.x, lastMeasure.y,
                          lastMeasure.X, lastMeasure.Y, lastMeasure.Z,
                          lab.L, lab.a, lab.b,
                          classifyLightSource(lastMeasure.CCT).c_str());
            while (digitalRead(BTN1_MODE) == LOW) delay(10); // attendre relâche
        }
    }

    // Bouton SELECT (GPIO13) — test répétabilité sur appui long (>2s)
    if (digitalRead(BTN2_SELECT) == LOW) {
        uint32_t t0 = millis();
        while (digitalRead(BTN2_SELECT) == LOW) delay(10);
        if (millis() - t0 > 2000) testRepeatability();
    }

    // Commandes série interactive
    if (Serial.available()) {
        char c = Serial.read();
        if (c == 'c' || c == 'C') performCalibration();
        if (c == 'm' || c == 'M') calibrateMonitor();
        if (c == 't' || c == 'T') testRepeatability();
        if (c == 'b' || c == 'B') {
            // Binning LED sur mesure courante
            LEDBin bin = classifyLED(lastMeasure.CCT);
            Serial.print("[BIN] ");
            Serial.println(ledBinName(bin));
        }
        if (c == 'v' || c == 'V') {
            Serial.printf("[BAT] Vbat=%.2f V\n", readBattery());
        }
        if (c == '?') {
            Serial.println("Commandes: c=Calibrer  m=MonitorD65  t=TestRep  b=Binning  v=Vbat");
        }
    }
}