readRaw() const;;
begin(115200);;
println("Erreur d'initialisation du bouton !");;
while (1);;
update();;
println("Bouton appuye");;
println("Bouton relache");;

                    

            return _status;
uint8_t _pin;
bool _activeLow;
long _debounceMs;

                    

        #pragma once
#include <Arduino.h>
#include "../StatusDevice.h"

/**
 * @namespace crepp::tools
 * @brief Outils utilitaires de la bibliothèque CREPP.
 */
namespace crepp::tools {

/**
 * @class Buttons
 * @brief Gestionnaire de boutons physiques (Up / Down).
 *
 * @details
 * Cette classe permet de gérer simplement un bouton USER (GP02) avec
 * anti-rebond logiciel et détection de front (appui / relâchement).
 * Peut être instanciée plusieurs fois pour gérer plusieurs boutons
 * (ex: un bouton "Up" et un bouton "Down").
 *
 * Fonctionnalités :
 * - initialisation
 * - lecture de l'état (appuyé / relâché)
 * - détection de front (appui unique, relâchement unique)
 * - anti-rebond logiciel configurable
 *
 * @badge tool
 * @badge stable
 */
class Buttons {
public:
    /**
     * @brief Constructeur du gestionnaire de boutons.
     *
     * @param pin Broche du MCU reliée au bouton (GP02 par défaut, bouton USER)
     * @param activeLow true si le bouton relie la broche à la masse quand
     *        il est appuyé (pull-up interne utilisée), false s'il relie
     *        la broche au +V (pull-down nécessaire côté câblage)
     * @param debounceMs Durée de l'anti-rebond en millisecondes
     */
    explicit Buttons(uint8_t pin = 2, bool activeLow = true, unsigned long debounceMs = 30);

    /**
     * @brief Initialise la broche du bouton (mode entrée, pull-up/pull-down).
     * @return true si l'initialisation a réussi
     */
    bool begin();

    /**
     * @brief Met à jour l'état interne du bouton (anti-rebond, détection de front).
     *        A appeler à chaque tour de loop().
     */
    void update();

    /**
     * @brief Indique si le bouton est actuellement appuyé (état stable, anti-rebond appliqué).
     * @return true si le bouton est appuyé
     */
    bool isPressed() const;

    /**
     * @brief Indique si un appui vient d'être détecté depuis le dernier appel.
     *        Consomme l'évènement : un second appel immédiat renverra false
     *        tant qu'un nouvel appui n'a pas eu lieu.
     * @return true si un front montant (appui) a été détecté
     */
    bool wasPressed();

    /**
     * @brief Indique si un relâchement vient d'être détecté depuis le dernier appel.
     *        Consomme l'évènement, comme wasPressed().
     * @return true si un front descendant (relâchement) a été détecté
     */
    bool wasReleased();

    /**
     * @brief Retourne l'état du périphérique.
     * @return DEVICE_OK si begin() a réussi, DEVICE_ERROR_INIT sinon.
     */
    StatusDevice getStatus() const { return _status; }

private:
    uint8_t _pin;
    bool _activeLow;
    unsigned long _debounceMs;

    bool _stableState   = false;
    bool _lastRawState  = false;
    unsigned long _lastChangeTime = 0;

    bool _pressedFlag  = false;
    bool _releasedFlag = false;

    bool _initialized = false;
    StatusDevice _status = StatusDevice::DEVICE_ERROR_INIT;

    bool readRaw() const;
};

/*
@example

@include
#include <crepp/tools/Buttons.h>
@end_include

@instance
crepp::tools::Buttons userButton; // GP02 par défaut
@end_instance

@setup
  Serial.begin(115200);

  if (!userButton.begin()) {
      Serial.println("Erreur d'initialisation du bouton !");
      while (1);
  }
@end_setup

@loop
  userButton.update();

  if (userButton.wasPressed()) {
      Serial.println("Bouton appuye");
  }

  if (userButton.wasReleased()) {
      Serial.println("Bouton relache");
  }
@end_loop

@end_example
*/

} // namespace crepp::tools