Mastering DC Motor Control with ESP32 and L298N Driver: A Professional's Guide to Speed, Direction, and Robotic Motion

// Professional power configuration checker
bool checkL298NPowerConfig(int motorVoltage, bool jumperInPlace) {
  Serial.println("\n=== L298N POWER CONFIGURATION ANALYSIS ===");
  
  if (motorVoltage > 12 && jumperInPlace) {
    Serial.println("⚠️ WARNING: Voltage >12V with jumper IN.");
    Serial.println("  The onboard 78M05 regulator will overheat!");
    Serial.println("  Solution: Remove jumper and provide external 5V to +5V pin.");
    return false;
  }
  
  if (motorVoltage < 6 && !jumperInPlace) {
    Serial.println("⚠️ WARNING: Voltage <6V with jumper OUT.");
    Serial.println("  The L298N may not receive sufficient logic voltage.");
    Serial.println("  Solution: Replace jumper or increase motor supply.");
    return false;
  }
  
  Serial.println("✓ Power configuration appears correct.");
  Serial.print("  Motor supply: "); Serial.print(motorVoltage); Serial.println("V");
  Serial.print("  5V source: ");
  if (jumperInPlace) {
    Serial.println("Onboard regulator (from motor supply)");
  } else {
    Serial.println("External 5V supply");
  }
  
  return true;
}

// Comprehensive motor noise suppression implementation
void installMotorSuppression(int motorVoltage) {
  Serial.println("\n=== RECOMMENDED SUPPRESSION COMPONENTS ===");
  
  // 1. Bulk capacitance for current spikes
  Serial.println("1. Add 470µF-1000µF electrolytic capacitor:");
  Serial.println("   - Place directly across motor power input terminals");
  Serial.println("   - Observe polarity (positive to +V, negative to GND)");
  Serial.println("   - Handles brief current demands during startup/stalling");
  
  // 2. High-frequency noise suppression  
  Serial.println("\n2. Add 0.1µF ceramic capacitor:");
  Serial.println("   - Solder directly to motor terminals");
  Serial.println("   - Non-polarized, can be placed in either orientation");
  Serial.println("   - Filters high-frequency brush noise (10kHz-1MHz)");
  
  // 3. Snubber network for inductive spike protection
  Serial.println("\n3. Consider RC snubber network for high-power motors:");
  Serial.print("   - Resistor: "); Serial.print(10*motorVoltage); Serial.println("Ω 1W");
  Serial.println("   - Capacitor: 0.01µF 250V ceramic");
  Serial.println("   - Connect in series, place across motor terminals");
  
  // 4. Physical separation techniques
  Serial.println("\n4. Physical layout recommendations:");
  Serial.println("   - Keep motor power wires twisted together");
  Serial.println("   - Separate motor wiring from signal cables");
  Serial.println("   - Use shielded cable for long motor runs (>30cm)");
}

// Adaptive dead zone compensation for smooth low-speed operation
class AdaptiveMotorController {
private:
  int enablePin;
  int minDutyCycle;
  const int deadZoneProbeSteps = 10;
  
public:
  AdaptiveMotorController(int pin) : enablePin(pin), minDutyCycle(30) {}
  
  void calibrateDeadZone() {
    Serial.println("\n=== CALIBRATING MOTOR DEAD ZONE ===");
    Serial.println("Ensure motor can rotate freely during calibration!");
    
    int foundDeadZone = 0;
    
    for (int duty = 5; duty <= 100; duty += 5) {
      ledcWrite(enablePin, map(duty, 0, 100, 0, 255));
      delay(300);
      
      // In practice, you would measure actual rotation here
      // For this example, we'll simulate detection
      bool isRotating = (duty > 25); // Simulated detection threshold
      
      if (!isRotating && duty > foundDeadZone) {
        foundDeadZone = duty;
        Serial.print("No rotation at "); Serial.print(duty); Serial.println("% duty");
      } else if (isRotating && foundDeadZone > 0) {
        minDutyCycle = duty + 5; // Add 5% safety margin
        Serial.print("✓ Rotation begins at "); Serial.print(duty); Serial.println("%");
        Serial.print("✓ Setting minimum duty cycle to "); 
        Serial.print(minDutyCycle); Serial.println("%");
        break;
      }
    }
    
    // Safety default if calibration fails
    if (minDutyCycle < 20) {
      minDutyCycle = 30;
      Serial.println("⚠️ Using default minimum duty cycle: 30%");
    }
  }
  
  void setSpeed(int speedPercent) {
    // Constrain to valid range with dead zone compensation
    speedPercent = constrain(speedPercent, 0, 100);
    
    if (speedPercent > 0 && speedPercent < minDutyCycle) {
      speedPercent = minDutyCycle; // Jump over dead zone
    }
    
    int duty = map(speedPercent, 0, 100, 0, 255);
    ledcWrite(enablePin, duty);
    
    Serial.print("Speed set to: "); 
    Serial.print(speedPercent); 
    Serial.println("% (dead zone compensated)");
  }
};

// Professional PWM configuration based on motor type
typedef struct {
  const char* motorType;
  int optimalFrequency;
  int resolution;
  int ledcChannel;
  const char* notes;
} MotorPWMConfig;

MotorPWMConfig pwmConfigs[] = {
  {"Small brushed (3-6V)", 25000, 8, 0, "Reduces audible whine"},
  {"Medium gearmotor", 20000, 10, 1, "Better low-speed control"},
  {"High-current motor", 15000, 8, 2, "Reduces switching losses in L298N"},
  {"Coreless/vibrating", 30000, 8, 3, "Above human hearing range"},
  {"Experimental/quiet", 5000, 12, 4, "Very smooth but may cause L298N heating"}
};

void configureOptimalPWM(int enablePin, const char* motorDescription) {
  Serial.println("\n=== OPTIMAL PWM CONFIGURATION ===");
  
  MotorPWMConfig selectedConfig = pwmConfigs[0]; // Default
  
  for (int i = 0; i < sizeof(pwmConfigs)/sizeof(pwmConfigs[0]); i++) {
    if (strstr(motorDescription, pwmConfigs[i].motorType) != NULL) {
      selectedConfig = pwmConfigs[i];
      break;
    }
  }
  
  Serial.print("Selected configuration for: ");
  Serial.println(selectedConfig.motorType);
  Serial.print("Frequency: "); 
  Serial.print(selectedConfig.optimalFrequency); 
  Serial.println(" Hz");
  Serial.print("Resolution: "); 
  Serial.print(selectedConfig.resolution); 
  Serial.println(" bits");
  Serial.print("Notes: "); 
  Serial.println(selectedConfig.notes);
  
  // Apply the configuration
  ledcAttachChannel(enablePin, selectedConfig.optimalFrequency, 
                   selectedConfig.resolution, selectedConfig.ledcChannel);
  
  // Calculate and display duty cycle range
  int maxDuty = pow(2, selectedConfig.resolution) - 1;
  Serial.print("Duty cycle range: 0 to "); 
  Serial.println(maxDuty);
  Serial.print("(Equivalent to 0-100% control with ");
  Serial.print(100.0/maxDuty, 2);
  Serial.println("% granularity)");
}

┌─────────────────┐     ┌─────────────────┐
│   ESP32 Power   │     │   Motor Power   │
│   (USB/3.3V)    │     │ (Battery/PSU)   │
└────────┬────────┘     └────────┬────────┘
         │                       │
    ┌────┴───────────────────────┴────┐
    │   COMMON GROUND CONNECTION     │
    │   (Heavy gauge, short path)    │
    └─────────────────────────────────┘

// Professional brownout protection system
class BrownoutProtector {
private:
  const int brownoutThreshold = 3.0; // Voltage threshold for ESP32
  unsigned long lastBrownoutTime = 0;
  const unsigned long brownoutDebounce = 5000; // 5 seconds
  
public:
  void checkSystemVoltage() {
    // Note: ESP32 has internal brownout detection that resets the chip
    // This is a software layer for monitoring and reporting
    
    // Read internal hall effect sensor as proxy for noise level
    adc2_config_channel_atten(ADC2_CHANNEL_0, ADC_ATTEN_DB_0);
    
    int noiseLevel = 0;
    for (int i = 0; i < 10; i++) {
      int raw;
      adc2_get_raw(ADC2_CHANNEL_0, ADC_WIDTH_BIT_12, &raw);
      noiseLevel += abs(raw - 2048); // Center value
      delay(1);
    }
    noiseLevel /= 10;
    
    if (noiseLevel > 500 && millis() - lastBrownoutTime > brownoutDebounce) {
      Serial.println("\n⚠️ WARNING: High electrical noise detected!");
      Serial.println("  Possible causes:");
      Serial.println("  - Inadequate power supply current");
      Serial.println("  - Missing suppression capacitors");
      Serial.println("  - Poor grounding between systems");
      Serial.println("  - Motor stalling or overloaded");
      
      recommendSolutions(noiseLevel);
      lastBrownoutTime = millis();
    }
  }
  
  void recommendSolutions(int noiseLevel) {
    Serial.println("\n  RECOMMENDED ACTIONS:");
    
    if (noiseLevel > 800) {
      Serial.println("  1. IMMEDIATE: Add 1000µF capacitor across motor power");
      Serial.println("  2. Check motor isn't stalled or overloaded");
    }
    
    if (noiseLevel > 500) {
      Serial.println("  3. Verify all ground connections are solid");
      Serial.println("  4. Consider separate power supplies for ESP32 and motors");
    }
    
    Serial.println("  5. Add ferrite beads to motor leads if available");
    Serial.println("  6. Ensure power wires are thick enough (18-22 AWG)");
  }
};

// Production-ready DC motor controller class
class DCMotorController {
private:
  // Pin definitions
  int in1Pin, in2Pin, enablePin;
  
  // Motor state
  enum MotorState { STOPPED, FORWARD, REVERSE, BRAKING };
  MotorState currentState;
  
  // Performance tracking
  unsigned long runTime = 0;
  unsigned long startTime = 0;
  int totalDirectionChanges = 0;
  
  // Protection parameters
  const unsigned long minDirectionChangeInterval = 100; // ms
  unsigned long lastDirectionChange = 0;
  const unsigned long maxContinuousRunTime = 300000; // 5 minutes
  bool overheating = false;
  
public:
  // Constructor with pin initialization
  DCMotorController(int in1, int in2, int enable) 
    : in1Pin(in1), in2Pin(in2), enablePin(enable), currentState(STOPPED) {
    
    pinMode(in1Pin, OUTPUT);
    pinMode(in2Pin, OUTPUT);
    pinMode(enablePin, OUTPUT);
    
    // Start with motor stopped
    digitalWrite(in1Pin, LOW);
    digitalWrite(in2Pin, LOW);
    digitalWrite(enablePin, LOW);
    
    Serial.print("Motor controller initialized on pins: ");
    Serial.print(in1); Serial.print(", ");
    Serial.print(in2); Serial.print(", ");
    Serial.println(enable);
  }
  
  // Configure PWM (call once in setup)
  void configurePWM(int frequency = 30000, int resolution = 8, int channel = 0) {
    ledcAttachChannel(enablePin, frequency, resolution, channel);
    Serial.print("PWM configured: ");
    Serial.print(frequency); Serial.print("Hz, ");
    Serial.print(resolution); Serial.print("bit, channel ");
    Serial.println(channel);
  }
  
  // Safe forward movement with error checking
  bool forward(int speedPercent) {
    if (!safetyChecks("forward")) return false;
    
    speedPercent = constrain(speedPercent, 0, 100);
    int dutyCycle = map(speedPercent, 0, 100, 0, 255);
    
    digitalWrite(in1Pin, LOW);
    digitalWrite(in2Pin, HIGH);
    ledcWrite(enablePin, dutyCycle);
    
    if (currentState != FORWARD) {
      currentState = FORWARD;
      totalDirectionChanges++;
      lastDirectionChange = millis();
      if (startTime == 0) startTime = millis();
    }
    
    runTime = millis() - startTime;
    
    Serial.print("Forward: "); Serial.print(speedPercent); 
    Serial.print("%, Duty: "); Serial.println(dutyCycle);
    
    return true;
  }
  
  // Safe reverse movement
  bool reverse(int speedPercent) {
    if (!safetyChecks("reverse")) return false;
    
    speedPercent = constrain(speedPercent, 0, 100);
    int dutyCycle = map(speedPercent, 0, 100, 0, 255);
    
    digitalWrite(in1Pin, HIGH);
    digitalWrite(in2Pin, LOW);
    ledcWrite(enablePin, dutyCycle);
    
    if (currentState != REVERSE) {
      currentState = REVERSE;
      totalDirectionChanges++;
      lastDirectionChange = millis();
      if (startTime == 0) startTime = millis();
    }
    
    runTime = millis() - startTime;
    
    Serial.print("Reverse: "); Serial.print(speedPercent); 
    Serial.print("%, Duty: "); Serial.println(dutyCycle);
    
    return true;
  }
  
  // Smooth stop with optional braking
  void stop(bool brake = false) {
    if (brake) {
      // Active braking - short motor leads together
      digitalWrite(in1Pin, HIGH);
      digitalWrite(in2Pin, HIGH);
      Serial.println("Active braking engaged");
    } else {
      // Coast to stop
      digitalWrite(in1Pin, LOW);
      digitalWrite(in2Pin, LOW);
      Serial.println("Coasting to stop");
    }
    
    ledcWrite(enablePin, 0);
    currentState = STOPPED;
    
    // Record runtime if we were moving
    if (startTime > 0) {
      runTime = millis() - startTime;
      startTime = 0;
    }
  }
  
  // Gradual speed ramp for smooth acceleration
  void rampSpeed(int targetPercent, int durationMs = 1000) {
    int currentPercent = getCurrentSpeedPercent();
    int steps = 20;
    int stepTime = durationMs / steps;
    int increment = (targetPercent - currentPercent) / steps;
    
    Serial.print("Ramping from "); Serial.print(currentPercent);
    Serial.print("% to "); Serial.print(targetPercent);
    Serial.print("% over "); Serial.print(durationMs); 
    Serial.println("ms");
    
    for (int i = 1; i <= steps; i++) {
      int intermediatePercent = currentPercent + (increment * i);
      
      if (currentState == FORWARD) {
        forward(intermediatePercent);
      } else if (currentState == REVERSE) {
        reverse(intermediatePercent);
      }
      
      delay(stepTime);
    }
  }
  
  // Get motor status information
  void printStatus() {
    Serial.println("\n=== MOTOR CONTROLLER STATUS ===");
    Serial.print("State: ");
    switch(currentState) {
      case STOPPED: Serial.println("STOPPED"); break;
      case FORWARD: Serial.println("FORWARD"); break;
      case REVERSE: Serial.println("REVERSE"); break;
      case BRAKING: Serial.println("BRAKING"); break;
    }
    
    Serial.print("Total runtime: "); 
    Serial.print(runTime / 1000); Serial.println(" seconds");
    
    Serial.print("Direction changes: "); 
    Serial.println(totalDirectionChanges);
    
    Serial.print("Overheat protection: ");
    Serial.println(overheating ? "ACTIVE (motor limited)" : "Normal");
    
    if (runTime > maxContinuousRunTime / 2) {
      Serial.println("Note: Consider cooldown period for extended use");
    }
  }
  
private:
  // Comprehensive safety checks before any movement
  bool safetyChecks(const char* operation) {
    unsigned long now = millis();
    
    // Check for rapid direction changes
    if (now - lastDirectionChange < minDirectionChangeInterval) {
      Serial.print("⚠️ Safety: Too soon to change direction after ");
      Serial.print(operation); Serial.println(". Waiting...");
      return false;
    }
    
    // Check for overheating condition
    if (overheating) {
      Serial.println("⚠️ Safety: Motor controller in overheat protection");
      Serial.println("   Allow cooldown period before resuming operation");
      return false;
    }
    
    // Check maximum continuous run time
    if (runTime > maxContinuousRunTime && startTime > 0) {
      Serial.println("⚠️ Safety: Maximum continuous run time exceeded");
      Serial.println("   Stopping motor for protection");
      stop(false);
      overheating = true;
      
      // Schedule cooldown period
      delay(60000); // 60 second cooldown
      overheating = false;
      Serial.println("✓ Cooldown complete, motor ready for operation");
      
      return false;
    }
    
    return true;
  }
  
  // Estimate current speed based on duty cycle (simplified)
  int getCurrentSpeedPercent() {
    // In a real implementation, you would read back PWM duty cycle
    // For this example, we return a placeholder
    return 0; // Placeholder
  }
};

// Example usage in your main sketch
DCMotorController motor1(27, 26, 14); // IN1, IN2, EN
BrownoutProtector powerMonitor;

void setup() {
  Serial.begin(115200);
  Serial.println("\n=== PROFESSIONAL MOTOR CONTROL DEMO ===");
  
  motor1.configurePWM(25000, 8, 0);
  
  // Optional: Calibrate dead zone if needed
  // motor1.calibrateDeadZone();
  
  Serial.println("System ready.");
}

void loop() {
  // Monitor power integrity
  powerMonitor.checkSystemVoltage();
  
  // Demonstrate smooth forward acceleration
  Serial.println("\n--- Smooth forward acceleration ---");
  if (motor1.forward(30)) {
    delay(1000);
    motor1.rampSpeed(80, 2000); // Ramp to 80% over 2 seconds
    delay(2000);
  }
  
  motor1.printStatus();
  
  // Stop with braking
  Serial.println("\n--- Stopping with brake ---");
  motor1.stop(true);
  delay(1000);
  
  // Reverse movement
  Serial.println("\n--- Reverse movement ---");
  if (motor1.reverse(60)) {
    delay(3000);
  }
  
  // Gradual stop
  Serial.println("\n--- Gradual stop ---");
  motor1.rampSpeed(0, 1500);
  motor1.stop(false);
  
  motor1.printStatus();
  
  delay(5000); // Pause before repeating
}

// Professional dual-motor robot controller
class DifferentialDriveRobot {
private:
  DCMotorController leftMotor;
  DCMotorController rightMotor;
  
  // Robot parameters
  const float wheelDiameter; // cm
  const float wheelbase;     // cm (distance between wheels)
  const float maxSpeed;      // cm/s
  
  // Odometry tracking (simplified)
  float xPos = 0, yPos = 0, heading = 0; // Position and orientation
  
public:
  // Constructor
  DifferentialDriveRobot(int leftIN1, int leftIN2, int leftEN,
                         int rightIN1, int rightIN2, int rightEN,
                         float wheelDiam = 6.5, float base = 12.0, float maxSpd = 30.0)
    : leftMotor(leftIN1, leftIN2, leftEN),
      rightMotor(rightIN1, rightIN2, rightEN),
      wheelDiameter(wheelDiam), wheelbase(base), maxSpeed(maxSpd) {
    
    Serial.println("Differential drive robot initialized");
    Serial.print("Wheel diameter: "); Serial.print(wheelDiam); Serial.println(" cm");
    Serial.print("Wheelbase: "); Serial.print(base); Serial.println(" cm");
    Serial.print("Max speed: "); Serial.print(maxSpd); Serial.println(" cm/s");
  }
  
  // Configure both motors
  void configureMotors(int freq = 25000, int res = 8) {
    leftMotor.configurePWM(freq, res, 0);
    rightMotor.configurePWM(freq, res, 1);
    Serial.println("Both motors configured");
  }
  
  // Move forward with speed in cm/s
  bool moveForward(float speedCmPerSec) {
    speedCmPerSec = constrain(speedCmPerSec, 0, maxSpeed);
    int speedPercent = (speedCmPerSec / maxSpeed) * 100;
    
    Serial.print("Moving forward at "); 
    Serial.print(speedCmPerSec); 
    Serial.println(" cm/s");
    
    bool leftSuccess = leftMotor.forward(speedPercent);
    bool rightSuccess = rightMotor.forward(speedPercent);
    
    updateOdometry(speedCmPerSec, 0); // Forward, no turn
    
    return leftSuccess && rightSuccess;
  }
  
  // Move backward
  bool moveBackward(float speedCmPerSec) {
    speedCmPerSec = constrain(speedCmPerSec, 0, maxSpeed);
    int speedPercent = (speedCmPerSec / maxSpeed) * 100;
    
    Serial.print("Moving backward at "); 
    Serial.print(speedCmPerSec); 
    Serial.println(" cm/s");
    
    bool leftSuccess = leftMotor.reverse(speedPercent);
    bool rightSuccess = rightMotor.reverse(speedPercent);
    
    updateOdometry(-speedCmPerSec, 0); // Backward, no turn
    
    return leftSuccess && rightSuccess;
  }
  
  // Turn in place (zero-radius turn)
  bool turnInPlace(float degrees, float speedPercent = 40) {
    // Calculate required motor movements for turn
    float distancePerWheel = (abs(degrees) / 360.0) * PI * wheelbase;
    float timeSeconds = distancePerWheel / ((speedPercent/100.0) * maxSpeed);
    
    Serial.print("Turning "); Serial.print(degrees); 
    Serial.print(" degrees over "); Serial.print(timeSeconds); 
    Serial.println(" seconds");
    
    if (degrees > 0) {
      // Turn right: left forward, right backward
      leftMotor.forward(speedPercent);
      rightMotor.reverse(speedPercent);
    } else {
      // Turn left: right forward, left backward
      rightMotor.forward(speedPercent);
      leftMotor.reverse(speedPercent);
    }
    
    delay(timeSeconds * 1000);
    
    // Stop both motors
    leftMotor.stop(false);
    rightMotor.stop(false);
    
    // Update heading
    heading += radians(degrees);
    while (heading > 2*PI) heading -= 2*PI;
    while (heading < 0) heading += 2*PI;
    
    Serial.print("New heading: "); 
    Serial.print(degrees(heading)); 
    Serial.println(" degrees");
    
    return true;
  }
  
  // Arc turn (one wheel slower)
  bool arcTurn(float turnRadius, float speedPercent) {
    // Calculate speed differential for arc turn
    float leftSpeed = speedPercent * (turnRadius - wheelbase/2) / turnRadius;
    float rightSpeed = speedPercent * (turnRadius + wheelbase/2) / turnRadius;
    
    // Constrain to valid range
    leftSpeed = constrain(leftSpeed, 0, 100);
    rightSpeed = constrain(rightSpeed, 0, 100);
    
    Serial.print("Arc turn with radius "); Serial.print(turnRadius);
    Serial.print("cm, speeds L:"); Serial.print(leftSpeed);
    Serial.print("%, R:"); Serial.print(rightSpeed); Serial.println("%");
    
    leftMotor.forward(leftSpeed);
    rightMotor.forward(rightSpeed);
    
    // Calculate turning rate for odometry
    float angularVelocity = (maxSpeed * (speedPercent/100.0)) / turnRadius;
    updateOdometry(maxSpeed * (speedPercent/100.0), angularVelocity);
    
    return true;
  }
  
  // Stop both motors
  void stopRobot(bool brake = false) {
    Serial.println("Stopping robot");
    leftMotor.stop(brake);
    rightMotor.stop(brake);
  }
  
  // Get estimated position
  void printPosition() {
    Serial.println("\n=== ROBOT POSITION ESTIMATE ===");
    Serial.print("X: "); Serial.print(xPos, 1); Serial.println(" cm");
    Serial.print("Y: "); Serial.print(yPos, 1); Serial.println(" cm");
    Serial.print("Heading: "); Serial.print(degrees(heading), 1); 
    Serial.println(" degrees");
    
    // Calculate distance from origin
    float distance = sqrt(xPos*xPos + yPos*yPos);
    Serial.print("Distance from start: "); 
    Serial.print(distance, 1); 
    Serial.println(" cm");
  }
  
  // Simple obstacle avoidance routine
  void avoidObstacle(int distanceSensorReading) {
    Serial.println("\n=== OBSTACLE AVOIDANCE ROUTINE ===");
    
    if (distanceSensorReading < 20) {
      Serial.println("Obstacle detected! Taking evasive action.");
      
      // Stop
      stopRobot(true);
      delay(500);
      
      // Back up a bit
      moveBackward(15);
      delay(1000);
      stopRobot(true);
      delay(300);
      
      // Turn right 45 degrees
      turnInPlace(45, 50);
      delay(500);
      
      // Move forward
      moveForward(25);
      delay(1500);
      
      // Turn left 45 degrees to resume original heading
      turnInPlace(-45, 50);
      
      Serial.println("Obstacle avoidance complete");
    } else {
      Serial.println("Path clear");
    }
  }
  
private:
  // Simplified odometry update (for illustration)
  void updateOdometry(float linearVelocity, float angularVelocity) {
    static unsigned long lastUpdate = millis();
    unsigned long now = millis();
    float dt = (now - lastUpdate) / 1000.0; // Convert to seconds
    
    if (dt > 0.1) { // Update at most every 100ms
      // Simple dead reckoning (improve with encoders in real implementation)
      xPos += linearVelocity * cos(heading) * dt;
      yPos += linearVelocity * sin(heading) * dt;
      heading += angularVelocity * dt;
      
      lastUpdate = now;
    }
  }
};

// Thermal management system for L298N
class ThermalManager {
private:
  const int overheatThreshold = 60; // °C (L298N max is ~130°C, but derate for safety)
  const int warningThreshold = 50;   // °C
  bool overheatProtectionActive = false;
  
  // Simulated temperature reading (in real system, use thermistor or IR sensor)
  float simulatedTemperature = 25.0; // Starting at room temperature
  
public:
  void update(float motorCurrent, bool isMoving) {
    // Simulate temperature change based on operating conditions
    if (isMoving) {
      // Temperature rise proportional to current squared (I²R losses)
      float heatInput = motorCurrent * motorCurrent * 0.05;
      simulatedTemperature += heatInput;
      
      // Natural cooling (proportional to temperature difference with ambient)
      float cooling = (simulatedTemperature - 25.0) * 0.01;
      simulatedTemperature -= cooling;
    } else {
      // Cooling when idle
      simulatedTemperature -= (simulatedTemperature - 25.0) * 0.02;
    }
    
    // Constrain to realistic range
    simulatedTemperature = constrain(simulatedTemperature, 20.0, 100.0);
    
    // Check thresholds
    if (simulatedTemperature > overheatThreshold && !overheatProtectionActive) {
      Serial.println("\n🔥 OVERHEAT PROTECTION ACTIVATED!");
      Serial.print("Temperature: "); 
      Serial.print(simulatedTemperature, 1); 
      Serial.println("°C");
      Serial.println("Reducing motor power to 50% until cooled");
      overheatProtectionActive = true;
    }
    
    if (overheatProtectionActive && simulatedTemperature < warningThreshold) {
      Serial.println("\n✓ Temperature normalized, full power restored");
      overheatProtectionActive = false;
    }
  }
  
  bool isPowerLimited() {
    return overheatProtectionActive;
  }
  
  float getTemperature() {
    return simulatedTemperature;
  }
  
  void printThermalStatus() {
    Serial.println("\n=== THERMAL MANAGEMENT STATUS ===");
    Serial.print("Current temperature: "); 
    Serial.print(simulatedTemperature, 1); 
    Serial.println("°C");
    
    if (simulatedTemperature > warningThreshold) {
      Serial.print("Status: ");
      if (simulatedTemperature > overheatThreshold) {
        Serial.println("OVERHEAT - POWER LIMITED");
      } else {
        Serial.println("WARNING - APPROACHING LIMIT");
      }
      
      Serial.println("Recommended actions:");
      Serial.println("1. Ensure adequate ventilation around L298N");
      Serial.println("2. Add heatsink to L298N (aluminum plate)");
      Serial.println("3. Reduce motor duty cycle");
      Serial.println("4. Add cooling fan if sustained operation needed");
    } else {
      Serial.println("Status: NORMAL");
    }
  }
};

void recommendMotorDriver(float voltage, float current, String application) {
  Serial.println("\n=== MOTOR DRIVER RECOMMENDATION ===");
  Serial.print("Requirements: "); Serial.print(voltage); Serial.print("V, ");
  Serial.print(current); Serial.print("A, "); Serial.println(application);
  
  if (current <= 2 && voltage <= 12 && application.indexOf("learning") >= 0) {
    Serial.println("✓ RECOMMENDATION: L298N");
    Serial.println("  Reasons: Perfect for learning, widely available,");
    Serial.println("  good documentation, handles most hobby motors");
  } else if (current <= 1.2 && voltage <= 10) {
    Serial.println("✓ RECOMMENDATION: TB6612FNG");
    Serial.println("  Reasons: More efficient, less heat, smaller footprint");
  } else if (current > 2 && current <= 5) {
    Serial.println("✓ RECOMMENDATION: VNH5019");
    Serial.println("  Reasons: Higher current capacity, built-in protection");
  } else if (current > 5) {
    Serial.println("✓ RECOMMENDATION: BTS7960 or external MOSFET controller");
    Serial.println("  Reasons: Very high current capability");
  } else {
    Serial.println("✓ RECOMMENDATION: L298N");
    Serial.println("  Reasons: Good all-around choice for general use");
  }
}

void runMotorDiagnostic(int motorAPins[3], int motorBPins[3]) {
  Serial.println("\n=== COMPREHENSIVE MOTOR SYSTEM DIAGNOSTIC ===");
  Serial.println("Running tests...");
  
  // Test 1: Power supply check
  Serial.println("\n1. POWER SUPPLY CHECK:");
  // In practice, you would read actual voltages here
  Serial.println("   [Placeholder: Connect voltmeter to measure]");
  Serial.println("   - Motor supply: Should be 6-12V");
  Serial.println("   - ESP32 3.3V: Should be stable 3.3V ±5%");
  Serial.println("   - Common ground: Verify continuity");
  
  // Test 2: Signal verification
  Serial.println("\n2. SIGNAL VERIFICATION:");
  for (int i = 0; i < 3; i++) {
    Serial.print("   Motor A Pin "); Serial.print(motorAPins[i]);
    Serial.println(": Check connection to L298N");
  }
  
  // Test 3: L298N jumper configuration
  Serial.println("\n3. L298N CONFIGURATION:");
  Serial.println("   - Enable jumper: Should be REMOVED for speed control");
  Serial.println("   - 5V jumper: IN for <12V supply, OUT for >12V");
  
  // Test 4: Motor direct test
  Serial.println("\n4. MOTOR DIRECT TEST:");
  Serial.println("   Disconnect from L298N, connect directly to 6V battery.");
  Serial.println("   Motor should spin freely. If not, motor may be faulty.");
  
  // Test 5: PWM signal test
  Serial.println("\n5. PWM SIGNAL TEST (requires oscilloscope):");
  Serial.println("   Check enable pin for clean PWM signal at set frequency");
  
  Serial.println("\nDiagnostic complete. Address any issues found.");
}