applySpeed(int8_t speed);;
begin(115200);;
begin(L293D_IN1A, L293D_IN2A, L293D_ENA,
              L293D_IN1B, L293D_IN2B, L293D_ENB);;
begin(l293d, crepp::drivers::L293D_Channel::CHANNEL_A);;
begin(l293d, crepp::drivers::L293D_Channel::CHANNEL_B, true);;
setRampRate(15);;
setRampRate(15);;
setSpeed(100);;
setSpeed(100);;
update();;
update();;
delay(20);;

                    

            return _targetSpeed;
return _currentSpeed;
return _state;
return _initialized;
return _status;

                    

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

namespace crepp::tools {

using crepp::drivers::L293D_Channel;
using crepp::drivers::L293D_Handler;

/**
 * @brief Etat courant d'un Motor_Driver.
 */
enum class MotorState : uint8_t {
    STOPPED = 0, ///< Moteur à l'arrêt (roue libre)
    RUNNING = 1, ///< Moteur en mouvement (vitesse != 0)
    BRAKING = 2  ///< Freinage actif en cours
};

/*
 * =========================
 * Tool: Motor_Driver
 * -------------------------
 * Abstraction haut niveau d'un moteur DC piloté au travers d'un
 * canal d'un crepp::drivers::L293D_Handler.
 *
 * Contrairement à crepp::tools::Motor (qui pilote directement 3 broches),
 * Motor_Driver délègue toute la commande électrique au driver L293D :
 * on "attache" le moteur à un canal (CHANNEL_A ou CHANNEL_B) d'un
 * L293D_Handler déjà initialisé. Cela permet :
 *  - de piloter 2 moteurs avec un seul objet driver partagé,
 *  - d'ajouter une rampe d'accélération / décélération logicielle,
 *  - d'inverser le sens de rotation par configuration (câblage inversé)
 *    sans toucher au reste du code.
 *
 * @badge tool
 * @badge stable
 *
 * Fonctionnalités :
 * - Attachement à un canal d'un L293D_Handler (begin)
 * - Commande de vitesse avec rampe progressive (setSpeed + update)
 * - Application immédiate optionnelle (bypass de la rampe)
 * - Inversion de sens configurable (câblage moteur inversé)
 * - Arrêt roue libre (stop) et freinage actif (brake)
 * - Lecture de l'état (vitesse cible, vitesse réelle, état moteur)
 * =========================
 */
class Motor_Driver {
public:
    /*
     * =========================
     * Constructeur / Destructeur
     * -------------------------
     * Le destructeur arrête le moteur (roue libre) s'il était attaché.
     */
    Motor_Driver();
    ~Motor_Driver();

    /*
     * =========================
     * Attachement au driver
     * -------------------------
     * Associe ce moteur à un canal d'un L293D_Handler déjà initialisé
     * (begin() du driver doit avoir été appelé au préalable).
     *
     * @param driver  Référence vers le driver L293D partagé
     * @param channel Canal du driver utilisé par ce moteur
     * @param invert  Inverse le sens logique de rotation (utile si le
     *                câblage physique du moteur est inversé)
     */
    void begin(L293D_Handler& driver, L293D_Channel channel, bool invert = false);

    /*
     * =========================
     * Commande de vitesse
     * -------------------------
     * Définit la vitesse cible du moteur. Par défaut, la vitesse est
     * atteinte progressivement via la rampe configurée (setRampRate) ;
     * il faut appeler update() régulièrement (dans loop()) pour que la
     * rampe progresse.
     *
     * @param speed     Vitesse cible de -100 à 100 (le signe donne le sens)
     * @param immediate Si true, applique la vitesse immédiatement sans rampe
     */
    void setSpeed(int8_t speed, bool immediate = false);

    /*
     * =========================
     * Mise à jour de la rampe
     * -------------------------
     * A appeler régulièrement (typiquement à chaque tour de loop()).
     * Rapproche la vitesse réelle de la vitesse cible d'au plus
     * `rampStep` points à chaque appel.
     */
    void update();

    /**
     * @brief Configure l'incrément maximal de vitesse appliqué à
     *        chaque update() (rampe d'accélération / décélération).
     * @param stepPerUpdate 0 = pas de rampe (vitesse appliquée instantanément)
     */
    void setRampRate(uint8_t stepPerUpdate);

    /**
     * @brief Arrêt roue libre immédiat (annule aussi la rampe en cours).
     */
    void stop();

    /**
     * @brief Freinage actif immédiat (court-circuit des bobines).
     */
    void brake();

    /// Vitesse cible demandée (avant application de la rampe)
    int8_t getTargetSpeed() const { return _targetSpeed; }

    /// Vitesse réellement appliquée au moteur à cet instant
    int8_t getCurrentSpeed() const { return _currentSpeed; }

    /// Etat courant du moteur (arrêté / en marche / freinage)
    MotorState getState() const { return _state; }

    /**
     * @brief Indique si begin() a été appelé avec un driver initialisé.
     */
    bool isInitialized() const { return _initialized; }

    StatusDevice getStatus() const { return _status; }

private:
    L293D_Handler* _driver = nullptr;
    L293D_Channel _channel = L293D_Channel::CHANNEL_A;
    bool _invert = false;
    bool _initialized = false;

    int8_t _targetSpeed = 0;   ///< Vitesse demandée par l'utilisateur
    int8_t _currentSpeed = 0;  ///< Vitesse réellement appliquée (après rampe)
    uint8_t _rampStep = 10;    ///< Incrément max de vitesse par update()

    MotorState _state = MotorState::STOPPED;
    StatusDevice _status = StatusDevice::DEVICE_ERROR_INIT;

    /// Applique une vitesse brute sur le driver, en tenant compte de _invert
    void applySpeed(int8_t speed);
};

/*
@example

@include
#include <crepp/drivers/L293D_Handler.h>
#include <crepp/tools/Motor_Driver.h>
@end_include

@macro
#define L293D_IN1A 2
#define L293D_IN2A 3
#define L293D_ENA  4
#define L293D_IN1B 5
#define L293D_IN2B 6
#define L293D_ENB  7
@end_macro

@instance
crepp::drivers::L293D_Handler l293d;
crepp::tools::Motor_Driver motorLeft;
crepp::tools::Motor_Driver motorRight;
@end_instance

@setup
  Serial.begin(115200);

  l293d.begin(L293D_IN1A, L293D_IN2A, L293D_ENA,
              L293D_IN1B, L293D_IN2B, L293D_ENB);

  motorLeft.begin(l293d, crepp::drivers::L293D_Channel::CHANNEL_A);
  motorRight.begin(l293d, crepp::drivers::L293D_Channel::CHANNEL_B, true); // true = sens inversé

  motorLeft.setRampRate(15);
  motorRight.setRampRate(15);
@end_setup

@loop
  motorLeft.setSpeed(100);
  motorRight.setSpeed(100);

  // La rampe doit être mise à jour régulièrement
  motorLeft.update();
  motorRight.update();

  delay(20);
@end_loop

@end_example
*/

} // namespace crepp::tools