rawToVolts(int16_t raw);;
rawToMilliVolts(int16_t raw);;
milliVoltsToRaw(float milliVolts);;
applyConfiguration();;
onAlertInterrupt();;
adc(ADS1115_ADDRESS);;
begin(115200);;
println("Erreur d'initialisation ADS1115");;
while (1);;
printInfo();;
for (uint8_t ch = 0; ch < 4; ch++) {;
print("CH");;
print(ch);;
print(" : ");;
println(" mV");;
println("------------------");;
delay(1000);;
adc(ADS1115_ADDRESS);;
begin(115200);;
while (1);;
adc(ADS1115_ADDRESS);;
begin(115200);;
while (1);;
print("Seuil depasse : ");;
println(" mV");;

                    

            Adafruit_ADS1115 _ads;
bool _dataReadyFlag;

                    

        #pragma once

#include <Arduino.h>
#include <Adafruit_ADS1X15.h>

#include "../StatusDevice.h"

namespace crepp::drivers {

enum ADS1115_DataRate {
    ADS1115_DR_8SPS    = 0x0000,
    ADS1115_DR_16SPS   = 0x0020,
    ADS1115_DR_32SPS   = 0x0040,
    ADS1115_DR_64SPS   = 0x0060,
    ADS1115_DR_128SPS  = 0x0080,
    ADS1115_DR_250SPS  = 0x00A0,
    ADS1115_DR_475SPS  = 0x00C0,
    ADS1115_DR_860SPS  = 0x00E0
};

/**
 * @class ADS1115_Handler
 * @brief Pilote du convertisseur analogique-numérique I2C ADS1115 (4 canaux, 16 bits).
 *
 * @badge driver
 * @badge stable
 *
 * Fonctionnalités :
 * - Initialisation avec gain et fréquence d'échantillonnage configurables
 * - Lecture brute, en volts ou en millivolts sur chacun des 4 canaux
 * - Compteurs de lectures / erreurs pour le diagnostic
 */
class ADS1115_Handler {
public:
    /**
     * @brief Construit le handler avec l'adresse I2C par défaut (0x48).
     */
    ADS1115_Handler();

    /**
     * @brief Construit le handler pour une adresse I2C spécifique.
     * @param address Adresse I2C du module ADS1115 (dépend du câblage ADDR)
     */
    explicit ADS1115_Handler(uint8_t address);
    ~ADS1115_Handler() = default;

    /**
     * @brief Initialise le composant avec le gain et la fréquence par défaut.
     * @return true si l'initialisation a réussi, false sinon
     */
    bool begin();

    /**
     * @brief Initialise le composant avec un gain et une fréquence d'échantillonnage donnés.
     * @param gain Gain de l'ADS1115 (ex: GAIN_TWOTHIRDS pour ±6.144V)
     * @param dataRate Fréquence d'échantillonnage (défaut: ADS1115_DR_128SPS)
     * @return true si l'initialisation a réussi, false sinon
     */
    bool begin(adsGain_t gain, ADS1115_DataRate dataRate = ADS1115_DR_128SPS);

    /**
     * @brief Lit la valeur brute (16 bits signés) d'un canal.
     * @param channel Numéro du canal à lire (0 à 3)
     * @return Valeur brute lue par le convertisseur
     */
    int16_t read(uint8_t channel);

    /**
     * @brief Lit la tension d'un canal, convertie en millivolts.
     * @param channel Numéro du canal à lire (0 à 3)
     * @return Tension mesurée en mV
     */
    float readMilliVolts(uint8_t channel);

    /**
     * @brief Lit la tension d'un canal, convertie en volts.
     * @param channel Numéro du canal à lire (0 à 3)
     * @return Tension mesurée en V
     */
    float readVolts(uint8_t channel);

    /**
     * @brief Change le gain (donc la pleine échelle) du convertisseur.
     * @param newGain Nouveau gain à appliquer
     */
    void setGain(adsGain_t newGain);

    /**
     * @brief Change la fréquence d'échantillonnage du convertisseur.
     * @param newDataRate Nouvelle fréquence d'échantillonnage
     */
    void setDataRate(ADS1115_DataRate newDataRate);

    /**
     * @brief Change l'adresse I2C utilisée pour communiquer avec le module.
     * @param address Nouvelle adresse I2C
     */
    void setAddress(uint8_t address);

    /**
     * @brief Indique si begin() a été appelé avec succès.
     * @return true si le composant est initialisé
     */
    bool isInitialized() const;

    /**
     * @brief Retourne l’état courant du périphérique
     */
    StatusDevice getStatus() const;

    /// Gain actuellement configuré
    adsGain_t getGain() const;
    /// Adresse I2C actuellement configurée
    uint8_t getAddress() const;
    /// Fréquence d'échantillonnage actuellement configurée
    ADS1115_DataRate getDataRate() const;
    /// Nombre total de lectures effectuées depuis begin()
    uint32_t getReadCount() const;
    /// Nombre total d'erreurs de lecture rencontrées depuis begin()
    uint32_t getErrorCount() const;

    /**
     * @brief Affiche sur le port série la configuration courante (adresse, gain, débit).
     */
    void printInfo();

    /**
     * @brief Affiche sur le port série la tension mesurée sur les 4 canaux.
     */
    void printAllChannels();

    /**
     * @brief Configure une conversion continue sur un canal, avec la broche
     *        ALERT/RDY du module utilisée comme comparateur matériel : elle
     *        s'active (niveau bas) dès que la valeur brute dépasse le seuil
     *        donné. Mode "traditionnel" et verrouillé (latch) : le pin reste
     *        actif jusqu'à ce que la valeur soit lue (cf. getLastConversion()).
     * @param channel Canal à convertir en continu (0 à 3)
     * @param alertPin Broche du MCU reliée à la sortie ALERT/RDY du module
     * @param rawThreshold Seuil brut (16 bits signés) déclenchant l'alerte.
     *        Laisser à 0 (valeur par défaut) pour un déclenchement quasi
     *        systématique à chaque conversion (utile en lecture "polling"
     *        non bloquante sans réel seuil de tension).
     * @return true si la configuration a réussi
     */
    bool beginContinuous(uint8_t channel, uint8_t alertPin, int16_t rawThreshold = 0);

    /**
     * @brief Equivalent de beginContinuous(), mais le seuil est exprimé
     *        directement en millivolts (converti en valeur brute selon le
     *        gain courant du convertisseur).
     * @param channel Canal à surveiller (0 à 3)
     * @param alertPin Broche du MCU reliée à ALERT/RDY
     * @param thresholdMilliVolts Seuil de tension déclenchant l'alerte (mV)
     * @return true si la configuration a réussi
     */
    bool beginThresholdAlert(uint8_t channel, uint8_t alertPin, float thresholdMilliVolts);

    /**
     * @brief Indique si une nouvelle conversion est disponible depuis le
     *        dernier appel (mode continu uniquement). Consomme le drapeau :
     *        un second appel immédiat renverra false tant qu'aucune nouvelle
     *        conversion n'est arrivée.
     * @return true si une nouvelle donnée est prête à être lue
     */
    bool dataReady();

    /**
     * @brief Récupère la dernière valeur brute convertie en mode continu.
     * @return Valeur brute (16 bits signés), ou 0 si le mode continu n'est pas actif
     */
    int16_t getLastConversion();

    /**
     * @brief Récupère la dernière valeur convertie en mode continu, en millivolts.
     */
    float getLastConversionMilliVolts();

    /**
     * @brief Indique si le mode continu (piloté par ALERT/RDY) est actif.
     */
    bool isContinuousMode() const;

private:
    Adafruit_ADS1115 _ads;

    uint8_t _address = 0x48;
    adsGain_t _gain = GAIN_TWOTHIRDS;
    ADS1115_DataRate _dataRate = ADS1115_DR_128SPS;

    uint32_t _readCount = 0;
    uint32_t _errorCount = 0;
    bool _initialized = false;

    StatusDevice _status = StatusDevice::DEVICE_ERROR_INIT;

    /// Convertit une valeur brute en volts, selon le gain courant
    float rawToVolts(int16_t raw);
    /// Convertit une valeur brute en millivolts, selon le gain courant
    float rawToMilliVolts(int16_t raw);
    /// Convertit une tension en millivolts vers la valeur brute correspondante, selon le gain courant
    int16_t milliVoltsToRaw(float milliVolts);
    /// Applique au composant physique la configuration courante (gain, débit)
    bool applyConfiguration();

    uint8_t _alertPin = 255;
    uint8_t _continuousChannel = 0;
    bool _continuousMode = false;

    // Note : ce drapeau est statique, donc partagé par toutes les instances.
    // Une seule instance à la fois peut utiliser le mode continu piloté par
    // interruption (limitation acceptable : un seul ADS1115 par projet dans
    // la grande majorité des cas). Pour plusieurs modules simultanés en
    // mode continu, il faudrait un tableau de drapeaux indexé par broche.
    static volatile bool _dataReadyFlag;
    static void onAlertInterrupt();
};

/*
@example

@include
#include <crepp/drivers/ADS1115_Handler.h>
@end_include

@macro
#define ADS1115_ADDRESS 0x48
@end_macro

@instance
crepp::drivers::ADS1115_Handler adc(ADS1115_ADDRESS);
@end_instance

@setup
  Serial.begin(115200);

  if (!adc.begin(GAIN_TWOTHIRDS, ADS1115_DR_128SPS)) {
      Serial.println("Erreur d'initialisation ADS1115");
      while (1);
  }

  adc.printInfo();
@end_setup

@loop
  for (uint8_t ch = 0; ch < 4; ch++) {
      Serial.print("CH");
      Serial.print(ch);
      Serial.print(" : ");
      Serial.print(adc.readMilliVolts(ch));
      Serial.println(" mV");
  }

  Serial.println("------------------");
  delay(1000);
@end_loop

@end_example

@example
// Variante A : lecture non bloquante d'un seul canal, sans vrai seuil
// (ALERT/RDY s'active à quasiment chaque conversion, utile en polling)

@include
#include <crepp/drivers/ADS1115_Handler.h>
@end_include

@macro
#define ADS1115_ADDRESS 0x48
#define ADS1115_ALERT_PIN 13
#define ADS1115_CHANNEL 0
@end_macro

@instance
crepp::drivers::ADS1115_Handler adc(ADS1115_ADDRESS);
@end_instance

@setup
  Serial.begin(115200);

  if (!adc.beginContinuous(ADS1115_CHANNEL, ADS1115_ALERT_PIN)) {
      Serial.println("Erreur d'initialisation ADS1115 (mode continu)");
      while (1);
  }
@end_setup

@loop
  if (adc.dataReady()) {
      Serial.println(adc.getLastConversionMilliVolts());
  }
@end_loop

@end_example

@example
// Variante B : vraie alerte sur seuil de tension (ex: 2500 mV)
// ALERT/RDY ne s'active que lorsque la tension dépasse ce seuil.

@include
#include <crepp/drivers/ADS1115_Handler.h>
@end_include

@macro
#define ADS1115_ADDRESS 0x48
#define ADS1115_ALERT_PIN 13
#define ADS1115_CHANNEL 0
#define THRESHOLD_MV 2500.0f
@end_macro

@instance
crepp::drivers::ADS1115_Handler adc(ADS1115_ADDRESS);
@end_instance

@setup
  Serial.begin(115200);

  if (!adc.beginThresholdAlert(ADS1115_CHANNEL, ADS1115_ALERT_PIN, THRESHOLD_MV)) {
      Serial.println("Erreur d'initialisation ADS1115 (seuil)");
      while (1);
  }
@end_setup

@loop
  if (adc.dataReady()) {
      Serial.print("Seuil depasse : ");
      Serial.print(adc.getLastConversionMilliVolts());
      Serial.println(" mV");
  }
@end_loop

@end_example
*/

} // namespace crepp::drivers