How to Program Your Elegoo Smart Robot Car V3.0: Speed, Remote Control, and Obstacle Detection

Are you looking to take full control of your Elegoo Smart Robot Car V3.0? This guide will walk you through enhancing your robot car’s programming, specifically focusing on increasing speed, integrating IR remote control, and understanding obstacle detection. We’ll break down the provided Arduino code and show you how to make these exciting modifications.

Understanding the Base Code for Elegoo Smart Robot Car V3.0

The foundation of our robot car’s intelligence lies in the Arduino code. Let’s examine the essential components of the provided sketch:

• Line Tracking: The code defines LT_R, LT_M, and LT_L connected to digital pins 10, 4, and 2 respectively. These are likely the right, middle, and left line tracking sensors. The !digitalRead() suggests these sensors are active-low, meaning they read LOW when a line is detected.
• Sonar (Ultrasonic Sensor): Pins Echo (A4) and Trig (A5) are defined for the ultrasonic sensor. This sensor is used for obstacle detection by measuring distance.
• Servo Motor: Pin SERVO_PIN (3) controls a servo motor, potentially used for steering or sensor positioning, although its function isn’t explicitly used in the provided loop() function.
• Motor Control: Pins ENB (5), IN1 (7), IN2 (8), IN3 (9), IN4 (11), and ENA (6) are used to control the robot car’s motors via a motor driver. ENA and ENB likely control motor speed via PWM (Pulse Width Modulation), and IN1-IN4 control motor direction.
• Speed Control: The carSpeed variable is set to 200. This variable is used in analogWrite() to set the motor speed, suggesting a PWM range of 0-255 (typical for Arduino).
• Distance Limit: distanceLimit is set to 25, likely representing the obstacle detection distance in centimeters.

The forward(), back(), left(), right(), and stop() functions define basic car movements by controlling the motor pins. The getDistance() function uses the ultrasonic sensor to measure the distance to an obstacle. The loop() function continuously measures distance and reacts if an obstacle is closer than distanceLimit.

Increasing the Robot Car’s Speed

To increase the maximum speed of your Elegoo Smart Robot Car V3.0, you need to modify the carSpeed variable.

1. Locate carSpeed: In your code, find the line #define carSpeed 200.
2. Increase the Value: The carSpeed variable is currently set to 200. To increase the speed, simply increase this number. The maximum value is 255, which corresponds to 100% duty cycle for the PWM signal controlling the motor speed.
3. Experiment Safely: Start by incrementally increasing the value, for example, to 230 or 240, and test the car’s performance. Gradually increase it until you reach the desired speed or the car becomes difficult to control, or you observe motor performance issues.

#define carSpeed 240 // Increased car speed

Important Note: Increasing the speed too much might reduce the car’s ability to accurately follow lines or react to obstacles in time. Test thoroughly after making changes.

Implementing IR Remote Control

To control your robot car with the included IR remote, you’ll need to integrate IR remote functionality into your code. Here’s how you can do it, focusing on using button ‘1’ to start line tracking and ‘OK’ to stop:

1. Include the IR Remote Library: You’ll need an Arduino library to decode IR remote signals. A popular choice is IRremote.h. If you haven’t already, install this library via the Arduino Library Manager (Sketch > Include Library > Manage Libraries…). Add #include <IRremote.h> at the beginning of your code.

2. Define IR Receiver Pin: Choose a digital pin for the IR receiver. Let’s assume you connect it to pin 12. Define this pin in your code: #define RECV_PIN 12.

3. Initialize IR Receiver: In the setup() function, initialize the IR receiver:

   #include <IRremote.h>
   
   #define RECV_PIN 12
   IRrecv irrecv(RECV_PIN);
   decode_results results;
   
   void setup() {
     // ... your existing setup code ...
     irrecv.enableIRIn(); // Start the receiver
   }

4. Read IR Remote Signals in loop(): In your loop() function, you need to continuously check for received IR signals and react to specific button presses.

   void loop() {
     if (irrecv.decode(&results)) {
       if (results.value == 0xFF38C7) { // Code for button '1' (Example, may vary)
         // Start line tracking and obstacle avoidance logic here
         sonarDistance = getDistance();
         if(sonarDistance > distanceLimit){
           // Line tracking logic (replace with your line tracking code)
           if(LT_M && !LT_R && !LT_L) forward();
           else if(LT_R && !LT_M && !LT_L) right();
           else if(LT_L && !LT_M && !LT_R) left();
           else stop();
         } else if (sonarDistance <= distanceLimit && sonarDistance > 0){
           analogWrite(ENA, 100); // Reduced speed for obstacle approach
           analogWrite(ENB, 100);
           forward();
           delay(100);
         } else {
           stop();
         }
       } else if (results.value == 0xFF02FD) { // Code for 'OK' button (Example, may vary)
         stop(); // Stop the car
       }
       irrecv.resume(); // Receive the next value
     }
     // ... rest of your loop code (if any) ...
   }

5. Determine IR Button Codes: You need to find the specific hexadecimal codes sent by your IR remote for button ‘1’ and the ‘OK’ button. You can use a simple sketch to print the received codes to the Serial Monitor. A basic IR receiver test sketch is usually included with the IRremote library examples. Upload this example sketch, open the Serial Monitor, and press the ‘1’ and ‘OK’ buttons on your remote to see their respective codes. Replace 0xFF38C7 and 0xFF02FD in the code above with the codes you obtain from your remote.

Understanding and Adjusting Obstacle Detection

Reaction Time and Distance: The robot car’s reaction time to obstacles depends on how frequently the loop() function runs and how quickly the ultrasonic sensor readings are processed. The distance at which the car starts to slow down is determined by distanceLimit.

• distanceLimit: This constant, set to 25, defines the threshold distance in centimeters. When the getDistance() function returns a value less than or equal to distanceLimit, the obstacle avoidance behavior is triggered.
• Reaction Distance: To change the obstacle detection distance, simply modify the value of distanceLimit. Increase it to make the car react to obstacles further away, and decrease it to react closer.

const int distanceLimit = 30; // Increased obstacle detection distance to 30cm

• Reaction Time: The reaction time is inherently linked to the speed of your Arduino’s loop() execution. The provided code measures the distance in each loop iteration. The time taken for one loop iteration is the fundamental reaction time component. You can’t directly change the “reaction time” in this simple code in milliseconds, but making your loop more efficient (if it were doing much more processing) could slightly improve responsiveness. For this code, the reaction time is primarily determined by the sensor reading and the loop frequency, which is generally very fast.

Measuring Reaction Distance: To empirically find the reaction distance, you can:

1. Place an obstacle in front of the robot car.
2. Start the robot car moving towards the obstacle.
3. Carefully measure the distance between the car and the obstacle when the car starts to slow down. This is your approximate reaction distance for the current distanceLimit and car speed.

By adjusting distanceLimit and experimenting, you can fine-tune your Elegoo Smart Robot Car V3.0’s obstacle detection behavior to suit your needs. Remember to always test your code in a safe environment and make incremental changes to understand their effects.