robot_car.ino

/*
 * ESP32 Robot Car with Bluetooth Control
 * 
 * Controls a 4-motor robot car using:
 * - ESP32 microcontroller
 * - HC-06 Bluetooth module
 * - 2x BTS7960 motor drivers (left and right)
 * - 4x 12V 500 RPM DC gear motors
 * 
 * Command Protocol:
 * Movement: F (Forward), B (Back), L (Left), R (Right)
 *          G (Forward Left), 1 (Forward Right)
 *          H (Back Left), J (Back Right), S (Stop)
 * Speed:   0-9 (0-90% in 10% steps), q (100%), D (Stop All)
 */

#include "BluetoothSerial.h"

// Check if Bluetooth is available
#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
#error "Bluetooth is not enabled! Please run `make menuconfig` to enable it"
#endif

// Bluetooth Serial object
BluetoothSerial SerialBT;

// Left Motor Driver Pins (BTS7960)
#define LEFT_L_EN  25
#define LEFT_R_EN  26
#define LEFT_LPWM  27
#define LEFT_RPWM  14

// Right Motor Driver Pins (BTS7960)
#define RIGHT_L_EN 33
#define RIGHT_R_EN 32
#define RIGHT_LPWM 13
#define RIGHT_RPWM 12

// PWM Channel Definitions
#define LEFT_LPWM_CHANNEL  0
#define LEFT_RPWM_CHANNEL  1
#define RIGHT_LPWM_CHANNEL 2
#define RIGHT_RPWM_CHANNEL 3

// PWM Settings
#define PWM_FREQUENCY  1000  // 1 kHz
#define PWM_RESOLUTION 8     // 8-bit (0-255)

// Current speed (0-255, updated by speed commands)
int currentSpeed = 128;  // Default to 50% speed

// Current movement state
char currentMovement = 'S';  // S = Stop

void setup() {
  // Initialize Serial for debugging
  Serial.begin(115200);
  Serial.println("ESP32 Robot Car Starting...");

  // Initialize Bluetooth
  SerialBT.begin("ESP32_RobotCar"); // Bluetooth device name
  Serial.println("Bluetooth device is ready to pair!");
  Serial.println("Device name: ESP32_RobotCar");

  // Configure Left Motor Driver Pins
  pinMode(LEFT_L_EN, OUTPUT);
  pinMode(LEFT_R_EN, OUTPUT);
  pinMode(LEFT_LPWM, OUTPUT);
  pinMode(LEFT_RPWM, OUTPUT);

  // Configure Right Motor Driver Pins
  pinMode(RIGHT_L_EN, OUTPUT);
  pinMode(RIGHT_R_EN, OUTPUT);
  pinMode(RIGHT_LPWM, OUTPUT);
  pinMode(RIGHT_RPWM, OUTPUT);

  // Initialize all pins to LOW (motors stopped)
  digitalWrite(LEFT_L_EN, LOW);
  digitalWrite(LEFT_R_EN, LOW);
  digitalWrite(RIGHT_L_EN, LOW);
  digitalWrite(RIGHT_R_EN, LOW);
  analogWrite(LEFT_LPWM, 0);
  analogWrite(LEFT_RPWM, 0);
  analogWrite(RIGHT_LPWM, 0);
  analogWrite(RIGHT_RPWM, 0);

  // Setup PWM channels for ESP32
  ledcSetup(LEFT_LPWM_CHANNEL, PWM_FREQUENCY, PWM_RESOLUTION);
  ledcSetup(LEFT_RPWM_CHANNEL, PWM_FREQUENCY, PWM_RESOLUTION);
  ledcSetup(RIGHT_LPWM_CHANNEL, PWM_FREQUENCY, PWM_RESOLUTION);
  ledcSetup(RIGHT_RPWM_CHANNEL, PWM_FREQUENCY, PWM_RESOLUTION);

  // Attach PWM channels to pins
  ledcAttachPin(LEFT_LPWM, LEFT_LPWM_CHANNEL);
  ledcAttachPin(LEFT_RPWM, LEFT_RPWM_CHANNEL);
  ledcAttachPin(RIGHT_LPWM, RIGHT_LPWM_CHANNEL);
  ledcAttachPin(RIGHT_RPWM, RIGHT_RPWM_CHANNEL);

  // Stop all motors initially
  stopMotors();

  Serial.println("Setup complete! Waiting for Bluetooth commands...");
}

void loop() {
  // Check for incoming Bluetooth data
  if (SerialBT.available()) {
    char command = SerialBT.read();
    Serial.print("Received command: ");
    Serial.println(command);
    
    // Process the command
    processCommand(command);
  }
  
  // Small delay to prevent excessive CPU usage
  delay(10);
}

void processCommand(char cmd) {
  // Convert to uppercase for case-insensitive commands
  cmd = toupper(cmd);
  
  switch (cmd) {
    // Movement Commands
    case 'F':  // Forward
      moveForward();
      currentMovement = 'F';
      break;
      
    case 'B':  // Backward
      moveBackward();
      currentMovement = 'B';
      break;
      
    case 'L':  // Turn Left
      turnLeft();
      currentMovement = 'L';
      break;
      
    case 'R':  // Turn Right
      turnRight();
      currentMovement = 'R';
      break;
      
    case 'G':  // Forward Left
      forwardLeft();
      currentMovement = 'G';
      break;
      
    case '1':  // Forward Right (Note: '1' conflicts with Speed 10% - movement takes precedence)
      forwardRight();
      currentMovement = '1';
      break;
      
    case 'H':  // Back Left
      backLeft();
      currentMovement = 'H';
      break;
      
    case 'J':  // Back Right
      backRight();
      currentMovement = 'J';
      break;
      
    case 'S':  // Stop
      stopMotors();
      currentMovement = 'S';
      break;
      
    // Speed Control Commands
    case '0':  // Speed 0%
      setSpeed(0);
      break;
      
    // Note: '1' is used for Forward Right movement
    // Speed 10% can be achieved by sending '0' then '2' and adjusting, or use default speed
    // Alternative: Use a Bluetooth RC app that sends different codes for speed vs movement
      
    case '2':  // Speed 20%
      setSpeed(51);  // 20% of 255 ≈ 51
      break;
      
    case '3':  // Speed 30%
      setSpeed(77);  // 30% of 255 ≈ 77
      break;
      
    case '4':  // Speed 40%
      setSpeed(102);  // 40% of 255 ≈ 102
      break;
      
    case '5':  // Speed 50%
      setSpeed(128);  // 50% of 255 = 128
      break;
      
    case '6':  // Speed 60%
      setSpeed(153);  // 60% of 255 ≈ 153
      break;
      
    case '7':  // Speed 70%
      setSpeed(179);  // 70% of 255 ≈ 179
      break;
      
    case '8':  // Speed 80%
      setSpeed(204);  // 80% of 255 ≈ 204
      break;
      
    case '9':  // Speed 90%
      setSpeed(230);  // 90% of 255 ≈ 230
      break;
      
    case 'Q':  // Speed 100%
    case 'q':
      setSpeed(255);  // 100% of 255 = 255
      break;
      
    case 'D':  // Stop All (Emergency Stop)
      stopMotors();
      currentSpeed = 128;  // Reset to default speed
      currentMovement = 'S';
      Serial.println("Emergency Stop - All motors stopped");
      break;
      
    default:
      // Unknown command - stop motors for safety
      Serial.print("Unknown command: ");
      Serial.println(cmd);
      stopMotors();
      break;
  }
}

// Set motor speed (0-255)
void setSpeed(int speed) {
  if (speed < 0) speed = 0;
  if (speed > 255) speed = 255;
  
  currentSpeed = speed;
  Serial.print("Speed set to: ");
  Serial.print((speed * 100) / 255);
  Serial.println("%");
  
  // Reapply current movement with new speed
  if (currentMovement != 'S') {
    processCommand(currentMovement);
  }
}

// Move Forward - Both sides forward at current speed
void moveForward() {
  // Enable both sides
  digitalWrite(LEFT_L_EN, HIGH);
  digitalWrite(LEFT_R_EN, LOW);
  digitalWrite(RIGHT_L_EN, HIGH);
  digitalWrite(RIGHT_R_EN, LOW);
  
  // Set PWM for forward direction
  ledcWrite(LEFT_LPWM_CHANNEL, currentSpeed);
  ledcWrite(LEFT_RPWM_CHANNEL, 0);
  ledcWrite(RIGHT_LPWM_CHANNEL, currentSpeed);
  ledcWrite(RIGHT_RPWM_CHANNEL, 0);
  
  Serial.println("Moving Forward");
}

// Move Backward - Both sides backward at current speed
void moveBackward() {
  // Enable both sides
  digitalWrite(LEFT_L_EN, LOW);
  digitalWrite(LEFT_R_EN, HIGH);
  digitalWrite(RIGHT_L_EN, LOW);
  digitalWrite(RIGHT_R_EN, HIGH);
  
  // Set PWM for backward direction
  ledcWrite(LEFT_LPWM_CHANNEL, 0);
  ledcWrite(LEFT_RPWM_CHANNEL, currentSpeed);
  ledcWrite(RIGHT_LPWM_CHANNEL, 0);
  ledcWrite(RIGHT_RPWM_CHANNEL, currentSpeed);
  
  Serial.println("Moving Backward");
}

// Turn Left - Right forward, left backward
void turnLeft() {
  // Right side forward, left side backward
  digitalWrite(LEFT_L_EN, LOW);
  digitalWrite(LEFT_R_EN, HIGH);
  digitalWrite(RIGHT_L_EN, HIGH);
  digitalWrite(RIGHT_R_EN, LOW);
  
  ledcWrite(LEFT_LPWM_CHANNEL, 0);
  ledcWrite(LEFT_RPWM_CHANNEL, currentSpeed);
  ledcWrite(RIGHT_LPWM_CHANNEL, currentSpeed);
  ledcWrite(RIGHT_RPWM_CHANNEL, 0);
  
  Serial.println("Turning Left");
}

// Turn Right - Left forward, right backward
void turnRight() {
  // Left side forward, right side backward
  digitalWrite(LEFT_L_EN, HIGH);
  digitalWrite(LEFT_R_EN, LOW);
  digitalWrite(RIGHT_L_EN, LOW);
  digitalWrite(RIGHT_R_EN, HIGH);
  
  ledcWrite(LEFT_LPWM_CHANNEL, currentSpeed);
  ledcWrite(LEFT_RPWM_CHANNEL, 0);
  ledcWrite(RIGHT_LPWM_CHANNEL, 0);
  ledcWrite(RIGHT_RPWM_CHANNEL, currentSpeed);
  
  Serial.println("Turning Right");
}

// Forward Left - Right full speed, left reduced speed
void forwardLeft() {
  digitalWrite(LEFT_L_EN, HIGH);
  digitalWrite(LEFT_R_EN, LOW);
  digitalWrite(RIGHT_L_EN, HIGH);
  digitalWrite(RIGHT_R_EN, LOW);
  
  // Right side at full speed, left side at reduced speed (50%)
  int leftSpeed = currentSpeed / 2;
  ledcWrite(LEFT_LPWM_CHANNEL, leftSpeed);
  ledcWrite(LEFT_RPWM_CHANNEL, 0);
  ledcWrite(RIGHT_LPWM_CHANNEL, currentSpeed);
  ledcWrite(RIGHT_RPWM_CHANNEL, 0);
  
  Serial.println("Moving Forward Left");
}

// Forward Right - Left full speed, right reduced speed
void forwardRight() {
  digitalWrite(LEFT_L_EN, HIGH);
  digitalWrite(LEFT_R_EN, LOW);
  digitalWrite(RIGHT_L_EN, HIGH);
  digitalWrite(RIGHT_R_EN, LOW);
  
  // Left side at full speed, right side at reduced speed (50%)
  int rightSpeed = currentSpeed / 2;
  ledcWrite(LEFT_LPWM_CHANNEL, currentSpeed);
  ledcWrite(LEFT_RPWM_CHANNEL, 0);
  ledcWrite(RIGHT_LPWM_CHANNEL, rightSpeed);
  ledcWrite(RIGHT_RPWM_CHANNEL, 0);
  
  Serial.println("Moving Forward Right");
}

// Back Left - Right backward full, left backward reduced
void backLeft() {
  digitalWrite(LEFT_L_EN, LOW);
  digitalWrite(LEFT_R_EN, HIGH);
  digitalWrite(RIGHT_L_EN, LOW);
  digitalWrite(RIGHT_R_EN, HIGH);
  
  // Right side backward at full speed, left side backward at reduced speed (50%)
  int leftSpeed = currentSpeed / 2;
  ledcWrite(LEFT_LPWM_CHANNEL, 0);
  ledcWrite(LEFT_RPWM_CHANNEL, leftSpeed);
  ledcWrite(RIGHT_LPWM_CHANNEL, 0);
  ledcWrite(RIGHT_RPWM_CHANNEL, currentSpeed);
  
  Serial.println("Moving Back Left");
}

// Back Right - Left backward full, right backward reduced
void backRight() {
  digitalWrite(LEFT_L_EN, LOW);
  digitalWrite(LEFT_R_EN, HIGH);
  digitalWrite(RIGHT_L_EN, LOW);
  digitalWrite(RIGHT_R_EN, HIGH);
  
  // Left side backward at full speed, right side backward at reduced speed (50%)
  int rightSpeed = currentSpeed / 2;
  ledcWrite(LEFT_LPWM_CHANNEL, 0);
  ledcWrite(LEFT_RPWM_CHANNEL, currentSpeed);
  ledcWrite(RIGHT_LPWM_CHANNEL, 0);
  ledcWrite(RIGHT_RPWM_CHANNEL, rightSpeed);
  
  Serial.println("Moving Back Right");
}

// Stop All Motors
void stopMotors() {
  // Disable all motor drivers
  digitalWrite(LEFT_L_EN, LOW);
  digitalWrite(LEFT_R_EN, LOW);
  digitalWrite(RIGHT_L_EN, LOW);
  digitalWrite(RIGHT_R_EN, LOW);
  
  // Set all PWM to 0
  ledcWrite(LEFT_LPWM_CHANNEL, 0);
  ledcWrite(LEFT_RPWM_CHANNEL, 0);
  ledcWrite(RIGHT_LPWM_CHANNEL, 0);
  ledcWrite(RIGHT_RPWM_CHANNEL, 0);
  
  Serial.println("Motors Stopped");
}